ใช้ LangGraph สร้าง Agentic RAG: วงจรค้นหา-คิด-ตรวจสอบ สำหรับมือใหม่

บทนำ: Agentic RAG คืออะไร และทำไมต้องเรียนรู้ตั้งแต่วันนี้

ในยุคที่ AI กลายเป็นเครื่องมือทำงานหลัก หลายคนอาจเคยใช้ ChatGPT หรือ Claude แล้วพบว่าบางครั้งคำตอบผิดพลาดหรือไม่ตรงกับข้อมูลจริง นี่คือจุดที่ "Agentic RAG" เข้ามาช่วยแก้ปัญหา Agentic RAG ย่อมาจาก Retrieval-Augmented Generation แบบมีตัวแทนอัจฉริยะ ซึ่งทำให้ AI สามารถค้นหาข้อมูลจากฐานข้อมูลของตัวเองก่อนตอบ แล้วตรวจสอบความถูกต้องก่อนส่งคำตอบสุดท้าย วันนี้ผมจะสอนคุณสร้างระบบ Agentic RAG ตั้งแต่เริ่มต้น โดยใช้ LangGraph ซึ่งเป็นเครื่องมือจาก Meta (Facebook) ที่ช่วยให้การสร้าง AI Agent ง่ายขึ้นมาก และใช้ HolySheep AI เป็น backend สำหรับเรียก LLM ด้วยค่าใช้จ่ายที่ประหยัดกว่า 85% เมื่อเทียบกับบริการอื่น ราคาเริ่มต้นเพียง $0.42 ต่อล้าน token (DeepSeek V3.2) และมีความเร็วตอบสนองต่ำกว่า 50 มิลลิวินาที

เตรียมเครื่องมือก่อนเริ่มต้น

ก่อนจะเริ่มเขียนโค้ด เราต้องติดตั้งโปรแกรมและขอ API Key ก่อน ทำตามขั้นตอนนี้ได้เลย **ขั้นตอนที่ 1: สมัครบัญชี HolySheep AI** เปิดเว็บไซต์ สมัครที่นี่ แล้วกรอกอีเมล ระบบจะส่ง API Key มาให้ทางอีเมลทันที พร้อมเครดิตฟรีสำหรับทดลองใช้ เมื่อได้ Key แล้วให้เก็บไว้ในที่ปลอดภัย อย่าแชร์ให้ใครเห็น **ขั้นตอนที่ 2: ติดตั้ง Python และโปรแกรมที่จำเป็น** ถ้ายังไม่มี Python ให้ไปที่ python.org แล้วดาวน์โหลดเวอร์ชันล่าสุด ระหว่างติดตั้ง อย่าลืมติ๊กถูกตรง "Add Python to PATH" ด้วย หลังติดตั้งเสร็จ เปิด Command Prompt (พิมพ์ cmd ในช่องค้นหา) แล้วพิมพ์คำสั่งติดตั้งไลบรารีที่จำเป็น:

pip install langchain langchain-community langgraph faiss-cpu openai tiktoken python-dotenv

รอสักครู่จนติดตั้งเสร็จ ถ้าพบข้อผิดพลาดเกี่ยวกับ version ให้ลองอัปเดต pip ก่อนด้วยคำสั่ง: pip install --upgrade pip

สร้างโครงสร้างโฟลเดอร์และไฟล์หลัก

สร้างโฟลเดอร์ใหม่ชื่อ agentic_rag แล้วสร้างไฟล์ดังนี้:

.
├── agentic_rag/
│   ├── main.py           # ไฟล์หลักที่รันโปรแกรม
│   ├── graph.py          # โค้ดสร้าง LangGraph
│   ├── retriever.py      # โค้ดค้นหาข้อมูล
│   ├── verifier.py        # โค้ดตรวจสอบความถูกต้อง
│   ├── documents/        # โฟลเดอร์เก็บเอกสารต้นทาง
│   └── .env               # ไฟล์เก็บ API Key

วิธีสร้างโฟลเดอร์: เปิด Command Prompt แล้วพิมพ์ mkdir agentic_rag แล้ว cd agentic_rag จากนั้นพิมพ์ mkdir documents

ขั้นตอนที่ 1: ตั้งค่า HolySheep API และโหลดเอกสาร

สร้างไฟล์ .env ในโฟลเดอร์ agentic_rag โดยพิมพ์ข้อความนี้:

HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY

แทนที่ YOUR_HOLYSHEEP_API_KEY ด้วย Key ที่ได้จากการสมัคร แล้วสร้างไฟล์ main.py ด้วยโค้ดนี้:

import os
from dotenv import load_dotenv
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS

load_dotenv()

ตรวจสอบว่า API Key ถูกโหลดหรือไม่
api_key = os.getenv("HOLYSHEEP_API_KEY")
if not api_key:
    raise ValueError("ไม่พบ API Key กรุณาตรวจสอบไฟล์ .env")

print("กำลังโหลดเอกสาร...")

โหลดเอกสารจากโฟลเดอร์ documents
loader = TextLoader("documents/sample.txt")
documents = loader.load()

แบ่งเอกสารเป็นส่วนเล็กๆ
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = splitter.split_documents(documents)

print(f"แบ่งเอกสารเสร็จแล้ว ได้ {len(chunks)} ชิ้น")

สร้าง vector store สำหรับค้นหา
ใช้ HolySheep API แทน OpenAI โดยตรง
embeddings = OpenAIEmbeddings(
    openai_api_base="https://api.holysheep.ai/v1",
    openai_api_key=api_key,
    model="text-embedding-3-small"
)

vectorstore = FAISS.from_documents(chunks, embeddings)
print("Vector store สร้างเสร็จแล้ว")

สร้างไฟล์ sample.txt ในโฟลเดอร์ documents โดยใส่ข้อมูลทดสอบ เช่น ข้อมูลบริษัท หรือคำถามที่พบบ่อย

ขั้นตอนที่ 2: สร้างตัวค้นหาข้อมูลอัจฉริยะ

ไฟล์ retriever.py จะทำหน้าที่ค้นหาข้อมูลที่เกี่ยวข้องจาก vector store พร้อมวิเคราะห์ว่าควรดึงข้อมูลเพิ่มหรือไม่:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os

os.environ["OPENAI_API_BASE"] = "https://api.holysheep.ai/v1"
os.environ["OPENAI_API_KEY"] = os.getenv("HOLYSHEEP_API_KEY")

llm = ChatOpenAI(
    model="gpt-4.1",
    temperature=0.3,
    api_key=os.getenv("HOLYSHEEP_API_KEY")
)

Prompt สำหรับตัดสินใจว่าต้องค้นหาเพิ่มหรือไม่
decision_prompt = ChatPromptTemplate.from_messages([
    ("system", "คุณเป็นผู้ช่วยตัดสินใจการค้นหาข้อมูล"),
    ("human", "คำถาม: {question}\nข้อมูลที่พบ: {context}\n\nตอบว่า 'ค้นหาเพิ่ม' หรือ 'เพียงพอแล้ว'")
])

class IntelligentRetriever:
    def __init__(self, vectorstore):
        self.vectorstore = vectorstore
        self.llm = llm
        
    def search(self, question: str, num_results: int = 3):
        # ค้นหาข้อมูลที่เกี่ยวข้อง
        docs = self.vectorstore.similarity_search(question, k=num_results)
        context = "\n".join([doc.page_content for doc in docs])
        
        # ตัดสินใจว่าควรค้นหาเพิ่มหรือไม่
        decision = self.llm.invoke(
            decision_prompt.format(question=question, context=context)
        )
        
        needs_more = "ค้นหาเพิ่ม" in decision.content
        
        return {
            "context": context,
            "needs_more_search": needs_more,
            "sources": docs
        }
    
    def search_more(self, question: str, existing_context: str):
        # ค้นหาเพิ่มด้วยคำค้นหาที่กว้างขึ้น
        new_docs = self.vectorstore.similarity_search(
            question + " related topics", 
            k=5
        )
        new_context = "\n".join([doc.page_content for doc in new_docs])
        return existing_context + "\n\n" + new_context

print("ตัวค้นหาอัจฉริยะพร้อมใช้งาน")

หลังจากสร้างไฟล์นี้เสร็จ คุณจะเห็นว่าโค้ดใช้ HolySheep API โดยตรง โดยกำหนด base_url เป็น https://api.holysheep.ai/v1 ตามที่กำหนดไว้ ราคาของ GPT-4.1 บน HolySheep อยู่ที่ $8 ต่อล้าน token ซึ่งถูกกว่าบริการอื่นมาก

ขั้นตอนที่ 3: สร้างตัวตรวจสอบความถูกต้อง

ไฟล์ verifier.py จะตรวจสอบว่าคำตอบที่สร้างขึ้นตรงกับข้อมูลจริงในเอกสารหรือไม่:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os

os.environ["OPENAI_API_BASE"] = "https://api.holysheep.ai/v1"
os.environ["OPENAI_API_KEY"] = os.getenv("HOLYSHEEP_API_KEY")

verifier_llm = ChatOpenAI(
    model="gpt-4.1",
    temperature=0,
    api_key=os.getenv("HOLYSHEEP_API_KEY")
)

verification_prompt = ChatPromptTemplate.from_messages([
    ("system", """คุณเป็นผู้ตรวจสอบความถูกต้องของคำตอบ
    - ตรวจสอบว่าข้อเท็จจริงในคำตอบตรงกับข้อมูลในเอกสารหรือไม่
    - ถ้าตรง: ตอบ 'ถูกต้อง: [เหตุผล]'
    - ถ้าไม่ตรง: ตอบ 'ผิดพลาด: [สิ่งที่ต้องแก้ไข]' และแก้ไขให้ถูกต้อง
    - ถ้าไม่มีข้อมูลในเอกสาร: ตอบ 'ไม่มีข้อมูล: ควรตอบว่าไม่ทราบ'"""),
    ("human", """เอกสารต้นทาง:
    {context}
    
    คำถาม: {question}
    
    คำตอบที่ตรวจสอบ: {answer}""")
])

class AnswerVerifier:
    def __init__(self):
        self.llm = verifier_llm
        
    def verify(self, question: str, answer: str, context: str):
        result = self.llm.invoke(
            verification_prompt.format(
                question=question,
                answer=answer,
                context=context
            )
        )
        
        response = result.content
        
        if response.startswith("ถูกต้อง"):
            return {"is_valid": True, "feedback": response, "corrected_answer": answer}
        elif response.startswith("ผิดพลาด"):
            return {"is_valid": False, "feedback": response, "corrected_answer": response.split("]", 1)[1].strip()}
        else:
            return {"is_valid": False, "feedback": response, "corrected_answer": "ขออภัย ฉันไม่พบข้อมูลที่แน่นอนในเอกสารเพื่อตอบคำถามนี้"}

print("ตัวตรวจสอบความถูกต้องพร้อมใช้งาน")

ส่วนนี้สำคัญมากเพราะช่วยลดปัญหา "hallucination" หรือการที่ AI สร้างคำตอบที่ฟังดูน่าเชื่อแต่ไม่ตรงความจริง

ขั้นตอนที่ 4: รวมทุกอย่างด้วย LangGraph

ไฟล์ graph.py จะรวม retriever, generator และ verifier เข้าด้วยกันในรูปแบบวงจร:

from langgraph.graph import StateGraph, END
from typing import TypedDict, List
import os
from retriever import IntelligentRetriever
from verifier import AnswerVerifier

กำหนดโครงสร้างข้อมูลที่ไหลผ่านในระบบ
class AgentState(TypedDict):
    question: str
    context: str
    answer: str
    verification_result: dict
    loop_count: int

def create_agentic_rag_graph(vectorstore):
    # สร้าง instances
    retriever = IntelligentRetriever(vectorstore)
    verifier = AnswerVerifier()
    
    # สร้าง graph
    graph = StateGraph(AgentState)
    
    # ขั้นตอนที่ 1: ค้นหาข้อมูล
    def retrieve_node(state):
        print(f"🔍 กำลังค้นหาข้อมูลสำหรับ: {state['question']}")
        result = retriever.search(state['question'])
        return {
            "context": result["context"],
            "loop_count": state.get("loop_count", 0) + (1 if result["needs_more_search"] else 0)
        }
    
    # ขั้นตอนที่ 2: สร้างคำตอบ
    def generate_node(state):
        print("✍️ กำลังสร้างคำตอบ...")
        from langchain_openai import ChatOpenAI
        from langchain_core.prompts import ChatPromptTemplate
        
        os.environ["OPENAI_API_BASE"] = "https://api.holysheep.ai/v1"
        generator = ChatOpenAI(
            model="gpt-4.1",
            temperature=0.5,
            api_key=os.getenv("HOLYSHEEP_API_KEY")
        )
        
        prompt = ChatPromptTemplate.from_messages([
            ("system", "คุณเป็นผู้เชี่ยวชาญ ตอบคำถามโดยใช้ข้อมูลจากเอกสารที่ให้มาเท่านั้น"),
            ("human", "ข้อมูล: {context}\n\nคำถาม: {question}")
        ])
        
        answer = generator.invoke(
            prompt.format(context=state["context"], question=state["question"])
        )
        
        return {"answer": answer.content}
    
    # ขั้นตอนที่ 3: ตรวจสอบความถูกต้อง
    def verify_node(state):
        print("✅ กำลังตรวจสอบความถูกต้อง...")
        result = verifier.verify(
            state["question"],
            state["answer"],
            state["context"]
        )
        return {"verification_result": result}
    
    # ตัดสินใจว่าจะวนซ้ำหรือจบ
    def should_continue(state):
        if state["verification_result"]["is_valid"]:
            return "end"
        elif state["loop_count"] >= 3:
            return "end"
        else:
            return "continue"
    
    # เพิ่ม nodes และ edges
    graph.add_node("retrieve", retrieve_node)
    graph.add_node("generate", generate_node)
    graph.add_node("verify", verify_node)
    
    graph.set_entry_point("retrieve")
    graph.add_edge("retrieve", "generate")
    graph.add_edge("generate", "verify")
    graph.add_conditional_edges(
        "verify",
        should_continue,
        {
            "continue": "retrieve",
            "end": END
        }
    )
    
    return graph.compile()

print("LangGraph Agentic RAG สร้างเสร็จแล้ว")

หลังจากรันโค้ดนี้ ระบบจะทำงานเป็นวงจร 3 ขั้นตอน: ค้นหา → สร้างคำตอบ → ตรวจสอบ ถ้าคำตอบไม่ถูกต้อง ระบบจะวนกลับไปค้นหาใหม่อีกครั้ง แต่ไม่เกิน 3 รอบ

ขั้นตอนที่ 5: รันโปรแกรมและทดสอบ

อัปเดตไฟล์ main.py เพื่อรันระบบทั้งหมด:

from graph import create_agentic_rag_graph
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
import os
from dotenv import load_dotenv

load_dotenv()

print("=" * 50)
print("  Agentic RAG - ระบบค้นหาและตอบคำถามอัจฉริยะ")
print("=" * 50)

โหลดและเตรียมข้อมูล
print("\n📂 กำลังโหลดเอกสาร...")
loader = TextLoader("documents/sample.txt")
documents = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(documents)

print(f"   ✓ โหลด {len(chunks)} ชิ้นข้อมูลเรียบร้อย")

สร้าง vector store
api_key = os.getenv("HOLYSHEEP_API_KEY")
embeddings = OpenAIEmbeddings(
    openai_api_base="https://api.holysheep.ai/v1",
    openai_api_key=api_key,
    model="text-embedding-3-small"
)

print("🔢 กำลังสร้าง vector store...")
vectorstore = FAISS.from_documents(chunks, embeddings)
print("   ✓ Vector store พร้อม")

สร้าง agent
print("🤖 กำลังสร้าง Agent...")
app = create_agentic_rag_graph(vectorstore)
print("   ✓ Agent พร้อม")

รับคำถามจากผู้ใช้
print("\n" + "=" * 50)
print("  พิมพ์คำถามของคุณ (พิมพ์ 'exit' เพื่อออก)")
print("=" * 50)

while True:
    question = input("\n❓ คำถาม: ")
    if question.lower() == "exit":
        print("ขอบคุณที่ใช้บริการ!")
        break
    
    print("\n⏳ กำลังประมวลผล...")
    
    # รัน agent
    result = app.invoke({
        "question": question,
        "context": "",
        "answer": "",
        "verification_result": {},
        "loop_count": 0
    })
    
    print("\n" + "=" * 50)
    print("📝 คำตอบ:")
    print("-" * 50)
    print(result["answer"])
    print("=" * 50)

หลังจากเตรียมทุกอย่างเสร็จ ให้รันโปรแกรมด้วยคำสั่ง: python main.py

ผลลัพธ์ที่คาดหวัง

เมื่อรันโปรแกรมแล้ว คุณจะเห็นหน้าจอแบบนี้:

==================================================
  Agentic RAG - ระบบค้นหาและตอบคำถามอัจฉริยะ
==================================================

📂 กำลังโหลดเอกสาร...
   ✓ โหลด 5 ชิ้นข้อมูลเรียบร้อย
🔢 กำลังสร้าง vector store...
   ✓ Vector store พร้อม
🤖 กำลังสร้าง Agent...
   ✓ Agent พร้อม

==================================================
  พิมพ์คำถามของคุณ (พิมพ์ 'exit' เพื่อออก)
==================================================

❓ คำถาม: บริษัทของเรามีนโยบายเรื่องการลาอย่างไร?

⏳ กำลังประมวลผล...
🔍 กำลังค้นหาข้อมูลสำหรับ: บริษัทของเรามีนโยบายเรื่องการลาอย่างไร?
✍️ กำลังสร้างคำตอบ...
✅ กำลังตรวจสอบความถูกต้อง...

==================================================
📝 คำตอบ:
--------------------------------------------------
ตามนโยบายบริษัท พนักงานสามารถลาพักร้อนได้ 12 วันต่อปี 
โดยต้องแจ้งล่วงหน้าอย่างน้อย 7 วัน...
==================================================

ระบบจะแสดงขั้นตอนการทำงานทีละขั้นตอน เพื่อให้เห็นว่า AI ทำงานอย่างไร

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

**กรณีที่ 1: ไม่พบ API Key**

Error: No API Key found
หรือ
ValueError: API Key not found in environment

วิธีแก้:
1. ตรวจสอบว่าไฟล์ .env อยู่ในโฟลเดอร์เดียวกับ main.py
2. ตรวจสอบว่าไม่มีช่องว่างก่อนหรือหลัง =
   ถูกต้อง: HOLYSHEEP_API_KEY=sk-xxxx
   ผิด:  HOLYSHEEP_API_KEY = sk-xxxx
3. รีสตาร์ท Command Prompt หลังแก้ไขไฟล์ .env

**กรณีที่ 2: Import Error เกี่ยวกับ langchain**

ImportError: cannot import name 'OpenAIEmbeddings' from 'langchain_community'

วิธีแก้:
pip install --upgrade langchain langchain-community langchain-openai
หรือถ้า still error
pip install langchain-ollama  # ใช้ alternative embeddings

**กรณีที่