#การสร้าง AI Agent ด้วย LangGraph

LangGraph เป็น framework ใน ecosystem ของ LangChain สำหรับสร้าง stateful AI agents และ agentic workflows ที่มีขั้นตอนการทำงานซับซ้อนกว่าการเรียก Large Language Model (LLM) เพียงครั้งเดียว

แนวคิดสำคัญของ LangGraph คือการมองระบบ Agent เป็น กราฟ (Graph) ซึ่งประกอบด้วย

  • State — ข้อมูลหรือบริบทที่ไหลอยู่ในระบบ
  • Node — ขั้นตอนการประมวลผล เช่น เรียก LLM หรือเรียก Tool
  • Edge — เส้นทางเชื่อมระหว่าง Node
  • Conditional Edge — เส้นทางที่เลือกตามเงื่อนไข
  • Cycle — การวนกลับไปทำงานซ้ำ เช่น LLM → Tool → LLM
  • Checkpoint / Persistence — การบันทึกสถานะเพื่อให้ Agent ทำงานต่อจากจุดเดิม
  • Human-in-the-loop — แทรกมนุษย์เข้ามาตรวจสอบหรืออนุมัติบางขั้นตอนได้

LangGraph จึงเหมาะกับงานที่ต้องการควบคุม workflow ของ Agent อย่างชัดเจน เช่น

  • AI Assistant ที่เรียก API หรือฐานข้อมูล
  • Research Agent
  • Coding Agent
  • RAG Agent
  • Customer Support Agent
  • Workflow Automation
  • Multi-Agent System
  • Agent ที่ต้องมี Memory
  • Agent ที่ต้องขออนุมัติจากมนุษย์ก่อนทำบาง Action

#1. LangGraph ต่างจากการเรียก LLM ปกติอย่างไร

การเรียก LLM แบบปกติอาจมีโครงสร้างประมาณนี้

User
  |
  v
LLM
  |
  v
Answer

แต่ Agent ต้องสามารถคิดว่าจะทำอะไรต่อ เช่น

User
  |
  v
LLM
  |
  +------ ไม่ต้องใช้ Tool ------> Answer
  |
  +------ ต้องใช้ Tool
             |
             v
            Tool
             |
             v
            LLM
             |
             +---- อาจเรียก Tool เพิ่ม
             |
             +---- Answer

LangGraph ช่วยให้เราเขียน workflow ลักษณะนี้ออกมาเป็น Graph โดยตรง

flowchart LR
    START --> LLM
    LLM -->|tool_calls| TOOL
    TOOL --> LLM
    LLM -->|no tool call| END

จุดเด่นสำคัญคือ เราควบคุมวงจรการทำงานของ Agent ได้อย่าง explicit

#2. สถาปัตยกรรมของ Agent

ตัวอย่างในบทความนี้จะสร้าง Agent ที่สามารถเลือกใช้เครื่องมือคำนวณได้ 3 ตัว

add(a, b)
multiply(a, b)
divide(a, b)

Workflow:

flowchart TD
    S([START])
    L[LLM Node]
    T[Tool Node]
    E([END])

    S --> L
    L -->|มี tool_calls| T
    T --> L
    L -->|ไม่มี tool_calls| E

หลักการคือ

  1. รับคำถามจากผู้ใช้
  2. ส่งข้อความเข้า LLM
  3. LLM วิเคราะห์ว่าต้องใช้ Tool หรือไม่
  4. ถ้าต้องใช้ Tool ให้ไปที่ tool_node
  5. นำผลลัพธ์จาก Tool กลับไปให้ LLM
  6. LLM อาจเรียก Tool เพิ่ม หรือสร้างคำตอบสุดท้าย
  7. เมื่อไม่มี tool_calls แล้ว Graph จบการทำงาน

#3. เตรียม Environment

บทความนี้ใช้ Python

แนะนำ Python 3.11 ขึ้นไป

สร้าง project

mkdir langgraph-agent
cd langgraph-agent

สร้าง virtual environment ด้วย uv

uv venv

ติดตั้ง package

uv add langgraph langchain langchain-anthropic python-dotenv

หรือใช้ pip

pip install -U langgraph langchain langchain-anthropic python-dotenv

สร้างไฟล์ .env

ANTHROPIC_API_KEY=your_api_key

ไม่ควร hard-code API Key ลงใน source code หรือ commit ไฟล์ .env ขึ้น Git

#4. สร้าง Tools

สร้างไฟล์ main.py

from langchain.tools import tool


@tool
def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b


@tool
def multiply(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b


@tool
def divide(a: int, b: int) -> float:
    """Divide a by b."""
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

Decorator

@tool

ทำให้ Python function สามารถถูก expose เป็น Tool ให้ LLM เรียกใช้งานได้

คำอธิบายใน docstring มีความสำคัญ เพราะโมเดลจะใช้ข้อมูลนี้เพื่อพิจารณาว่า Tool ทำหน้าที่อะไร

#5. สร้าง Chat Model และ Bind Tools

เพิ่ม code

from langchain.chat_models import init_chat_model


model = init_chat_model(
    "claude-sonnet-4-6",
    temperature=0,
)

tools = [add, multiply, divide]

tools_by_name = {
    tool.name: tool
    for tool in tools
}

model_with_tools = model.bind_tools(tools)

คำสั่ง

model.bind_tools(tools)

ทำให้ LLM ทราบว่ามี Tool อะไรให้เลือกใช้

ตัว LLM จะไม่ได้ execute function โดยตรง แต่จะส่ง tool_calls ออกมา เช่น

{
  "name": "multiply",
  "args": {
    "a": 25,
    "b": 4
  }
}

จากนั้น Graph ของเราจะเป็นผู้รับคำสั่งดังกล่าวไป execute จริง

#6. สร้าง State

หัวใจของ LangGraph คือ State

import operator

from langchain.messages import AnyMessage
from typing_extensions import Annotated, TypedDict


class AgentState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    llm_calls: int

messages ใช้เก็บ conversation เช่น

HumanMessage
AIMessage
ToolMessage
AIMessage

ส่วน

Annotated[list[AnyMessage], operator.add]

กำหนด reducer ให้ LangGraph append ข้อความใหม่ต่อจากของเดิม แทนการเขียนทับ list ทั้งหมด

#7. สร้าง LLM Node

Node แรกทำหน้าที่เรียกโมเดล

from langchain.messages import SystemMessage


def llm_call(state: AgentState):
    response = model_with_tools.invoke(
        [
            SystemMessage(
                content=(
                    "You are a helpful AI assistant. "
                    "Use tools when calculation is required."
                )
            )
        ]
        + state["messages"]
    )

    return {
        "messages": [response],
        "llm_calls": state.get("llm_calls", 0) + 1,
    }

Node รับ

state

แล้วคืนค่าบางส่วนของ State ที่ต้องการ update

#8. สร้าง Tool Node

เมื่อ LLM ต้องการเรียก Tool เราจะอ่าน tool_calls

from langchain.messages import ToolMessage


def tool_node(state: AgentState):
    results = []

    last_message = state["messages"][-1]

    for tool_call in last_message.tool_calls:
        tool = tools_by_name[tool_call["name"]]

        observation = tool.invoke(
            tool_call["args"]
        )

        results.append(
            ToolMessage(
                content=str(observation),
                tool_call_id=tool_call["id"],
            )
        )

    return {
        "messages": results
    }

Workflow ณ จุดนี้จะเป็น

LLM
 |
 | tool_calls
 v
Tool Node
 |
 | ToolMessage
 v
LLM

#9. สร้าง Conditional Routing

Agent ต้องรู้ว่าเมื่อไรควรไป Tool และเมื่อไรควรจบ

from typing import Literal
from langgraph.graph import END


def should_continue(
    state: AgentState,
) -> Literal["tool_node", END]:

    last_message = state["messages"][-1]

    if last_message.tool_calls:
        return "tool_node"

    return END

ถ้า LLM ส่ง tool_calls

LLM → Tool

แต่ถ้าไม่มี

LLM → END

นี่คือส่วนที่ทำให้ workflow กลายเป็น Agent Loop

#10. สร้าง StateGraph

Import LangGraph

from langgraph.graph import StateGraph, START, END

สร้าง Graph

builder = StateGraph(AgentState)

เพิ่ม Node

builder.add_node(
    "llm_call",
    llm_call,
)

builder.add_node(
    "tool_node",
    tool_node,
)

กำหนดจุดเริ่มต้น

builder.add_edge(
    START,
    "llm_call",
)

เพิ่ม Conditional Edge

builder.add_conditional_edges(
    "llm_call",
    should_continue,
    ["tool_node", END],
)

หลัง Tool ทำงานเสร็จ ให้วนกลับไปหา LLM

builder.add_edge(
    "tool_node",
    "llm_call",
)

Compile

agent = builder.compile()

กราฟสมบูรณ์จึงเป็น

START
  |
  v
LLM
  |
  +------ ไม่มี Tool ------> END
  |
  +------ มี Tool
             |
             v
            TOOL
             |
             +-------------> LLM

#11. Code ฉบับสมบูรณ์

import operator
from typing import Literal

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain.messages import (
    AnyMessage,
    HumanMessage,
    SystemMessage,
    ToolMessage,
)
from langchain.tools import tool
from langgraph.graph import END, START, StateGraph
from typing_extensions import Annotated, TypedDict


load_dotenv()


# -------------------------
# Tools
# -------------------------

@tool
def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b


@tool
def multiply(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b


@tool
def divide(a: int, b: int) -> float:
    """Divide a by b."""
    if b == 0:
        raise ValueError("Cannot divide by zero")

    return a / b


tools = [
    add,
    multiply,
    divide,
]

tools_by_name = {
    tool.name: tool
    for tool in tools
}


# -------------------------
# Model
# -------------------------

model = init_chat_model(
    "claude-sonnet-4-6",
    temperature=0,
)

model_with_tools = model.bind_tools(tools)


# -------------------------
# State
# -------------------------

class AgentState(TypedDict):
    messages: Annotated[
        list[AnyMessage],
        operator.add,
    ]
    llm_calls: int


# -------------------------
# LLM Node
# -------------------------

def llm_call(state: AgentState):
    response = model_with_tools.invoke(
        [
            SystemMessage(
                content=(
                    "You are a helpful AI assistant. "
                    "Use tools when arithmetic is required."
                )
            )
        ]
        + state["messages"]
    )

    return {
        "messages": [response],
        "llm_calls": state.get(
            "llm_calls",
            0,
        ) + 1,
    }


# -------------------------
# Tool Node
# -------------------------

def tool_node(state: AgentState):
    results = []

    last_message = state["messages"][-1]

    for tool_call in last_message.tool_calls:
        tool = tools_by_name[
            tool_call["name"]
        ]

        observation = tool.invoke(
            tool_call["args"]
        )

        results.append(
            ToolMessage(
                content=str(observation),
                tool_call_id=tool_call["id"],
            )
        )

    return {
        "messages": results
    }


# -------------------------
# Router
# -------------------------

def should_continue(
    state: AgentState,
) -> Literal["tool_node", END]:

    last_message = state["messages"][-1]

    if last_message.tool_calls:
        return "tool_node"

    return END


# -------------------------
# Build Graph
# -------------------------

builder = StateGraph(AgentState)

builder.add_node(
    "llm_call",
    llm_call,
)

builder.add_node(
    "tool_node",
    tool_node,
)

builder.add_edge(
    START,
    "llm_call",
)

builder.add_conditional_edges(
    "llm_call",
    should_continue,
    ["tool_node", END],
)

builder.add_edge(
    "tool_node",
    "llm_call",
)

agent = builder.compile()


# -------------------------
# Run
# -------------------------

result = agent.invoke(
    {
        "messages": [
            HumanMessage(
                content=(
                    "คำนวณ 25 คูณ 8 "
                    "แล้วนำผลลัพธ์หารด้วย 4"
                )
            )
        ],
        "llm_calls": 0,
    }
)

print(
    result["messages"][-1].content
)

print(
    "LLM calls:",
    result["llm_calls"],
)

รันโปรแกรม

uv run python main.py

หรือ

python main.py

#12. Agent ทำงานอย่างไรเมื่อ Run จริง

สมมติผู้ใช้ถาม

คำนวณ 25 คูณ 8 แล้วนำผลลัพธ์หารด้วย 4

Agent อาจทำงานดังนี้

Human
  |
  v
LLM
  |
  | multiply(25, 8)
  v
Tool
  |
  | 200
  v
LLM
  |
  | divide(200, 4)
  v
Tool
  |
  | 50
  v
LLM
  |
  v
"คำตอบคือ 50"

สังเกตว่าเราไม่ได้เขียนว่า

multiply(...)
divide(...)

ตามลำดับแบบ hard-code

แต่ LLM เป็นผู้เลือกเองว่าจะใช้ Tool ใด

นี่คือความแตกต่างสำคัญระหว่าง Workflow ธรรมดา กับ AI Agent

#13. Visualize Graph

LangGraph สามารถสร้างภาพของ Graph ได้

from IPython.display import Image, display


display(
    Image(
        agent
        .get_graph(xray=True)
        .draw_mermaid_png()
    )
)

เหมาะสำหรับใช้ตรวจสอบว่า workflow เชื่อมต่อกันถูกต้องหรือไม่

#14. เพิ่ม Memory ด้วย Checkpointer

Agent ในตัวอย่างก่อนหน้ายังไม่ได้เก็บ state ข้ามการ invoke

สามารถเพิ่ม checkpointer ได้ เช่น In-Memory Checkpointer สำหรับ development

from langgraph.checkpoint.memory import InMemorySaver


checkpointer = InMemorySaver()

agent = builder.compile(
    checkpointer=checkpointer
)

จากนั้นกำหนด thread_id

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

เรียกครั้งแรก

agent.invoke(
    {
        "messages": [
            HumanMessage(
                content="ฉันมีเงิน 100 บาท"
            )
        ],
        "llm_calls": 0,
    },
    config=config,
)

เรียกครั้งถัดไปด้วย thread_id เดิม

result = agent.invoke(
    {
        "messages": [
            HumanMessage(
                content="เพิ่มอีก 50 บาท รวมเป็นเท่าไร"
            )
        ],
        "llm_calls": 0,
    },
    config=config,
)

แนวคิด thread_id มีประโยชน์กับ

  • Chatbot
  • Personal Assistant
  • Customer Support
  • Long-running Workflow
  • Human approval flow

สำหรับ production ควรเลือก persistent checkpointer ที่เหมาะสมกับระบบ เช่น database-backed checkpoint storage แทนการเก็บเฉพาะใน process memory

#15. Human-in-the-loop

หนึ่งในจุดเด่นของ LangGraph คือ workflow สามารถหยุดรอมนุษย์ได้

ตัวอย่างงานที่เหมาะสม

AI สร้างคำสั่งโอนเงิน
        |
        v
Human Approval
        |
     Approve?
      /    \
    Yes     No
    |        |
 Execute   Cancel

แนวทางนี้สำคัญเมื่อ Agent มีสิทธิ์ทำ Action ที่มีผลจริง เช่น

  • ส่ง Email
  • Deploy Production
  • ลบข้อมูล
  • อนุมัติเอกสาร
  • สร้าง Purchase Order
  • เรียก Payment API

หลักการออกแบบที่ดีคือ

ให้ AI มี autonomy เฉพาะส่วนที่มีความเสี่ยงต่ำ และใส่ approval gate ก่อน action ที่มีผลกระทบสูง

#16. จาก Single Agent ไป Multi-Agent

เมื่อระบบซับซ้อนขึ้น เราสามารถสร้างหลาย Agent และเชื่อมเป็น Graph

ตัวอย่าง

flowchart TD
    U[User]
    S[Supervisor]
    R[Research Agent]
    C[Coding Agent]
    D[Database Agent]
    A[Answer Agent]

    U --> S
    S --> R
    S --> C
    S --> D

    R --> A
    C --> A
    D --> A

    A --> U

แต่ละ Agent มีหน้าที่เฉพาะ

Agent หน้าที่
Supervisor วิเคราะห์คำขอและ routing
Research Agent ค้นหาและสรุปข้อมูล
Coding Agent วิเคราะห์หรือสร้าง code
Database Agent Query ข้อมูล
Answer Agent รวมผลและสร้างคำตอบ

LangGraph เหมาะกับ architecture ลักษณะนี้เพราะสามารถกำหนด

  • state ร่วม
  • routing
  • loop
  • parallel branches
  • retry
  • checkpoint
  • human approval

ได้ในระดับ Graph

#17. แนวทางจัดโครงสร้าง Project

เมื่อ project เริ่มใหญ่ ไม่ควรรวมทุกอย่างไว้ใน main.py

โครงสร้างตัวอย่าง

langgraph-agent/
│
├── .env
├── pyproject.toml
│
├── app/
│   ├── __init__.py
│   │
│   ├── graph.py
│   ├── state.py
│   ├── models.py
│   │
│   ├── nodes/
│   │   ├── __init__.py
│   │   ├── llm_node.py
│   │   └── tool_node.py
│   │
│   └── tools/
│       ├── __init__.py
│       ├── calculator.py
│       ├── database.py
│       └── search.py
│
└── tests/
    ├── test_tools.py
    └── test_graph.py

แบ่ง responsibility ออกจากกันชัดเจน จะช่วยให้

  • test ง่าย
  • เปลี่ยน model ง่าย
  • เพิ่ม tool ง่าย
  • เพิ่ม node ง่าย
  • ดูแล routing ง่าย
  • รองรับ Multi-Agent ในอนาคต

#18. การทดสอบ Agent

Agent ไม่ควรทดสอบเฉพาะ final answer

ควรแยกทดสอบอย่างน้อย 4 ระดับ

#18.1 Tool Test

def test_add():
    assert add.invoke(
        {
            "a": 2,
            "b": 3,
        }
    ) == 5

#18.2 Node Test

ทดสอบว่าแต่ละ Node update state ถูกต้อง

#18.3 Routing Test

ตรวจสอบว่า

มี tool_calls

ต้อง route ไป Tool

และ

ไม่มี tool_calls

ต้องไป END

#18.4 End-to-End Agent Test

ทดสอบ workflow จริงตั้งแต่

User Input
   ↓
LLM
   ↓
Tool
   ↓
LLM
   ↓
Final Answer

สำหรับ production ควรเก็บ trace และวัด metric เช่น

  • Task Success Rate
  • Tool Selection Accuracy
  • Tool Execution Error Rate
  • Number of LLM Calls
  • Latency
  • Token Usage
  • Cost
  • Hallucination Rate

#19. LangGraph เหมาะกับงานแบบไหน

LangGraph เหมาะมากเมื่อระบบมีคุณสมบัติต่อไปนี้

#ต้องมีหลายขั้นตอน

เช่น

วิเคราะห์ → ค้นข้อมูล → ตรวจสอบ → สรุป

#ต้องมี Loop

เช่น

LLM → Tool → LLM → Tool → LLM

#ต้องเก็บ State

เช่น Chatbot หรือ workflow ที่ใช้เวลานาน

#ต้องมี Routing

เช่น

Question
  |
  +--> SQL Agent
  |
  +--> RAG Agent
  |
  +--> Web Search Agent

#ต้องมี Human Approval

เช่น Agent ที่มีสิทธิ์ execute action สำคัญ

#ต้องสร้าง Multi-Agent System

เช่น Supervisor + Specialized Agents

#20. เมื่อไรไม่จำเป็นต้องใช้ LangGraph

ถ้าระบบเป็นเพียง

Prompt → LLM → Answer

การใช้ LangGraph อาจซับซ้อนเกินความจำเป็น

ในกรณีที่ workflow เป็น sequence ตายตัว เช่น

Step A
  ↓
Step B
  ↓
Step C

โดยไม่มี routing, state, tool loop หรือ decision making การใช้ function ธรรมดาหรือ workflow engine ที่ง่ายกว่าอาจเพียงพอ

#21. Best Practices

#1. ให้ Tool ทำงานเฉพาะเจาะจง

ไม่ควรสร้าง Tool ที่ทำทุกอย่าง

ไม่ดี

do_everything()

ดีกว่า

search_documents()
get_customer()
create_ticket()
calculate_total()

#2. Tool Description ต้องชัดเจน

LLM ใช้ชื่อ Tool, argument schema และ description ในการตัดสินใจเลือก Tool

#3. จำกัด Loop

ควรมีแนวทางป้องกัน Agent วนไม่จบ เช่น

  • recursion limit
  • maximum tool calls
  • timeout
  • retry policy

#4. Validate Tool Input

อย่าเชื่อ argument จาก LLM โดยอัตโนมัติ โดยเฉพาะ Tool ที่ทำ action จริง

#5. แยก Read Tool และ Write Tool

ตัวอย่าง

Read
- search_order
- get_customer
- query_database

Write
- update_order
- delete_customer
- send_payment

Write Tool ควรมี security control สูงกว่า

#6. เก็บ Trace

Agent system มี behavior แบบ dynamic จึงควร trace

Input
 ↓
Node
 ↓
Model
 ↓
Tool call
 ↓
Tool result
 ↓
Routing
 ↓
Output

การดูเฉพาะ final answer ทำให้ debug ยาก

#7. ใส่ Human Approval ใน High-Risk Action

โดยเฉพาะงาน

  • Payment
  • Deployment
  • Delete
  • External Communication
  • Permission Change

#22. LangGraph กับ LangChain Agent

โดยภาพรวม

LangChain Agent
      |
      | ใช้งานง่ายกว่า
      | abstraction สูงกว่า
      v
Prebuilt Agent Architecture

LangGraph
      |
      | ควบคุม workflow มากกว่า
      | abstraction ต่ำกว่า
      v
Custom Agent Architecture

LangChain agents เองสามารถใช้ LangGraph เป็น execution foundation ได้

ดังนั้นไม่ได้หมายความว่าต้องเลือกอย่างใดอย่างหนึ่งเสมอไป

เลือกตามระดับ control ที่ต้องการ

#23. สรุป

LangGraph ทำให้การสร้าง Agent เปลี่ยนจากแนวคิด

Prompt → LLM → Answer

ไปเป็น

State
  ↓
Node
  ↓
Decision
  ↓
Tool
  ↓
State Update
  ↓
Loop / Route
  ↓
Final Answer

หัวใจสำคัญที่ควรรู้มี 5 เรื่อง

  1. State — ข้อมูลกลางของ Agent
  2. Node — ขั้นตอนประมวลผล
  3. Edge — เส้นทางการทำงาน
  4. Conditional Edge — การตัดสินใจและ Routing
  5. Cycle — ทำให้ LLM เรียก Tool และกลับมาคิดต่อได้

เมื่อเข้าใจ 5 แนวคิดนี้แล้ว สามารถต่อยอดจาก Single Agent ไปสู่

RAG Agent
    ↓
Tool-Using Agent
    ↓
Agent with Memory
    ↓
Human-in-the-loop Agent
    ↓
Multi-Agent System

ได้อย่างเป็นระบบ

#References