โค้ดเอเจนต์ส่วนใหญ่เริ่มต้นง่าย ๆ แล้วก็พังทลายลงจากความพยายามซ้ำซ้อนของมันเอง คุณเชื่อมต่อ LLM ให้เครื่องมือบางอย่าง และเมื่อใดก็ตามที่เวิร์กโฟลว์จำเป็นต้องวนซ้ำ แยกสาขา หรือหยุดรอคน สคริปต์แบบเส้นตรงก็พังทลายลง LangGraph คือเฟรมเวิร์กที่สร้างขึ้นมาเพื่อปัญหานี้โดยเฉพาะ: มันจำลองเอเจนต์เป็นกราฟที่มีสถานะร่วมกัน ทำให้การวนซ้ำและการแยกสาขากลายเป็นโครงสร้างหลัก แทนที่จะเป็นคำสั่ง if ที่พันกันยุ่งเหยิง คู่มือนี้จะอธิบายว่า LangGraph คืออะไร ปัญหาที่มันแก้ไขได้ และ การทดสอบ API มีบทบาทอย่างไรเมื่อเอเจนต์ของคุณเรียกใช้บริการจริง
ปุ่ม
LangGraph คืออะไร
LangGraph เป็นเฟรมเวิร์กการจัดการระดับต่ำและรันไทม์สำหรับการสร้างเอเจนต์ที่มีสถานะและทำงานได้นาน มันถูกสร้างขึ้นโดย LangChain Inc ซึ่งเป็นทีมที่อยู่เบื้องหลัง LangChain แต่เป็นไลบรารีที่แยกต่างหากโดยมีจุดเน้นของตัวเอง คุณสามารถติดตั้งได้ด้วยตัวเองโดยใช้ pip install -U langgraph และคุณสามารถใช้งานได้โดยไม่ต้องพึ่งพาระบบนิเวศ LangChain ส่วนที่เหลือ
แนวคิดหลักนั้นเรียบง่าย คุณอธิบายเอเจนต์ของคุณเป็นกราฟ โหนดจะทำงาน (เรียกโมเดล, รันเครื่องมือ, แปลงข้อมูล) เส้นเชื่อมจะตัดสินใจว่าจะรันอะไรต่อไป ออบเจกต์สถานะที่ใช้ร่วมกันจะไหลผ่านทุกโหนด และแต่ละโหนดสามารถอ่านและเขียนกลับไปยังสถานะนั้นได้ เนื่องจากเส้นเชื่อมสามารถชี้กลับไปข้างหลังได้ กราฟจึงสามารถวนซ้ำได้ นี่คือส่วนที่เชนธรรมดาทำได้ไม่ดีนัก
หากคุณเคยใช้ abstraction แบบ Chain รุ่นเก่าของ LangChain ความแตกต่างอยู่ที่รูปทรงของการควบคุมการไหล (control flow) เชนคือไปป์ไลน์: ขั้นตอนที่หนึ่ง ขั้นตอนที่สอง ขั้นตอนที่สาม เสร็จสิ้น กราฟช่วยให้โหนดสามารถตรวจสอบสถานะปัจจุบัน จากนั้นกระโดดไปยังสาขาอื่น วนกลับเพื่อลองใหม่ หรือแตกแขนงไปยังหลายโหนดที่ทำงานพร้อมกันและรวมผลลัพธ์เข้าด้วยกัน เอเจนต์จริงต้องการสิ่งนั้น เพราะ "คิด, ทำ, สังเกต, คิดอีกครั้ง" คือการวนซ้ำ ไม่ใช่เส้นตรง
ปัญหาที่ LangGraph แก้ไข
เวิร์กโฟลว์ของเอเจนต์โดยธรรมชาติแล้วเป็นแบบวงจร เอเจนต์เรียกใช้เครื่องมือ ดูผลลัพธ์ ตัดสินใจว่าเสร็จสิ้นแล้วหรือไม่ และถ้ายังไม่เสร็จ ก็ลองใหม่อีกครั้ง การจำลองสิ่งนี้ด้วยเงื่อนไขที่ซ้อนกันทำให้การอ่านยากขึ้นอย่างรวดเร็ว และมันจะแย่ลงไปอีกเมื่อคุณเพิ่มสิ่งที่เอเจนต์ที่ใช้งานจริงต้องการ:
- การวนซ้ำพร้อมเงื่อนไขการหยุด เรียกใช้เครื่องมือต่อไปจนกว่างานจะเสร็จสมบูรณ์ โดยไม่วนซ้ำตลอดไป
- การแยกสาขาตามสถานะ กำหนดเส้นทางไปยังโหนดที่แตกต่างกัน ขึ้นอยู่กับสิ่งที่โมเดลส่งกลับมา
- การคงอยู่ของข้อมูล (Persistence) รอดจากการแครช การหมดเวลา หรือการรีสตาร์ท และดำเนินการต่อจากจุดที่ทำงานได้ดีครั้งล่าสุด
- มนุษย์ร่วมในการทำงาน (Human-in-the-loop) หยุดชั่วคราว ให้คนตรวจสอบหรือแก้ไขสถานะ แล้วดำเนินการต่อ
- การสตรีม (Streaming) ส่งโทเค็นและขั้นตอนกลางเมื่อเกิดขึ้น ไม่ใช่แค่ตอนท้าย
LangGraph เปลี่ยนสิ่งเหล่านี้ให้เป็นความสามารถในตัวแทนที่จะเป็นสิ่งที่คุณต้องสร้างขึ้นมาเอง คุณจะได้เครื่องสถานะ (state machine) ที่มีการดำเนินการที่ทนทาน ทำให้เอเจนต์สามารถทำงานได้เป็นนาทีหรือเป็นชั่วโมง และดำเนินการต่อจากจุดที่หยุดไป
แนวคิดหลัก: กราฟ สถานะ โหนด เส้นเชื่อม
สี่ส่วนประกอบพื้นฐานนี้เป็นส่วนสำคัญของเฟรมเวิร์ก นี่คือวิธีการที่มันทำงานร่วมกัน
สถานะ (State) เป็นออบเจกต์ที่มีชนิดข้อมูลซึ่งใช้ร่วมกันตลอดการทำงาน คุณกำหนดรูปร่างของมันด้วยสคีมา ซึ่งมักจะเป็น TypedDict และ LangGraph จะรวมการอัปเดตของแต่ละโหนดเข้าไว้ด้วยกัน จุดเริ่มต้นที่พบบ่อยคือ MessagesState ซึ่งเป็นสคีมาที่สร้างไว้ล่วงหน้าซึ่งเก็บรายการข้อความแชทที่กำลังทำงานอยู่
โหนด (Nodes) เป็นฟังก์ชัน แต่ละฟังก์ชันจะรับสถานะปัจจุบันและส่งคืนการอัปเดตบางส่วน คุณลงทะเบียนมันด้วย add_node()
เส้นเชื่อม (Edges) เชื่อมต่อโหนดต่างๆ เส้นเชื่อมปกติที่ใช้ add_edge() จะไปจาก A ไป B เสมอ ส่วนเส้นเชื่อมแบบมีเงื่อนไขที่ใช้ add_conditional_edges() จะรันฟังก์ชันการกำหนดเส้นทางที่อ่านสถานะและส่งคืนชื่อของโหนดถัดไป ซึ่งเป็นวิธีที่คุณจะแสดงออกว่า "หากโมเดลขอเครื่องมือ ให้ไปรันเครื่องมือนั้น มิฉะนั้นให้สิ้นสุดการทำงาน"
START และ END เป็นเครื่องหมายพิเศษสำหรับจุดที่การดำเนินการเริ่มต้นและหยุด
นี่คือรูปร่างของกราฟที่เรียบง่ายที่สุด มันเป็นระดับ pseudo-code แต่ชื่อ API เป็นของจริง
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()
บรรทัด add_edge("tools", "model") คือวงจร หลังจากที่เครื่องมือทำงาน การควบคุมจะกลับไปที่โมเดล ซึ่งสามารถเรียกใช้เครื่องมือเพิ่มเติมหรือหยุดได้ การวนซ้ำนี้เป็นเหตุผลทั้งหมดที่ LangGraph มีอยู่
การคงอยู่ของข้อมูลและการร่วมทำงานของมนุษย์
คอมไพล์กราฟด้วย checkpointer และมันจะบันทึกสแนปช็อตของสถานะหลังจากแต่ละขั้นตอน ส่ง thread_id ในการกำหนดค่า และ LangGraph จะกู้คืน 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 เหมาะสำหรับการพัฒนา สำหรับสิ่งที่สามารถอยู่รอดจากการรีสตาร์ท LangGraph มีตัวบันทึกที่รองรับฐานข้อมูล (SQLite สำหรับเซิร์ฟเวอร์เดียว, Postgres สำหรับการขยายขนาดหลายอินสแตนซ์) เนื่องจากสถานะมีความทนทาน คุณยังได้รับความสามารถ "มนุษย์ร่วมในการทำงาน" เกือบจะฟรี คุณสามารถขัดจังหวะกราฟ ณ จุดที่เลือกได้ แสดงสถานะปัจจุบันให้คนตรวจสอบหรือแก้ไข จากนั้นดำเนินการต่อจากจุด checkpoint นั้นได้ทันที การอนุมัติ การแก้ไขด้วยตนเอง และขั้นตอน "คุณแน่ใจหรือไม่?" ทั้งหมดนี้สร้างขึ้นบนพื้นฐานนี้
การสตรีมช่วยให้สมบูรณ์ LangGraph สามารถสตรีมโทเค็นของโมเดลและการอัปเดตระดับโหนดได้เมื่อการทำงานดำเนินไป ดังนั้น UI จึงสามารถแสดงให้เห็นว่าเอเจนต์กำลังคิดอยู่แทนที่จะจ้องมองที่สปินเนอร์
LangGraph เกี่ยวข้องกับ LangChain อย่างไร
สิ่งนี้ทำให้ผู้คนสับสน ดังนั้นมาพูดกันตรงๆ เลย LangChain คือชุดเครื่องมือที่กว้างกว่า: ตัวห่อโมเดล (model wrappers), เทมเพลตพร้อมต์ (prompt templates), ตัวเรียกค้นข้อมูล (retrievers), ตัวโหลดเอกสาร (document loaders) และการรวมเข้ากับผู้ให้บริการหลายร้อยราย LangGraph เป็นชั้นการจัดการ (orchestration layer) ที่อยู่เบื้องล่างส่วนของเอเจนต์ของชุดเครื่องมือนั้น
คุณไม่จำเป็นต้องใช้ LangChain เพื่อใช้ LangGraph คุณสามารถกำหนดสถานะ โหนด และเส้นเชื่อมของคุณ และเรียกใช้ไคลเอ็นต์โมเดลใดก็ได้ที่คุณต้องการภายในโหนด ทีมงานจำนวนมากใช้ทั้งสองอย่างร่วมกัน เพราะ abstraction ของโมเดลและเครื่องมือของ LangChain นั้นสะดวก และ helper create_react_agent ที่สร้างไว้ล่วงหน้าของ LangGraph (ใน langgraph.prebuilt) ช่วยให้คุณมีเอเจนต์เรียกใช้เครื่องมือที่ใช้งานได้จริงด้วยโค้ดเพียงไม่กี่บรรทัดเมื่อคุณไม่ต้องการกราฟที่กำหนดเอง
| LangChain | LangGraph | |
|---|---|---|
| บทบาท | ส่วนประกอบและการรวมระบบ | การจัดการและรันไทม์ |
| การควบคุมการไหล | เชนเชิงเส้น | กราฟที่มีวงจรและสาขา |
| สถานะในตัว | จำกัด | ใช้ร่วมกัน, มีชนิดข้อมูล, ทนทาน |
| การคงอยู่ / ดำเนินการต่อ | ไม่ใช่จุดเน้น | Checkpointers + รหัสเธรด |
| ดีที่สุดสำหรับ | การรวมการเรียกใช้โมเดลและเครื่องมือ | เอเจนต์ที่มีสถานะ, หลายขั้นตอน |
ข้อสังเกตสำหรับผู้ใช้ปัจจุบัน: สาย LangGraph v1.0 (เสถียรตั้งแต่ปลายปี 2025) ได้ย้าย helper เอเจนต์ที่สร้างไว้ล่วงหน้าไปที่ langchain.agents.create_agent ดังนั้นโปรดตรวจสอบเวอร์ชันที่ติดตั้งและ การอ้างอิงอย่างเป็นทางการ สำหรับเส้นทางการนำเข้าที่แน่นอนก่อนที่คุณจะคัดลอกโค้ดตัวอย่างเก่าๆ การสร้างเอเจนต์แบบกำหนดเองตั้งแต่เริ่มต้นก็เป็นทักษะที่มีประโยชน์เช่นกัน ดูคำแนะนำของเราเกี่ยวกับ การสร้าง AI เอเจนต์แบบกำหนดเอง สำหรับภาพรวมที่กว้างขึ้น
แพลตฟอร์มและสตูดิโอของ LangGraph
ไลบรารีโอเพนซอร์สเป็นแกนหลัก แต่ผลิตภัณฑ์เสริมสองตัวมีความสำคัญเมื่อคุณนำไปใช้งานจริง
LangGraph Studio คือ IDE สำหรับเอเจนต์แบบภาพ มันจะแสดงกราฟของคุณ ช่วยให้คุณรันมันได้ และแสดงสถานะที่ทุกโหนดเพื่อให้คุณสามารถดูการทำงานแต่ละขั้นตอนผ่านโหนดและเส้นเชื่อมของคุณได้ สำหรับสิ่งใดก็ตามที่มีวงจรและการกำหนดเส้นทางแบบมีเงื่อนไข การได้เห็นเส้นทางที่เอเจนต์ดำเนินการจริงนั้นดีกว่าการอ่านบรรทัดบันทึก
LangGraph Platform เป็นส่วนของการจัดการการนำไปใช้งาน: ปลายทาง API สำหรับเอเจนต์ของคุณ, การคงอยู่ของข้อมูลในตัวสำหรับการทำงานที่ยาวนาน, และตัวเลือกการโฮสต์ที่หลากหลายตั้งแต่ self-hosted ไปจนถึงการจัดการเต็มรูปแบบในคลาวด์ คุณไม่จำเป็นต้องมีสิ่งนี้เพื่อใช้งานไลบรารี มันมีอยู่เมื่อคุณต้องการโครงสร้างพื้นฐานสำหรับเอเจนต์ในการผลิต แทนที่จะเรียกใช้ด้วยตัวเอง
เมื่อใดควรใช้ LangGraph
เลือกใช้ LangGraph เมื่อเอเจนต์ของคุณมีการควบคุมการไหลที่แท้จริง สัญญาณที่ดีคือ:
- งานเป็นการวนซ้ำ ไม่ใช่ลำดับ (เรียกใช้เครื่องมือ, ตรวจสอบ, ทำซ้ำ)
- คุณจำเป็นต้องแยกสาขาตามสิ่งที่โมเดลตัดสินใจ
- การทำงานอาจใช้เวลานาน และคุณต้องการให้มันรอดจากการแครชและดำเนินการต่อได้
- มนุษย์ต้องอนุมัติหรือแก้ไขบางสิ่งระหว่างการทำงาน
- คุณกำลังประสานงานนักแสดงหลายคนหรือเอเจนต์ย่อยที่ใช้สถานะร่วมกัน
ข้ามไปได้เลยหากการเรียกโมเดลครั้งเดียวหรือเชนเชิงเส้นสั้นๆ ก็ทำงานได้ กราฟเป็นการโอเวอร์เฮดที่คุณไม่จำเป็นต้องใช้สำหรับ "สรุปข้อความนี้" เก็บโครงสร้างไว้สำหรับเวิร์กโฟลว์ที่ต้องการการแยกสาขาและการวนซ้ำอย่างแท้จริง
การทดสอบ API และการจำลอง (Mocking) มีบทบาทอย่างไร
นี่คือส่วนที่ทำให้ทีมมีปัญหาในการพัฒนา เอเจนต์ LangGraph จะเชื่อถือได้เท่ากับ API ที่มันเรียกใช้เท่านั้น และมันเรียกใช้ API จำนวนมาก: ปลายทาง LLM รวมถึง API ของเครื่องมือทุกชนิด (การค้นหา, CRM, แบ็กเอนด์ของคุณเอง) LangGraph จัดการการเรียกเหล่านั้น; มันไม่ได้ทดสอบสิ่งเหล่านั้น นั่นเป็นงานแยกต่างหาก และนั่นคือที่ที่ Apidog เข้ามามีบทบาท
สองปัญหาจะปรากฏขึ้นอย่างรวดเร็ว ประการแรก การเรียกใช้ API จริงในการทดสอบทุกครั้งจะสิ้นเปลืองโทเค็นและทำให้ติดขีดจำกัดอัตรา คุณสามารถ จำลอง API ที่เอเจนต์ต้องพึ่งพาได้ เพื่อให้ปลายทางของเครื่องมือส่งคืนการตอบสนองที่แน่นอนและรวดเร็วในขณะที่คุณปรับปรุงตรรกะของกราฟ จำลองปลายทาง LLM ด้วยวิธีเดียวกัน และคุณจะหยุดจ่ายค่าโทเค็นเพียงเพื่อทดสอบการกำหนดเส้นทาง
ประการที่สอง โหนดของคุณคาดหวังรูปแบบการตอบกลับ หาก API ของเครื่องมือเปลี่ยนชื่อฟิลด์อย่างเงียบๆ เส้นเชื่อมแบบมีเงื่อนไขของคุณจะอ่านผิด และเอเจนต์จะวนซ้ำหรือหยุดชะงัก การกำหนดสัญญาเหล่านั้นด้วย การยืนยัน API จะช่วยตรวจจับการเปลี่ยนแปลงก่อนที่จะไปถึงกราฟของคุณ และเนื่องจากเอเจนต์ต้องจัดการคีย์ต่างๆ ในสภาพแวดล้อม staging และ production การจัดการคีย์เหล่านั้นในสภาพแวดล้อมจะช่วยให้ความลับไม่รั่วไหลจากโค้ดโหนดของคุณ หากคุณต้องการเวิร์กโฟลว์ที่เน้นเอเจนต์อย่างสมบูรณ์ ชุดทดสอบ Apidog สำหรับ AI เอเจนต์ จะอธิบายกระบวนการทั้งหมดตั้งแต่ต้นจนจบ ขอชี้แจงว่า ไม่มีสิ่งใดในนี้ที่จัดการเอเจนต์; Apidog ทดสอบและจำลอง API ที่อยู่เบื้องหลังเอเจนต์เท่านั้น
คำถามที่พบบ่อย
LangGraph มาแทนที่ LangChain ใช่หรือไม่? ไม่ใช่ LangGraph คือรันไทม์การจัดการ (orchestration runtime) ส่วน LangChain คือชุดส่วนประกอบและการรวมระบบที่กว้างกว่า ทั้งสองเป็นไลบรารีที่แยกจากกันจากทีมเดียวกัน และคุณสามารถรัน LangGraph โดยไม่มี LangChain หรือใช้ร่วมกันก็ได้ LangGraph จัดการการควบคุมการไหลแบบมีสถานะและเป็นวงจรที่เชนธรรมดาทำได้ยาก
ฉันจำเป็นต้องรู้ LangChain เพื่อเริ่มต้นใช้ LangGraph หรือไม่? ไม่จำเป็น คุณสามารถกำหนด StateGraph เพิ่มโหนดและเส้นเชื่อม และเรียกใช้ไคลเอ็นต์โมเดลใดก็ได้ภายในโหนด ตัวห่อโมเดลของ LangChain นั้นสะดวก แต่เป็นทางเลือก เริ่มต้นด้วยโครงสร้างพื้นฐานของกราฟและเพิ่มส่วนที่เหลือเมื่อคุณต้องการเท่านั้น
LangGraph จำสิ่งต่างๆ ระหว่างการเรียกใช้ได้อย่างไร? ผ่าน checkpointer คอมไพล์กราฟของคุณด้วย checkpointer และส่ง thread_id จากนั้น LangGraph จะบันทึกสแนปช็อตสถานะหลังจากแต่ละขั้นตอน แล้วกู้คืนในการเรียกครั้งถัดไปสำหรับเธรดนั้น นี่คือวิธีที่คุณจะได้หน่วยความจำการสนทนาและการกู้คืนจากข้อผิดพลาดโดยไม่ต้องเปลี่ยนตรรกะของโหนดของคุณ
ฉันจะทดสอบ API ที่เอเจนต์ของฉันเรียกได้อย่างไร? ทดสอบและจำลอง (mock) แยกจากกราฟ จำลองปลายทาง LLM และปลายทางเครื่องมือเพื่อให้การทำงานรวดเร็วและฟรีในระหว่างการพัฒนา และยืนยันรูปแบบการตอบกลับเพื่อไม่ให้ฟิลด์ที่เปลี่ยนแปลงทำให้โหนดเสีย คู่มือของเราเกี่ยวกับการ ทดสอบ ChatGPT API ครอบคลุมการยืนยันตัวตน การสตรีม และการเรียกเครื่องมือ ซึ่งเป็นส่วนที่เอเจนต์ต้องพึ่งพาโดยตรง
สรุป
LangGraph มอบโครงสร้างที่ขาดหายไปสำหรับเอเจนต์ที่วนซ้ำ แยกสาขา คงอยู่ และหยุดรอมนุษย์ จำลองเวิร์กโฟลว์เป็นกราฟที่มีสถานะร่วมกัน อาศัย checkpointer สำหรับหน่วยความจำและการกู้คืน และใช้ Studio และ Platform เมื่อคุณพร้อมที่จะดีบักและปรับใช้ เฟรมเวิร์กจัดการการประสานงาน API ที่เอเจนต์ของคุณเรียกใช้ยังคงต้องการความปลอดภัยของตนเอง ดังนั้นให้จำลองและทดสอบ API เหล่านั้นใน Apidog เพื่อให้การพัฒนาคุ้มค่าและสัญญาของเครื่องมือเป็นไปอย่างซื่อสัตย์ ดาวน์โหลด Apidog เพื่อจำลองปลายทางและยืนยันการตอบกลับก่อนที่เอเจนต์ของคุณจะเรียกใช้จริง
ปุ่ม