LangGraph คืออะไร? คู่มือสร้าง Stateful AI Agent

โค้ดเอเจนต์ส่วนใหญ่เริ่มต้นง่าย ๆ แล้วเริ่มพังเมื่อเวิร์กโฟลว์ต้องวนซ้ำ แยกสาขา หรือหยุดรอมนุษย์ LangGraph แก้ปัญหานี้ด้วยการจำลองเอเจนต์เป็นกราฟที่มีสถานะร่วมกัน ทำให้การวนซ้ำและการกำหนดเส้นทางเป็นโครงสร้างหลัก ไม่ใช่ชุด if ที่ซ้อนกัน คู่มือนี้อธิบายว่า LangGraph คืออะไร ควรใช้เมื่อใด และ การทดสอบ API มีบทบาทอย่างไรเมื่อเอเจนต์เรียกใช้บริการจริง

ลองใช้ Apidog วันนี้

LangGraph คืออะไร

LangGraph เป็นเฟรมเวิร์ก orchestration ระดับต่ำและรันไทม์สำหรับสร้างเอเจนต์ที่มีสถานะและทำงานได้นาน พัฒนาโดย LangChain Inc แต่เป็นไลบรารีแยกต่างหากจาก LangChain คุณติดตั้งและใช้งานได้โดยตรง:

pip install -U langgraph

แนวคิดหลักคืออธิบายเอเจนต์เป็นกราฟ:

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

ถ้า chain แบบเดิมคือ pipeline เช่น ขั้นตอน 1 → 2 → 3 → จบ LangGraph คือ state machine ที่สามารถเลือกเส้นทาง วนกลับ หรือหยุดรอ input เพิ่มได้ เหมาะกับเอเจนต์ที่ทำงานแบบ “คิด → ทำ → สังเกต → คิดอีกครั้ง”

ปัญหาที่ LangGraph แก้ไข

เวิร์กโฟลว์ของเอเจนต์มักไม่เป็นเส้นตรง เอเจนต์ต้องเรียกเครื่องมือ ดูผลลัพธ์ แล้วตัดสินใจว่าจะทำต่อหรือหยุด หากเขียนทั้งหมดด้วย if/else และ loop เอง โค้ดจะอ่านยากและทดสอบยาก

LangGraph ช่วยจัดการสิ่งเหล่านี้:

• การวนซ้ำพร้อมเงื่อนไขหยุด: เรียกเครื่องมือซ้ำจนกว่างานจะเสร็จ โดยไม่วนไม่รู้จบ
• การแยกสาขาตามสถานะ: ส่งงานไปยังโหนดที่ต่างกันตามผลลัพธ์จากโมเดล
• Persistence: บันทึกสถานะเพื่อ resume หลัง timeout, crash หรือ restart
• Human-in-the-loop: หยุดให้มนุษย์ตรวจสอบหรือแก้ไขสถานะก่อนทำต่อ
• Streaming: ส่ง token และ update ระหว่างทาง ไม่ต้องรอผลลัพธ์สุดท้ายเท่านั้น

ผลลัพธ์คือคุณได้ runtime สำหรับเอเจนต์ที่ทนทานกว่า script เชิงเส้น โดยเฉพาะงานที่กินเวลาหลายนาทีหรือหลายชั่วโมง

แนวคิดหลัก: กราฟ สถานะ โหนด เส้นเชื่อม

LangGraph ประกอบด้วย 4 ส่วนหลัก

1. State

State คือออบเจกต์ที่แชร์ระหว่างทุกโหนด คุณกำหนด schema ได้ เช่น TypedDict หรือใช้ schema ที่มีให้แล้วอย่าง MessagesState สำหรับเก็บรายการข้อความแชท

2. Nodes

Node คือฟังก์ชันที่รับ state ปัจจุบัน แล้วคืนค่า update บางส่วน

3. Edges

Edge เชื่อมโหนดเข้าด้วยกัน:

• add_edge() ใช้สำหรับเส้นทางคงที่ เช่น A → B
• add_conditional_edges() ใช้สำหรับ routing ตาม state เช่น ถ้าโมเดลเรียก tool ให้ไป node tools ไม่เช่นนั้นจบ

4. START และ END

START และ END เป็น marker พิเศษสำหรับจุดเริ่มต้นและจุดสิ้นสุดของกราฟ

ตัวอย่างโครงสร้างพื้นฐาน:

from langgraph.graph import StateGraph, START, END, MessagesState

def call_model(state: MessagesState):
    response = model.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: MessagesState) -> str:
    last = state["messages"][-1]
    return "tools" if last.tool_calls else END

builder = StateGraph(MessagesState)

builder.add_node("model", call_model)
builder.add_node("tools", tool_node)

builder.add_edge(START, "model")
builder.add_conditional_edges("model", should_continue)
builder.add_edge("tools", "model")   # loop back

graph = builder.compile()

จุดสำคัญคือบรรทัดนี้:

builder.add_edge("tools", "model")

หลังจากรัน tool แล้ว control จะวนกลับไปที่ model เพื่อให้โมเดลตัดสินใจต่อว่าจะเรียก tool เพิ่มหรือจบงาน นี่คือ use case หลักที่ LangGraph ถูกออกแบบมาเพื่อรองรับ

การคงอยู่ของข้อมูลและ Human-in-the-loop

ถ้าต้องการให้กราฟ resume ได้ ให้ compile พร้อม checkpointer จากนั้นส่ง thread_id ตอนเรียกใช้งาน LangGraph จะบันทึก snapshot ของ state หลังแต่ละ step และกู้คืน checkpoint ล่าสุดในการเรียกครั้งถัดไป

from langgraph.checkpoint.memory import InMemorySaver

graph = builder.compile(checkpointer=InMemorySaver())

config = {
    "configurable": {
        "thread_id": "user-42"
    }
}

graph.invoke(
    {"messages": [user_message]},
    config
)

InMemorySaver เหมาะสำหรับ development ถ้าต้องการให้รอดจาก process restart ให้ใช้ checkpointer ที่ backed ด้วย database เช่น SQLite สำหรับ server เดี่ยว หรือ Postgres สำหรับหลาย instance

เมื่อ state ถูกบันทึกไว้ คุณสามารถสร้าง workflow แบบ human-in-the-loop ได้ เช่น:

1. รันกราฟจนถึงจุดที่ต้องอนุมัติ
2. แสดง state ปัจจุบันให้ผู้ใช้ตรวจสอบ
3. ให้ผู้ใช้แก้ไขหรือยืนยัน
4. Resume จาก checkpoint เดิม

รูปแบบนี้เหมาะกับงานเช่น approval flow, manual correction หรือขั้นตอน “ยืนยันก่อนส่งจริง”

LangGraph ยังรองรับ streaming เพื่อให้ UI แสดง token หรือ node update ระหว่างรัน แทนที่จะรอ response ตอนจบเพียงครั้งเดียว

LangGraph เกี่ยวข้องกับ LangChain อย่างไร

LangChain คือชุดเครื่องมือที่กว้างกว่า เช่น model wrappers, prompt templates, retrievers, document loaders และ integrations จำนวนมาก ส่วน LangGraph คือ orchestration layer สำหรับควบคุม workflow ของเอเจนต์ที่มีสถานะและมีวงจร

คุณไม่จำเป็นต้องใช้ LangChain เพื่อใช้ LangGraph คุณสามารถกำหนด state, node และ edge เอง แล้วเรียก model client ใดก็ได้ภายใน node แต่หลายทีมใช้ร่วมกันเพราะ abstraction ของ LangChain ช่วยลด boilerplate สำหรับ model และ tools

หัวข้อ	LangChain	LangGraph
บทบาท	ส่วนประกอบและ integrations	Orchestration และ runtime
Control flow	Chain เชิงเส้น	Graph ที่มีวงจรและสาขา
State ในตัว	จำกัด	แชร์ได้ มี schema และทนทาน
Persistence / Resume	ไม่ใช่จุดเน้นหลัก	Checkpointers + thread ID
เหมาะกับ	การรวม model และ tools	เอเจนต์หลายขั้นตอนที่มี state

ข้อสังเกตสำหรับผู้ใช้ปัจจุบัน: LangGraph v1.0 ซึ่งเสถียรตั้งแต่ปลายปี 2025 ได้ย้าย helper agent ที่สร้างไว้ล่วงหน้าไปที่ langchain.agents.create_agent ดังนั้นควรตรวจสอบเวอร์ชันที่ติดตั้งและ เอกสารอ้างอิงทางการ ก่อนคัดลอกตัวอย่างเก่า ๆ

ถ้าต้องการภาพรวมการสร้างเอเจนต์แบบกำหนดเอง ดูเพิ่มเติมได้ที่ การสร้าง AI เอเจนต์แบบกำหนดเอง

แพลตฟอร์มและสตูดิโอของ LangGraph

ไลบรารีโอเพนซอร์สคือแกนหลัก แต่มีเครื่องมือเสริมที่ช่วยตอน debug และ deploy

LangGraph Studio

LangGraph Studio คือ IDE สำหรับเอเจนต์แบบภาพ ใช้ดูกราฟ รัน workflow และ inspect state ในแต่ละโหนด เหมาะมากเมื่อกราฟมี loop และ conditional routing เพราะคุณเห็น path ที่เอเจนต์เลือกจริง แทนที่จะไล่อ่าน log ทีละบรรทัด

LangGraph Platform

LangGraph Platform เป็นส่วนสำหรับ production deployment เช่น API endpoint สำหรับเอเจนต์, persistence ในตัว และตัวเลือก hosting ตั้งแต่ self-hosted ไปจนถึง managed cloud คุณไม่จำเป็นต้องใช้เพื่อเริ่มต้นกับ LangGraph แต่มีประโยชน์เมื่อ workflow เริ่มต้องการ infrastructure สำหรับ production

เมื่อใดควรใช้ LangGraph

ใช้ LangGraph เมื่อ workflow ของเอเจนต์มี control flow จริง เช่น:

• งานเป็น loop ไม่ใช่ลำดับตรง ๆ เช่น call tool → inspect → retry
• ต้อง branch ตามการตัดสินใจของโมเดล
• งานใช้เวลานานและต้อง resume หลัง crash หรือ timeout
• ต้องมีมนุษย์อนุมัติหรือแก้ไขระหว่างทาง
• มีหลาย actor หรือหลาย sub-agent ที่ใช้ state ร่วมกัน

ไม่จำเป็นต้องใช้ LangGraph ถ้างานเป็นการเรียกโมเดลครั้งเดียวหรือ chain สั้น ๆ เช่น “สรุปข้อความนี้” เพราะกราฟจะเพิ่ม overhead โดยไม่จำเป็น

การทดสอบ API และ Mocking มีบทบาทอย่างไร

เอเจนต์ LangGraph จะเชื่อถือได้เท่ากับ API ที่มันเรียกใช้เท่านั้น เช่น LLM endpoint, search API, CRM, internal backend หรือ tool API อื่น ๆ LangGraph ช่วยจัดการ workflow แต่ไม่ได้ทดสอบ API เหล่านั้น นี่คือจุดที่ Apidog เข้ามาช่วยในขั้นตอน development และ testing

มี 2 ปัญหาที่ควรจัดการตั้งแต่ต้น

1. Mock API เพื่อลดต้นทุนและทำให้ test repeatable

ถ้ารัน API จริงทุกครั้ง คุณจะเจอปัญหา token cost, rate limit และผลลัพธ์ที่ไม่ deterministic ระหว่างพัฒนา logic ของกราฟ ให้ mock endpoint ที่เอเจนต์พึ่งพาแทน

ตัวอย่างแนวทาง:

1. ระบุ tool API ทั้งหมดที่ node เรียกใช้
2. สร้าง mock response สำหรับแต่ละ endpoint
3. ให้ test environment ชี้ไปยัง mock server
4. ทดสอบ routing ของกราฟโดยไม่เรียก API จริง

คุณสามารถใช้ การจำลอง API เพื่อให้ endpoint ส่ง response ที่แน่นอนและรวดเร็ว เหมาะสำหรับทดสอบว่า conditional edge เลือก path ถูกต้องหรือไม่

2. ใช้ API assertions เพื่อตรวจ schema drift

Node ของคุณมักคาดหวัง response shape ที่แน่นอน เช่น field name, status code หรือ nested object ถ้า API เปลี่ยน field แบบเงียบ ๆ conditional edge อาจอ่านค่าผิด แล้วทำให้เอเจนต์วนซ้ำหรือหยุดผิดจุด

ให้กำหนด contract ด้วย API assertions เช่น:

• status code ต้องเป็น 200
• response ต้องมี field ที่ node ใช้
• type ของ field ต้องตรงตาม schema
• error response ต้องอยู่ในรูปแบบที่กราฟจัดการได้

สำหรับ workflow ที่เน้น AI agent โดยตรง ดู ชุดทดสอบ Apidog สำหรับ AI เอเจนต์ เพื่อวางกระบวนการ mock, assert และทดสอบ API ที่อยู่เบื้องหลังเอเจนต์

ข้อสำคัญ: Apidog ไม่ได้ orchestrate agent แทน LangGraph แต่ใช้ทดสอบและจำลอง API ที่ agent เรียกใช้

คำถามที่พบบ่อย

LangGraph มาแทนที่ LangChain ใช่หรือไม่?

ไม่ใช่ LangGraph คือ orchestration runtime สำหรับ workflow ที่มี state และ loop ส่วน LangChain คือชุด components และ integrations ที่กว้างกว่า คุณใช้ LangGraph โดยไม่ใช้ LangChain ได้ หรือใช้ร่วมกันก็ได้

ต้องรู้ LangChain ก่อนเริ่มใช้ LangGraph หรือไม่?

ไม่จำเป็น คุณเริ่มจาก StateGraph เพิ่ม node และ edge แล้วเรียก model client ที่ต้องการภายใน node ได้เลย LangChain ช่วยลด boilerplate แต่ไม่ใช่ข้อบังคับ

LangGraph จำ state ระหว่างการเรียกใช้ได้อย่างไร?

ผ่าน checkpointer เมื่อ compile graph พร้อม checkpointer และส่ง thread_id LangGraph จะบันทึก snapshot ของ state หลังแต่ละ step และกู้คืน checkpoint ล่าสุดในการเรียกครั้งถัดไป

จะทดสอบ API ที่เอเจนต์เรียกได้อย่างไร?

แยกการทดสอบ API ออกจากกราฟ Mock LLM endpoint และ tool endpoint เพื่อให้ test เร็วและคุมผลลัพธ์ได้ จากนั้นใช้ assertions ตรวจ response schema เพื่อป้องกัน field เปลี่ยนแล้วทำให้ node ทำงานผิด ดูตัวอย่างเพิ่มเติมได้ในคู่มือ ทดสอบ ChatGPT API

สรุป

LangGraph เหมาะกับเอเจนต์ที่ต้องวนซ้ำ แยกสาขา เก็บ state และหยุดรอมนุษย์ โครงสร้างหลักคือ graph, state, node และ edge ส่วน checkpointer ช่วยให้ resume และสร้าง workflow แบบ human-in-the-loop ได้

เมื่อเอเจนต์เริ่มเรียก API จริง ให้แยกการทดสอบ API ออกจาก orchestration layer ใช้ mock เพื่อลดต้นทุนและทำให้ test predictable และใช้ assertions เพื่อป้องกัน schema drift คุณสามารถทดสอบและจำลอง API เหล่านั้นใน Apidog และ ดาวน์โหลด Apidog เพื่อเริ่มสร้าง mock endpoint และตรวจ response ก่อนให้เอเจนต์เรียกใช้จริง