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

LangChain เป็น Framework สำหรับพัฒนาแอปพลิเคชันที่ใช้ Large Language Model (LLM) โดยมี abstraction สำหรับ Model, Prompt, Tool, Memory, Retrieval และ Agent

ใน LangChain รุ่นปัจจุบัน การสร้าง Agent สามารถเริ่มต้นได้ด้วย create_agent() ซึ่งช่วยให้ LLM สามารถตัดสินใจเลือกใช้ Tool ตามงานที่ผู้ใช้ร้องขอ แล้วนำผลจาก Tool กลับมาวิเคราะห์ต่อจนได้คำตอบสุดท้าย

บทความนี้ใช้แนวทาง LangChain API รุ่นใหม่ (langchain 1.x) และเน้น create_agent() แทน Agent API รุ่นเก่า

#1. AI Agent คืออะไร

LLM ปกติทำงานคล้ายฟังก์ชัน

Prompt
  ↓
LLM
  ↓
Answer

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

User
  ↓
Agent / LLM
  ↓
Reason about the task
  ↓
Select Tool
  ↓
Execute Tool
  ↓
Observe Result
  ↓
Continue or select another Tool
  ↓
Final Answer

Agent จึงเหมาะกับงานที่ต้องมีการตัดสินใจหลายขั้นตอน เช่น

  • ค้นหาข้อมูล
  • เรียก REST API
  • Query Database
  • คำนวณ
  • อ่านเอกสาร
  • ใช้ RAG
  • เรียก Service ภายในองค์กร
  • ทำ Workflow หลายขั้นตอน
  • ประสานงานระหว่าง Agent หลายตัว

#2. องค์ประกอบหลักของ LangChain Agent

Agent โดยทั่วไปประกอบด้วย 4 ส่วนสำคัญ

#2.1 Model

Model เป็น reasoning engine ของ Agent เช่น

  • OpenAI
  • Google Gemini
  • Anthropic Claude
  • AWS Bedrock
  • Ollama
  • OpenRouter
  • Hugging Face

ตัวอย่างการกำหนด Model

model="openai:gpt-5.4-mini"

#2.2 Tools

Tool คือฟังก์ชันที่ Agent สามารถเลือกเรียกใช้งานได้

ตัวอย่างเช่น

@tool
def get_product_price(product_name: str) -> str:
    """Get product price."""
    ...

LLM จะอ่านชื่อ Tool, parameter และ docstring เพื่อเข้าใจว่า Tool ใช้ทำอะไร

#2.3 System Prompt

System Prompt ใช้กำหนดบทบาท กติกา และพฤติกรรมของ Agent

system_prompt="""
คุณคือ AI Shopping Assistant
เลือกใช้เครื่องมือเมื่อจำเป็น
ตอบเป็นภาษาไทย
"""

#2.4 Agent Runtime

create_agent() สร้าง runtime แบบ graph-based โดยใช้ LangGraph อยู่เบื้องหลัง

Agent จะวนลูประหว่าง

Model
  ↓
Tool Call
  ↓
Tool Result
  ↓
Model

จนกระทั่ง Model สร้างคำตอบสุดท้ายหรือถึงเงื่อนไขหยุด

#3. เตรียม Project

ต้องใช้ Python 3.10 หรือใหม่กว่า

สร้าง Project

mkdir langchain-agent-demo
cd langchain-agent-demo

สร้าง Virtual Environment

python -m venv .venv

เปิดใช้งานบน macOS / Linux

source .venv/bin/activate

บน Windows

.venv\Scripts\activate

#4. ติดตั้ง LangChain

ติดตั้งด้วย pip

pip install -U langchain langchain-openai python-dotenv

หรือถ้าใช้ uv

uv init
uv add langchain langchain-openai python-dotenv

#5. กำหนด API Key

สร้างไฟล์ .env

OPENAI_API_KEY=your_openai_api_key

และควรเพิ่ม .env ลงใน .gitignore

.env
.venv/
__pycache__/

ห้าม commit API Key ขึ้น Git repository

#6. สร้าง Agent ตัวแรก

สร้างไฟล์

app.py

ตัวอย่างนี้จะสร้าง Shopping Agent ที่มี 3 Tools

  1. ค้นหาราคาสินค้า
  2. คำนวณค่าจัดส่ง
  3. คำนวณยอดรวม
import os

from dotenv import load_dotenv
from langchain.agents import create_agent
from langchain.tools import tool

load_dotenv()


PRODUCTS = {
    "mechanical keyboard": 1890,
    "wireless mouse": 990,
    "usb-c hub": 1290,
}


@tool
def get_product_price(product_name: str) -> str:
    """ค้นหาราคาสินค้าจากชื่อสินค้า"""

    name = product_name.lower().strip()
    price = PRODUCTS.get(name)

    if price is None:
        return f"ไม่พบสินค้า: {product_name}"

    return f"{product_name} ราคา {price} บาทต่อชิ้น"


@tool
def get_shipping_cost(province: str) -> float:
    """คำนวณค่าจัดส่งตามจังหวัด"""

    free_shipping = {
        "กรุงเทพมหานคร",
        "กรุงเทพ",
        "นครปฐม",
        "นนทบุรี",
    }

    if province.strip() in free_shipping:
        return 0

    return 80


@tool
def calculate_total(
    price: float,
    quantity: int,
    shipping: float,
) -> float:
    """คำนวณยอดรวมจากราคาต่อชิ้น จำนวนสินค้า และค่าจัดส่ง"""

    return (price * quantity) + shipping


agent = create_agent(
    model="openai:gpt-5.4-mini",
    tools=[
        get_product_price,
        get_shipping_cost,
        calculate_total,
    ],
    system_prompt="""
คุณคือ AI Shopping Assistant

หน้าที่:
- ช่วยลูกค้าค้นหาราคาสินค้า
- คำนวณค่าจัดส่ง
- คำนวณยอดรวม

กติกา:
- ใช้ Tool เมื่อจำเป็น
- ห้ามเดาราคาเอง
- ถ้าพบข้อมูลไม่เพียงพอให้แจ้งผู้ใช้
- ตอบเป็นภาษาไทย
- สรุปวิธีคำนวณให้เข้าใจง่าย
""",
)


result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": (
                    "ต้องการซื้อ Mechanical Keyboard จำนวน 2 ตัว "
                    "ส่งไปนครปฐม ต้องจ่ายทั้งหมดเท่าไร"
                ),
            }
        ]
    }
)

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

รัน

python app.py

Agent จะตัดสินใจประมาณนี้

User Request
   ↓
get_product_price()
   ↓
get_shipping_cost()
   ↓
calculate_total()
   ↓
Final Answer

ตัวอย่างผลลัพธ์

Mechanical Keyboard ราคา 1,890 บาทต่อชิ้น

จำนวน 2 ตัว:
1,890 × 2 = 3,780 บาท

จัดส่งไปนครปฐม:
ค่าจัดส่ง = 0 บาท

ยอดรวมทั้งหมด = 3,780 บาท

#7. Agent เลือก Tool ได้อย่างไร

สิ่งสำคัญมากของ Tool คือ

  • ชื่อฟังก์ชัน
  • Parameter
  • Type hint
  • Docstring

ตัวอย่าง

@tool
def get_weather(city: str) -> str:
    """ค้นหาสภาพอากาศปัจจุบันของเมืองที่กำหนด"""

LLM จะใช้ metadata เหล่านี้ในการตัดสินใจว่า Tool เหมาะกับคำถามหรือไม่

ดังนั้นควรเขียน Tool ให้มีหน้าที่ชัดเจน

ไม่ควรเขียน

@tool
def do_something(data: str):
    """Do something."""

ควรเขียน

@tool
def search_customer_by_email(email: str) -> str:
    """ค้นหาข้อมูลลูกค้าจาก email address"""

#8. ใช้ ChatOpenAI โดยตรง

นอกจากกำหนด Model เป็น String แล้ว เรายังสามารถสร้าง Model object เพื่อควบคุม configuration ได้ละเอียดขึ้น

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI


model = ChatOpenAI(
    model="gpt-5.4-mini",
    temperature=0,
    timeout=30,
    max_retries=2,
)


agent = create_agent(
    model=model,
    tools=[
        get_product_price,
        get_shipping_cost,
        calculate_total,
    ],
)

วิธีนี้เหมาะเมื่อจำเป็นต้องกำหนด

  • temperature
  • timeout
  • max retries
  • API endpoint
  • provider-specific options

#9. Streaming

หากต้องการดูผลระหว่าง Agent ทำงาน สามารถใช้ stream()

query = {
    "messages": [
        {
            "role": "user",
            "content": (
                "ซื้อ Wireless Mouse 3 ตัว "
                "ส่งเชียงใหม่ ต้องจ่ายเท่าไร"
            ),
        }
    ]
}

for step in agent.stream(
    query,
    stream_mode="values",
):
    message = step["messages"][-1]
    message.pretty_print()

Streaming มีประโยชน์มากสำหรับ

  • Chat UI
  • Debug Agent
  • ตรวจสอบ Tool Calling
  • ดู intermediate steps
  • แสดง progress ให้ผู้ใช้

#10. เชื่อมต่อ REST API เป็น Tool

ในระบบจริง Tool มักไม่ได้ใช้ข้อมูล hard-code แต่เรียก API

import requests

from langchain.tools import tool


@tool
def get_exchange_rate(currency: str) -> str:
    """ดึงอัตราแลกเปลี่ยนของสกุลเงิน"""

    response = requests.get(
        "https://api.example.com/exchange-rate",
        params={"currency": currency},
        timeout=10,
    )

    response.raise_for_status()

    return response.text

Agent สามารถใช้ API นี้เหมือน Tool ปกติ

#11. เชื่อม Database เป็น Tool

ตัวอย่างแนวคิด

@tool
def find_student(student_id: str) -> str:
    """ค้นหาข้อมูลนักศึกษาจากรหัสนักศึกษา"""

    student = database.find_by_id(student_id)

    if student is None:
        return "ไม่พบข้อมูลนักศึกษา"

    return student.to_json()

Agent จึงสามารถทำงานลักษณะ

User
 ↓
Agent
 ↓
Database Tool
 ↓
Result
 ↓
Agent
 ↓
Natural-language Answer

#12. Agent + RAG

RAG Retriever สามารถนำมาห่อเป็น Tool ได้

User
  ↓
Agent
  ├── Database Tool
  ├── REST API Tool
  └── RAG Search Tool
          ↓
      Vector Database

ตัวอย่าง conceptual code

@tool
def search_documents(query: str) -> str:
    """ค้นหาข้อมูลจาก Knowledge Base"""

    docs = retriever.invoke(query)

    return "\n\n".join(
        doc.page_content
        for doc in docs
    )

ทำให้ Agent เลือกเองได้ว่า

  • คำถามนี้ตอบจาก Model
  • คำถามนี้ต้องค้น Database
  • คำถามนี้ต้องค้น Knowledge Base
  • คำถามนี้ต้องใช้หลาย Tool ร่วมกัน

#13. Conversation และ Memory

Agent เก็บประวัติข้อความใน message state ระหว่างการทำงาน

สำหรับระบบที่ต้องการสนทนาหลายรอบ สามารถเพิ่ม persistence/checkpointer เพื่อเก็บ state ของแต่ละ conversation ได้

แนวคิด

User
 ↓
Thread / Conversation ID
 ↓
Agent State
 ↓
Messages + Tool Results
 ↓
Persistent Checkpointer

เหมาะกับ

  • Customer Support Agent
  • Personal Assistant
  • Tutor
  • Research Assistant
  • Coding Agent

#14. Structured Output

ในระบบ Production บางครั้งไม่ควรให้ Agent ตอบเป็นข้อความอิสระ แต่ควรกำหนด schema

ตัวอย่าง

from pydantic import BaseModel


class OrderSummary(BaseModel):
    product: str
    quantity: int
    subtotal: float
    shipping: float
    total: float

จากนั้นกำหนด response_format ให้ Agent เพื่อให้ผลลัพธ์อยู่ในรูปแบบที่โปรแกรมนำไปใช้งานต่อได้ง่าย

Structured Output เหมาะกับ

  • API response
  • Workflow automation
  • Data extraction
  • Database insertion
  • Integration กับ Frontend

#15. Observability ด้วย LangSmith

Agent มีหลายขั้นตอนกว่าการเรียก LLM ปกติ

ดังนั้นควรมี tracing เพื่อดูว่า

Prompt
 ↓
Model
 ↓
Tool Call
 ↓
Tool Result
 ↓
Model
 ↓
Final Output

สามารถเปิด LangSmith tracing ผ่าน environment variables

LANGSMITH_TRACING=true
LANGSMITH_API_KEY=your_langsmith_api_key

Tracing ช่วยตรวจสอบ

  • Agent เลือก Tool อะไร
  • Parameter ที่ส่งให้ Tool
  • Tool ใช้เวลานานเท่าไร
  • Model ใช้ Token เท่าไร
  • จุดที่ Error
  • Agent วนลูปผิดปกติหรือไม่

#16. Project Structure ที่แนะนำ

เมื่อ Project มีขนาดใหญ่ ไม่ควรวางทุกอย่างใน app.py

ตัวอย่าง

langchain-agent/
│
├── app.py
├── agent.py
├── models.py
│
├── tools/
│   ├── __init__.py
│   ├── product.py
│   ├── shipping.py
│   └── calculator.py
│
├── services/
│   ├── product_service.py
│   └── shipping_service.py
│
├── schemas/
│   └── order.py
│
├── tests/
│   ├── test_tools.py
│   └── test_agent.py
│
├── .env
├── .gitignore
└── pyproject.toml

หลักการคือแยก

Agent
Tools
Business Logic
External Services
Schemas
Tests

ออกจากกัน

#17. Tool กับ Business Logic ควรแยกกัน

ไม่ควรเขียน Business Logic จำนวนมากไว้ใน Tool

ไม่แนะนำ

@tool
def create_order(...):
    # validate
    # query database
    # calculate
    # call payment
    # call shipping
    # save database
    # send email

ควรให้ Tool เรียก Service Layer

@tool
def create_order(product_id: int, quantity: int) -> str:
    """สร้างคำสั่งซื้อ"""

    return order_service.create_order(
        product_id=product_id,
        quantity=quantity,
    )

ข้อดีคือ

  • Test ง่าย
  • เปลี่ยน Agent framework ได้
  • Business logic ไม่ผูกกับ LangChain
  • ลดความซับซ้อน
  • Reuse code ได้

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

ควรแยก Test เป็นหลายระดับ

#Unit Test Tool

def test_shipping_nakhon_pathom():
    result = get_shipping_cost.invoke(
        {"province": "นครปฐม"}
    )

    assert result == 0

#Integration Test

ทดสอบว่า Agent เลือก Tool ถูกหรือไม่

Question
   ↓
Expected Tool
   ↓
Expected Parameters

#End-to-End Test

ตรวจสอบตั้งแต่ User Request จนถึง Final Answer

User
 ↓
Agent
 ↓
Tools
 ↓
External System
 ↓
Answer

#19. Security ที่ต้องระวัง

Agent สามารถเรียก Tool และกระทำกับระบบจริงได้ ดังนั้นต้องระมัดระวังมากกว่า Chatbot ปกติ

ควรมีมาตรการอย่างน้อยดังนี้

#จำกัดสิทธิ์ของ Tool

Agent ไม่ควรเข้าถึง Database ด้วย account ที่มีสิทธิ์เกินความจำเป็น

#Validate Input

if quantity <= 0:
    raise ValueError("quantity must be greater than zero")

#Confirmation ก่อนทำ Action สำคัญ

เช่น

  • โอนเงิน
  • ลบข้อมูล
  • ส่ง Email
  • Deploy Production
  • ปิด Server

ควรให้ Human ยืนยันก่อน

#ห้ามส่ง Secret เข้า Prompt

เช่น

API Key
Database Password
Private Key
Access Token

ควรเก็บใน Secret Manager หรือ Environment Variable

#20. Agent เหมาะกับงานแบบไหน

Agent เหมาะเมื่อระบบต้อง

  • ตัดสินใจว่าจะใช้ Tool ใด
  • ใช้หลาย Tool ต่อเนื่องกัน
  • วางแผนหลายขั้นตอน
  • ทำงานกับข้อมูลหลายแหล่ง
  • ปรับเส้นทางการทำงานตามสถานการณ์

ตัวอย่าง

Research Agent
Customer Support Agent
Coding Agent
DevOps Agent
Data Analysis Agent
Database Agent
RAG Agent
Travel Agent
Teaching Assistant

#21. Agent ไม่เหมาะกับทุกงาน

ถ้า Workflow ตายตัว เช่น

Upload File
 ↓
Validate
 ↓
Convert
 ↓
Save

การเขียน workflow ปกติอาจเหมาะกว่า Agent

หลักคิดที่ดีคือ

Deterministic workflow
→ ใช้ Code / Workflow

Dynamic decision making
→ ใช้ Agent

ไม่ควรใช้ LLM ตัดสินใจในจุดที่โปรแกรมปกติสามารถตัดสินใจได้อย่างแน่นอนกว่า

#22. LangChain Agent Architecture

ภาพรวมระบบ Production อาจมีลักษณะดังนี้

flowchart LR

    U[User] --> API[API / Chat UI]

    API --> A[LangChain Agent]

    A --> LLM[LLM]

    A --> T1[Database Tool]
    A --> T2[REST API Tool]
    A --> T3[RAG Tool]
    A --> T4[Calculator Tool]

    T1 --> DB[(Database)]
    T2 --> EXT[External API]
    T3 --> VDB[(Vector DB)]

    A --> OBS[LangSmith / Observability]

    A --> API
    API --> U

#23. Development Roadmap

สำหรับผู้เริ่มต้น แนะนำเรียนตามลำดับ

1. Chat Model
      ↓
2. Prompt
      ↓
3. Tool Calling
      ↓
4. create_agent()
      ↓
5. Streaming
      ↓
6. Memory / Persistence
      ↓
7. RAG
      ↓
8. Structured Output
      ↓
9. LangSmith
      ↓
10. Middleware
      ↓
11. Multi-Agent

#24. สรุป

หัวใจของการสร้าง Agent ด้วย LangChain คือการรวม

LLM
+
Tools
+
Instructions
+
Agent Runtime

เข้าด้วยกัน

ใน LangChain รุ่นใหม่สามารถเริ่มต้นได้ง่ายด้วย

from langchain.agents import create_agent

agent = create_agent(
    model="openai:gpt-5.4-mini",
    tools=tools,
    system_prompt="You are a helpful assistant.",
)

จากนั้นเรียก

agent.invoke(...)

Agent จะเป็นผู้ตัดสินใจเองว่า

ต้องใช้ Tool หรือไม่
      ↓
ใช้ Tool ตัวไหน
      ↓
ใช้ Tool กี่ครั้ง
      ↓
นำผลลัพธ์มาประกอบคำตอบอย่างไร

จุดสำคัญสำหรับระบบจริงคือ อย่าให้ Agent รับผิดชอบ Business Logic ทั้งหมด แต่ควรใช้ Agent เป็นชั้นสำหรับ reasoning และ orchestration ส่วนกฎธุรกิจที่แน่นอนควรอยู่ใน Service หรือ Application Logic ที่สามารถทดสอบและควบคุมได้

#References