สร้าง AI Agent แบบ Human-in-the-Loop ด้วย Ollama + LangGraph ปลอดภัย 100% ออฟไลน์

ลองนึกภาพดูครับ... คุณสั่งให้ AI จัดระเบียบไฟล์ในเซิร์ฟเวอร์ แต่มันเข้าใจผิดและลบไฟล์ฐานข้อมูลลูกค้าทิ้งหมด หรือสั่งให้มันจ่ายเงินค่าสัญญา แต่มันโอนไปผิดบัญชีหลักล้านบาท เสียวไหมล่ะ? นี่คือเหตุผลว่าทำไม AI Agent ที่ทำงานอัตโนมัติเต็มรูปแบบ (Full Autopilot) อาจไม่ใช่คำตอบที่ดีที่สุดสำหรับงานที่มีความเสี่ยงสูง

ทำไมเราต้องมี Human-in-the-Loop (HITL)?

Human-in-the-Loop หรือ HITL คือการออกแบบระบบให้ AI หยุดชะงักและขออนุมัติจากมนุษย์ก่อนที่จะลงมือทำสิ่งที่ "สำคัญ" หรือ "ไม่สามารถย้อนกลับได้" (Irreversible Actions) เช่น การลบไฟล์ การโอนเงิน หรือการส่งอีเมลหาผู้ใช้ทั้งบริษัท

สำหรับองค์กรในไทย โดยเฉพาะธุรกิจที่ต้องระวังเรื่อง PDPA (พ.ร.บ.คุ้มครองข้อมูลส่วนบุคคล) การส่งข้อมูลลูกค้าขึ้นไปบน Cloud AI อย่าง ChatGPT อาจเป็นเรื่องยากและมีความเสี่ยง ดังนั้น การใช้ Ollama เพื่อรันโมเดล LLM แบบ 100% ออฟไลน์ในเครื่องของเราเอง จึงเป็นทางออกที่ปลอดภัยและตอบโจทย์ที่สุดครับ

วันนี้เราจะมาใช้ LangGraph ร่วมกับ Ollama เพื่อสร้าง AI Agent ที่ฉลาด แต่รู้จักหยุดคิดและขออนุมัติก่อนทำลายล้างกันครับ

เตรียมเครื่องมือให้พร้อม

ก่อนเริ่มเขียนโค้ด เราต้องมีเครื่องมือดังนี้:

1. Ollama: ติดตั้งจาก ollama.com และดาวน์โหลดโมเดลที่รองรับการเรียกฟังก์ชัน (Tool Calling) ได้ดี เช่น Llama 3.1 หรือ Qwen 2.5
2. Python 3.10+
3. Library: langchain, langgraph, langchain-ollama

เปิด Terminal แล้วรันคำสั่งนี้ได้เลย:

ollama pull llama3.1
pip install langchain langgraph langchain-ollama

ทำความเข้าใจ LangGraph

LangGraph คือไลบรารีสำหรับสร้าง Stateful Multi-Actor Applications หรือพูดง่ายๆ คือการสร้างกราฟ (Graph) ของการทำงาน AI ที่มี "สถานะ" (State) และ "ทางแยก" (Edges) ชัดเจน

แนวคิดหลักมี 3 ส่วน:

• State: ตัวแปรที่เก็บข้อมูลระหว่างทาง (เช่น ข้อความที่ผู้ใช้พิมพ์, คำสั่งที่ AI ต้องการทำ)
• Nodes: ฟังก์ชันการทำงาน (เช่น โหนด AI คิดต่อ, โหนดมนุษย์อนุมัติ, โหนดลบไฟล์)
• Edges: เส้นเชื่อมระหว่างโหนด ที่อาจจะเป็นเส้นตรงไป หรือเส้นที่มีเงื่อนไข (Conditional Edge)

เริ่มเขียนโค้ด AI Agent กัน

เราจะสร้างเอเจนต์ที่มีหน้าที่จัดการไฟล์ โดยถ้ามันต้องการ "ลบไฟล์" มันจะต้องหยุดและถามมนุษย์ก่อนครับ

1. กำหนด State ของระบบ

from typing import TypedDict, Annotated, List
import operator

class AgentState(TypedDict):
    messages: Annotated[List[str], operator.add]
    pending_action: str
    approved: bool

2. สร้างโหนด AI (Reasoning Node)

โหนดนี้จะใช้ Ollama ในการวิเคราะห์ว่าผู้ใช้ต้องการอะไร และกำหนดคำสั่ง (Action) ที่จะทำ

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1", temperature=0)

def ai_node(state: AgentState):
    user_input = state["messages"][-1]
    # จำลองการวิเคราะห์คำสั่ง (ในทางปฏิบัติควรใช้ Tool Calling)
    if "ลบไฟล์" in user_input:
        action = f"ต้องการลบไฟล์: {user_input.split('ลบไฟล์')[1].strip()}"
        return {"pending_action": action, "messages": ["AI: กำลังรออนุมัติเพื่อ" + action]}
    else:
        return {"pending_action": "", "messages": ["AI: รับทราบครับ ทำงานเรียบร้อย"]}

3. สร้างโหนด Human-in-the-Loop (Approval Node)

โหนดนี้จะเป็นจุดที่ระบบหยุดรอการตอบกลับจากมนุษย์

def human_approval_node(state: AgentState):
    action = state["pending_action"]
    print(f"\n[ระบบต้องการอนุมัติ] {action}")
    user_input = input("คุณยอมรับหรือไม่? (y/n): ")
    approved = user_input.lower() == 'y'
    return {"approved": approved, "messages": [f"Human: {'อนุมัติ' if approved else 'ปฏิเสธ'}"]}

4. สร้างโหนด Execute (Action Node)

ถ้ามนุษย์กด y ระบบจะลงมือทำลายล้างจริง

def execute_node(state: AgentState):
    if state["approved"]:
        return {"messages": [f"System: ดำเนินการเรียบร้อย: {state['pending_action']}"]}
    else:
        return {"messages": ["System: ยกเลิกคำสั่ง"]}

5. ประกอบกราฟ (Compile Graph)

นำโหนดทั้งหมดมาต่อกันด้วย LangGraph

from langgraph.graph import StateGraph, END

workflow = StateGraph(AgentState)

# เพิ่มโหนด
workflow.add_node("ai", ai_node)
workflow.add_node("human", human_approval_node)
workflow.add_node("execute", execute_node)

# กำหนดเส้นทางเริ่มต้น
workflow.set_entry_point("ai")

# สร้างเส้นทางแบบมีเงื่อนไขจาก AI
def should_approve(state: AgentState):
    if state["pending_action"]:
        return "human"
    return END

workflow.add_conditional_edges("ai", should_approve)

# จาก Human ไป Execute
workflow.add_edge("human", "execute")
workflow.add_edge("execute", END)

app = workflow.compile()

ทดสอบระบบ

ลองรันดูสักครั้งเพื่อดูว่ามันทำงานอย่างไร

# กรณีปกติ
print("--- ทดสอบที่ 1 ---")
result = app.invoke({"messages": ["สร้างไฟล์ report.txt"]})
print(result["messages"])

# กรณีต้องขออนุมัติ
print("\n--- ทดสอบที่ 2 ---")
result = app.invoke({"messages": ["ลบไฟล์ database_backup.sql"]})
print(result["messages"])

เมื่อรันโค้ดที่ 2 ระบบจะหยุดที่ human_approval_node และรอให้คุณพิมพ์ y หรือ n ครับ ถ้าคุณพิมพ์ n ไฟล์ก็จะรอดตาย ไม่ถูกลบไปไหน!

ทำไมแนวทางนี้ถึงปลอดภัยตาม PDPA?

1. ออฟไลน์ 100%: Ollama รันอยู่บนเครื่องของคุณ ไม่มีข้อมูลใดๆ รั่วไปยัง API ของบริษัทภายนอก (เช่น OpenAI, Anthropic) ทั้งสิ้น ตอบโจทย์มาตรฐานการรักษาข้อมูลส่วนบุคคล (PDPA) ที่ห้ามส่งข้อมูลลูกค้าออกนอกองค์กรโดยไม่ได้รับอนุญาต
2. Audit Trail: การแยกโหนด Human และ Execute ทำให้คุณสามารถบันทึก Log ได้ชัดเจนว่าใครอนุมัติคำสั่งอะไร เมื่อไหร่ ซึ่งเป็นสิ่งสำคัญมากในการตรวจสอบย้อนหลัง
3. Prevent Hallucination Damage: AI อาจจะเพ้อเจ้อ (Hallucinate) และคิดว่าต้องลบไฟล์ระบบ แต่มีมนุษย์เป็นเกราะป้องกันเสมอ

สรุป

การสร้าง AI Agent ไม่ใช่แค่เรื่องของการให้มันทำงานแทนเราแบบไม่มีข้อจำกัด แต่คือการออกแบบระบบที่ "น่าเชื่อถือ" (Trustworthy) ด้วย LangGraph และ Ollama คุณสามารถสร้างเอเจนต์ที่ฉลาด ทำงานออฟไลน์ได้ และที่สำคัญคือมันยอมฟังคำสั่งจากมนุษย์ก่อนทำสิ่งที่เสี่ยงครับ

ลองนำโค้ดนี้ไปปรับใช้กับระบบ Database หรือระบบการเงินขององค์กรคุณดูนะครับ แล้วอย่าลืมแชร์ประสบการณ์การทำ Human-in-the-Loop มาคุยกันได้ในคอมเมนต์เลย! ใครมีไอเดียเจ๋งๆ อยากให้ AI หยุดถามก่อนทำอะไรบ้าง?