ການສ້າງລະບົບ Multi-Agent AI ດ້ວຍ LangGraph ສໍາລັບນັກພັດທະນາຂັ້ນສູງ

ການໃຊ້ LLM (Large Language Model) ພຽງຕົວດຽວເພື່ອຕອບຄຳຖາມທົ່ວໄປ ອາດຈະພຽງພໍແລ້ວສຳລັບໂປຣເຈັກຂະໜາດນ້ອຍ. ແຕ່ສຳລັບແອັບພລິເຄຊັນລະດັບອົງກອນ (Enterprise Level) ໃນປະຈຸບັນ, ວຽກງານມັກຈະມີຄວາມຊັບຊ້ອນເກີນກວ່າທີ່ AI ພຽງແຕ່ “ຕົວດຽວ” ຈະຈັດການໄດ້ທັງໝົດ.

ລອງຈິນຕະນາການເຖິງບໍລິສັດຂົນສົ່ງສິນຄ້າໃນນະຄອນຫຼວງວຽງຈັນ ທີ່ຕ້ອງການສົ່ງອອກກາເຟຈາກປາກຊ່ອງຜ່ານລົດໄຟລາວ-ຈີນ. ລະບົບທີ່ສົມບູນແບບຕ້ອງມີການປະເມີນສະພາບອາກາດ, ກວດສອບເອກະສານພາສີ, ແປເອກະສານເປັນພາສາຈີນ ແລະ ຄຳນວນຄ່າໃຊ້ຈ່າຍ. ນີ້ຄືຈຸດທີ່ Multi-Agent Systems (MAS) ເຂົ້າມາມີບົດບາດສຳຄັນ ໂດຍການແບ່ງໜ້າທີ່ໃຫ້ AI ແຕ່ລະຕົວເຮັດວຽກທີ່ຕົນເອງຖະໜັດ ແລະ ສື່ສານກັນເພື່ອໃຫ້ໄດ້ຜົນລບທີ່ດີທີ່ສຸດ. ແລະໃນມື້ນີ້, ເຄື່ອງມືທີ່ດີທີ່ສຸດໃນການສ້າງ Flow ດັ່ງກ່າວກໍຄື LangGraph.

LangGraph ແມ່ນຫຍັງ ແລະ ເປັນຫຍັງຈຶ່ງສຳຄັນ?

LangGraph ເປັນໄລບຣາຣີ (Library) ທີ່ຕໍ່ຍອດມາຈາກ LangChain ເຊິ່ງອອກແບບມາເພື່ອສ້າງລະບົບ AI ທີ່ສາມາດຄວບຄຸມສະຖານະ (Stateful) ແລະ ຈັດການວົງຈອນການເຮັດວຽກທີ່ມີການວົນລູບ (Cyclic). ຕ່າງຈາກການສ້າງ Chain ທຳມະດາທີ່ເປັນເສັ້ນຊື່ (Linear), LangGraph ອະນຸຍາດໃຫ້ Agents ຕັດສິນໃຈ, ກວດສອບຄວາມຜິດພາດ, ແລະ ຍ້ອນກັບໄປແກ້ໄຂວຽກໄດ້ (Feedback loops) ເຊິ່ງຄ້າຍຄືກັບການເຮັດວຽກຂອງມະນຸດແທ້ໆ.

ສະຖາປັດຕະຍະກຳຂອງ LangGraph (Core Concepts)

ຖ້າທ່ານເຄີຍຮຽນທິດສະດີກຣາຟ (Graph Theory), ແນວຄວາມຄິດຂອງ LangGraph ຈະເຂົ້າໃຈໄດ້ງ່າຍຫຼາຍ ໂດຍປະກອບມີ 3 ສ່ວນຫຼັກຄື:

1. State (ສະຖານະ): ແມ່ນໂຄງສ້າງຂໍ້ມູນກາງ (Global Context) ທີ່ທຸກໆ Agents ຈະແຊ໌ຮ່ວມກັນ. ໃນ Python ມັກໃຊ້ TypedDict ຫຼື Pydantic ເພື່ອກຳນົດໂຄງສ້າງນີ້. ທຸກໆເທື່ອທີ່ AI ເຮັດໜ້າທີ່ສຳເລັດ, ມັນຈະອັບເດດຂໍ້ມູນໃສ່ State ນີ້.
2. Nodes (ໂຫຍດ): ປຽບເໝືອນຕົວແທນ (Agents) ຫຼື ຟັງຊັນການເຮັດວຽກ. ແຕ່ລະ Node ຈະຮັບ State ເຂົ້າມາປະມວນຜົນ ແລ້ວສົ່ງຄ່າສະຖານະໃໝ່ອອກໄປ.
3. Edges (ເສັ້ນເຊື່ອມ): ເປັນຕົວຄວບຄຸມເສັ້ນທາງການໄຫຼຂອງຂໍ້ມູນວ່າ ຫຼັງຈາກ Node A ເຮັດວຽກສຳເລັດແລ້ວ ຈະສົ່ງຕໍ່ໄປໃຫ້ Node B. ນອກຈາກນີ້ຍັງມີ Conditional Edges ທີ່ຊ່ວຍໃຫ້ລະບົບຕັດສິນໃຈໄດ້ວ່າຈະໄປທາງໃດຕໍ່ (ເຊັ່ນ: ຖ້າເອກະສານຜິດພາດ ໃຫ້ສົ່ງກັບໄປ Node ກວດສອບໃໝ່).

ຕົວຢ່າງການນຳໃຊ້ໃນລາວ: ລະບົບ AI ຄຸ້ມຄອງການຂົນສົ່ງ (Logistics Coordinator AI)

ເຮົາຈະມາຂຽນລະບົບ Multi-Agent ສໍາລັບອະນຸມັດການສົ່ງສິນຄ້າ. ເຮົາຈະມີ 3 ສ່ວນ:

• Document Agent: ກວດສອບແລະແປເອກະສານສົ່ງອອກ.
• Routing Agent: ຊອກຫາຖ້ຽວລົດໄຟລາວ-ຈີນ ທີ່ເໝາະສົມ.
• Manager Agent: ເປັນຕົວຕັດສິນຊີ້ຂາດວ່າ ຂໍ້ມູນພ້ອມແລ້ວຫຼືຍັງ, ຖ້າຍັງ ໃຫ້ສົ່ງກ່າວໄປຫາ Agent ທີ່ກ່ຽວຂ້ອງ.

ມາເລີ່ມຂຽນໂຄດກັນເລີຍ (Code Implementation)

ກ່ອນອື່ນ ຕ້ອງຕິດັ້ງ requirements:

pip install langgraph langchain-openai langchain-core

ລອງມາເບິ່ງວິທີການຂຽນ StateGraph ໃນ Python:

from typing import TypedDict, Annotated, Sequence
import operator
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
from langgraph.graph import StateGraph, END

# 1. ກຳນົດ State ຂອງລະບົບ
class TransportState(TypedDict):
    # ເກັບປະຫວັດການສົນທະນາທັງໝົດ ແລະ ຕໍ່ທ້າຍຂໍ້ຄວາມໃໝ່ສະເໝີຜ່ານ operator.add
    messages: Annotated[Sequence[BaseMessage], operator.add]
    document_status: str
    route_status: str
    final_decision: str

# 2. ສ້າງ Nodes (ໃນທີ່ນີ້ຈະໃຊ້ Function ຂັ້ນພື້ນຖານເພື່ອຈຳລອງການເຮັດວຽກຂອງ LLM Agents)
def document_agent(state: TransportState):
    print("📋 [Document Agent]: ກຳລັງກວດສອບເອກະສານສົ່ງອອກກາເຟປາກຊ່ອງ...")
    # ຈຳລອງລໍຈິກ (Logic): ຖ້າມີເອກະສານ ແລ້ວໃຫ້ຜ່ານ
    return {"document_status": "approved", "messages": [AIMessage(content="ເອກະສານແປສຳເລັດແລ້ວ")]}

def routing_agent(state: TransportState):
    print("🚂 [Routing Agent]: ກຳລັງກວດສອບຕາຕະລາງລົດໄຟລາວ-ຈີນ...")
    return {"route_status": "booked", "messages": [AIMessage(content="ຈອງປີ້ຂະບວນລົດໄຟສິນຄ້າສຳເລັດ")]}

def manager_agent(state: TransportState):
    print("👔 [Manager Agent]: ກຳລັງປະເມີນສະຖານະການທັງໝົດ...")
    if state.get("document_status") == "approved" and state.get("route_status") == "booked":
        return {"final_decision": "ready_to_ship", "messages": [AIMessage(content="ອະນຸມັດການຂົນສົ່ງ!")]}
    return {"final_decision": "missing_info", "messages": [AIMessage(content="ຂໍ້ມູນຍັງບໍ່ຄົບຖ້ວນ, ກະລຸນາກວດສອບຄືນ")]}

# Conditional Logic (ສຳລັບ Edges)
def router_logic(state: TransportState):
    if state.get("final_decision") == "ready_to_ship":
        return "end"
    # ຖ້າບໍ່ພ້ອມ ໃຫ້ວົນລູບກັບໄປແກ້ໄຂ (ໃນຕົວຢ່າງນີ້ຄືສົ່ງກັບໄປທີ່ document ໃໝ່)
    return "retry"

# 3. ປະກອບ Graph ເຂົ້າກັນ
workflow = StateGraph(TransportState)

# ເພີ່ມ Nodes ເຂົ້າໄປໃນ Graph
workflow.add_node("document", document_agent)
workflow.add_node("routing", routing_agent)
workflow.add_node("manager", manager_agent)

# ກຳນົດຈຸດເລີ່ມຕົ້ນ (Entry point)
workflow.set_entry_point("document")

# ສ້າງເສັ້ນທາງເຊື່ອມຕໍ່ (Linear Edges)
workflow.add_edge("document", "routing")
workflow.add_edge("routing", "manager")

# ສ້າງເສັ້ນທາງເງື່ອນໄຂ (Conditional Edges ທີ່ສາມາດວົນລູບໄດ້)
workflow.add_conditional_edges(
    "manager", # ໃຜເປັນຄົນຕັດສິນໃຈ
    router_logic, # ໃຊ້ຟັງຊັນໃດໃນການຕັດສິນ
    {
        "end": END,          # ຖ້າພ້ອມ ໃຫ້ຈົບງບ (END)
        "retry": "document"  # ຖ້າບໍ່ພ້ອມ ໃຫ້ສົ່ງກັບໄປໂຫຍດ document
    }
)

# 4. ແປງໂຄງສ້າງໃຫ້ກາຍເປັນ App ທີ່ພ້ອມໃຊ້ງານ
app = workflow.compile()

# ທົດສອບລະບົບ
initial_state = TransportState(
    messages=[HumanMessage(content="ຕ້ອງການສົ່ງກາເຟ 2 ໂຕນ ໄປຄຸນໝິງ ມື້ອື່ນ")],
    document_status="pending",
    route_status="pending",
    final_decision="pending"
)

# Run workflow
final_state = app.invoke(initial_state)
print("\n=== ສະຫຼຸບຜົນທີ່ໄດ້ (Final State) ===")
print("ສະຖານະການຂົນສົ່ງ:", final_state['final_decision'])

ອະທິບາຍການເຮັດວຽກຂອງລະບົບ:

ໃນໂຄດຂ້າງເທິງນີ້, ເຮົາຈະເຫັນວ່າ TransportState ເປັນຕົວເກັບຂໍ້ມູນເພື່ອໃຫ້ Agent ແຕ່ລະຕົວອ່ານ ແລະ ຂຽນ. Node manager_agent ພຽງແຕ່ເຮັດການກວດສອບວ່າ Agents ອື່ນໆເຮັດວຽກສຳເລັດ ຫຼື ຍັງ. ຖ້າເງື່ອນໄຂທັງໝົດຜ່ານ, ຟັງຊັນ router_logic ຈະສົ່ງຄ່າໄປທີ່ END ເຊິ່ງຈະເປັນການຈົບການເຮັດວຽກ (Terminate cycle) ຂອງກຣາຟ ຢ່າງສົມບູນ. ໃນໂລກຄວາມຈິງ, Nodes ເຫຼົ່ານີ້ຈະຖືກແທນທີ່ດ້ວຍ LLM calls ຄວບຄູ່ໄປກັບ Tool function (ເຊັ່ນ Tool ຈອງປີ້ລົດໄຟ API ຮ່ວມກັບ Llama-3 ຫຼື GPT-4).

Key Takeaways (ສິ່ງສຳຄັນທີ່ຄວນຈື່)

• Multi-Agent ດີກວ່າ Single Agent ສະເໝີສຳລັບວຽກຄອມເພຼັກ: ການແບ່ງວຽກ (Decomposition) ເຮັດໃຫ້ AI ແຕ່ລະຕົວມີຄວາມຊ່ຽວຊານສະເພາະດ້ານ, ຫຼຸດຜ່ອນອາການ Hallucination (ການມະໂນ) ຂອງ LLM ອອກໄປໄດ້.
• LangGraph ເນັ້ນເລື່ອງການຄວບຄຸມ: ດ້ວຍການໃຊ້ State ແລະ Conditional Edges, ນັກພັດທະນາສາມາດຄວບຄຸມ AI ໃຫ້ມີຄວາມປອດໄພລັດກຸມ ແລະ ຄາດເດົາໄດ້ (Deterministic) ຫຼາຍຂຶ້ນເມື່ອທຽບກັບ Autonomous Agents ແບບເກົ່າ.
• ສາາມາດນຳໃຊ້ເຂົ້າໃນທຸລະກິດລາວໄດ້ຈິງ: ບໍ່ວ່າຈະເປັນການຈັດການການຂົນສົ່ງສິນຄ້າ, ລະບົບຊ່ວຍຕອບລູກຄ້າສຳລັບທຸລະກິດໂຮງແຮມຊ່ວງບຸນທາດຫຼວງ, ຫຼື ການວິເຄາະຂໍ້ມູນນ້ຳຂອງ, ລະບົບ Multi-Agent ສາມາດເຊື່ອມຕໍ່ກັບ API ທ້ອງຖິ່ນເພື່ອອັດຕະໂນມັດວຽກຕ່າງໆໄດ້.

ສະຫຼຸບ

ໃນຍຸກທີ່ AI ກຳລັງກ້າວເຂົ້າສູ່ຂັ້ນຕອນການນຳໃຊ້ໃນພາກທຸລະກິດຢ່າງເຕັມຕົວ, ການປ່ຽນຈາກການຂຽນ Prompt ຍາວໆ ມາເປັນການອອກແບບສະຖາປັດຕະຍະກຳດ້ວຍ LangGraph ຈະຊ່ວຍໃຫ້ນັກພັດທະນາລາວຍົກລະດັບ ຊອບແວ ຂອງຕົນກ້າວເຂົ້າສູ່ລະດັບ Enterprise ໄດ້. ລະບົບ Multi-Agent AI ຈະຊ່ວຍຫຼຸດເວລາການເຮັດວຽກທີ່ຊັບຊ້ອນ ແລະ ເພີ່ມປະສິດທິພາບການປະຕິບັດງານຂອງອົງກອນໄດ້ຢ່າງມະຫາສານ. ພວກເຮົາຫວັງວ່າບົດຄວາມນີ້ຈະເປັນແນວທາງໃຫ້ກັບນັກພັດທະນາທຸກທ່ານ ລອງນຳເອົາ LangGraph ໄປປະຍຸກໃຊ້ກັບໂປຣເຈັກຂອງຕົນເອງໃນອະນາຄົດ.