15 เฟรมเวิร์ก Python ชั้นนำสำหรับสร้างแอป Agentic AI แบบครบวงจร

ปัจจุบันการสร้างแอป Agentic AI ง่ายขึ้นมากเมื่อเทียบกับไม่กี่ปีก่อน แทนที่จะต้องสร้างลูปเอเจนต์ การเชื่อมต่อเครื่องมือ หน่วยความจำ การดึงข้อมูล และการออร์เคสเตรตตั้งแต่ศูนย์ นักพัฒนาสามารถใช้เฟรมเวิร์ก Python ที่มีคอมโพเนนต์เหล่านี้ให้พร้อมใช้งานแล้วส่วนใหญ่

ผู้เขียนใช้เฟรมเวิร์กหลายตัวในบทความนี้เพื่อ สร้างแอป RAG เอเจนต์อัตโนมัติ ระบบหลายเอเจนต์ และเครื่องมือ AI ที่พร้อมดีพลอย

มักใช้ LangChain สำหรับเวิร์กโฟลว์เอเจนต์ที่ยืดหยุ่น, LlamaIndex และ Haystack สำหรับแอปที่เชื่อมต่อข้อมูล และ OpenAI Agents SDK หรือ Google ADK เมื่ออยากให้เชื่อมต่อกับโมเดลของผู้ให้บริการได้รวดเร็ว

เฟรมเวิร์กบางตัวพัฒนาไปมากจนบ่อยครั้งไม่จำเป็นต้องสร้างโซลูชันใหม่เอง ด้วยคีย์ API เครดิตโมเดล และเฟรมเวิร์กที่เหมาะสม ก็สามารถสร้างเอเจนต์ เชื่อมต่อกับเครื่องมือหรือข้อมูลส่วนตัว ทดสอบ และดีพลอยผ่าน API หรือส่วนติดต่อผู้ใช้ได้

บทความนี้เปรียบเทียบเฟรมเวิร์ก Python จำนวน 15 ตัวใน 5 หมวด: เฟรมเวิร์กเอเจนต์เอนกประสงค์, SDK เอเจนต์ทางการ, เฟรมเวิร์กออร์เคสเตรตหลายเอเจนต์, เฟรมเวิร์กข้อมูลและ RAG และเฟรมเวิร์กแบบน้ำหนักเบาสำหรับโมเดลเปิด

แต่ละส่วนมีตัวอย่าง Python สั้น ๆ ให้คัดลอก วาง และทดสอบเพื่อเข้าใจการทำงานของเฟรมเวิร์กได้อย่างรวดเร็ว

เฟรมเวิร์กเอเจนต์เอนกประสงค์

เฟรมเวิร์กเหล่านี้ให้บล็อกองค์ประกอบสำหรับสร้างเอเจนต์ เชื่อมต่อเครื่องมือ จัดการสถานะ และควบคุมเวิร์กโฟลว์หลายขั้นตอน

1. LangChain

สำหรับนักพัฒนาจำนวนมาก การพัฒนาแอป LLM แบบสมัยใหม่เริ่มจาก LangChain เฟรมเวิร์ก Python แบบโอเพนซอร์สที่ออกแบบมาเพื่อเชื่อมโมเดลภาษาเข้ากับข้อมูลภายนอก เครื่องมือ API และลอจิกของแอป กลายเป็นหนึ่งในเฟรมเวิร์กชุดแรกที่ถูกใช้อย่างแพร่หลายในการใช้ OpenAI API ร่วมกับเว็บไซต์ เอกสาร เวกเตอร์ดาต้าเบส และแหล่งข้อมูลอื่น ๆ เพื่อสร้างแอปที่รับรู้บริบทมากขึ้น

ทุกวันนี้ LangChain พัฒนาเป็นอีโคซิสเต็มครบวงจรสำหรับสร้างแอป Agentic AI ตั้งแต่ต้นจนจบ รวมถึงระบบ RAG เอเจนต์ที่ใช้เครื่องมือ เวิร์กโฟลว์ การเชื่อมต่อ การมอนิเตอร์ และการประเมิน แนะนำให้ดู เส้นทาง AI Engineering with LangChain เพื่อเรียนรู้เพิ่มเติม

ตัวอย่างต่อไปนี้สร้างเอเจนต์ LangChain แบบง่ายที่ใช้เครื่องมือค้นหาเอกสารเพื่อหาข้อมูลที่เกี่ยวข้องก่อนตอบคำถาม

# pip install -U langchain "langchain[openai]"

from langchain.agents import create_agent

def search_docs(query: str) -> str:
    """Search the company documentation."""
    return f"Documentation found for: {query}"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[search_docs],
    system_prompt="Use the documentation tool when needed.",
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "What is our remote-work policy?"
    }]
})

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

2. LangGraph

แม้ LangChain จะทำให้การสร้างเอเจนต์และเครื่องมือเป็นเรื่องง่าย แต่ LangGraph ให้การควบคุมการทำงานของเอเจนต์ได้มากขึ้น ช่วยให้นักพัฒนาจัดโครงสร้างแอปเป็นกราฟของขั้นตอนที่เชื่อมต่อกัน ทำให้ง่ายต่อการควบคุมลูป การเรียกใช้เครื่องมือ สถานะแชร์ การอนุมัติโดยมนุษย์ และเวิร์กโฟลว์หลายเอเจนต์

มีประโยชน์มากเมื่อสร้างเอเจนต์อัตโนมัติที่ต้องตัดสินใจซ้ำ ๆ ว่าจะทำอะไร เลือกเครื่องมือที่ใช่ ตรวจผลลัพธ์ และทำต่อจนงานเสร็จ LangGraph ยังรองรับการคงสภาพการทำงาน สตรีมมิง เช็คพอยต์ และการกู้คืนสำหรับแอปที่ทำงานนาน ดูรายละเอียดได้ใน คู่มือ LangGraph

ตัวอย่างต่อไปนี้สร้างเอเจนต์ที่สามารถเรียกเครื่องคิดเลขซ้ำ ๆ จนมีข้อมูลพอที่จะตอบได้:

# pip install -U langgraph langchain langchain-openai

from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.graph import MessagesState, StateGraph, START
from langgraph.prebuilt import ToolNode, tools_condition

model = init_chat_model("openai:gpt-5.5", temperature=0)

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

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

tools = [add, multiply]
model_with_tools = model.bind_tools(tools)

def call_model(state: MessagesState):
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

builder = StateGraph(MessagesState)
builder.add_node("agent", call_model)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")

agent = builder.compile()

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Add 12 and 8, then multiply the result by 3."
    }]
})

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

กราฟจะส่งคำขอไปยังโมเดล เรียกใช้เครื่องมือที่จำเป็น และวนกลับสู่โมเดลจนกว่าจะสร้างคำตอบสุดท้าย

3. Agno

Agno คือเฟรมเวิร์ก Python สำหรับสร้างเอเจนต์ ทีมหลายเอเจนต์ และเวิร์กโฟลว์แบบมีโครงสร้าง รวมทั้งมี AgentOS ที่ช่วยให้นักพัฒนาเปิดให้บริการเอเจนต์ผ่าน API จัดเก็บเซสชันและเทรซ และจัดการเป็นแอประดับโปรดักชัน เนื่องจากรันบนอินฟราสตรักเชอร์ของตนเองได้ องค์กรจึงควบคุมข้อมูลและความปลอดภัยได้มากขึ้น

ตัวอย่างต่อไปนี้สร้างเอเจนต์ค้นคว้าที่สามารถค้นเว็บก่อนสรุปคำตอบอย่างกระชับ

# pip install -U agno ddgs openai

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    name="AI Research Assistant",
    model=OpenAIResponses(id="gpt-5.5"),
    tools=[DuckDuckGoTools()],
    instructions="Search when needed and keep the answer concise.",
)

agent.print_response(
    "Find one recent development in open-source AI and summarize it.",
    stream=True,
)

เอเจนต์จะใช้เครื่องมือค้นหาเพื่อหาข้อมูลล่าสุดและสตรีมสรุปสั้น ๆ ให้ผู้ใช้

4. Pydantic AI

Pydantic AI เป็นเฟรมเวิร์ก Python-native จากทีม Pydantic สำหรับสร้างเอเจนต์และแอปเจเนอเรทีฟ AI ให้ความรู้สึกคล้ายทำงานกับโมเดล Pydantic หรือ FastAPI เพราะเอเจนต์ เครื่องมือ ดีเพนเดนซี และเอาต์พุต ถูกกำหนดด้วยฟังก์ชัน Python มาตรฐาน type hints เดคอเรเตอร์ และคลาส BaseModel จากนั้นใช้การตรวจสอบของ Pydantic เพื่อคงโครงสร้างและความน่าเชื่อถือของอาร์กิวเมนต์เครื่องมือและผลลัพธ์โมเดล

แนะนำ บทเรียน Pydantic AI เพื่อทำความเข้าใจเฟรมเวิร์กมากขึ้น

ตัวอย่างต่อไปนี้สร้างเอเจนต์ที่ส่งคืนแผนบทความแบบผ่านการตรวจสอบเป็นโมเดล Pydantic

# pip install -U pydantic-ai

from pydantic import BaseModel, Field
from pydantic_ai import Agent


class ArticlePlan(BaseModel):
    title: str
    key_points: list[str]
    reading_time_minutes: int = Field(ge=1)


agent = Agent(
    "openai:gpt-5.6-sol",
    output_type=ArticlePlan,
    instructions="Create concise article plans for technical readers.",
)

result = agent.run_sync(
    "Create a short article plan about building AI agents in Python."
)

print(result.output)

เอเจนต์จะสร้างอ็อบเจ็กต์ ArticlePlan และตรวจสอบให้ทุกฟิลด์ตรงตามชนิดและกฎของ Python ที่กำหนดก่อนส่งคืน

SDK เอเจนต์ทางการ

SDK เอเจนต์ทางการดูแลโดยผู้ให้บริการ AI และมักมอบการเชื่อมต่อกับโมเดล API เครื่องมือ ระบบดีพลอย และแพลตฟอร์มสังเกตการณ์ของตนเองที่ง่ายที่สุด

5. OpenAI Agents SDK

OpenAI Agents SDK เป็น เฟรมเวิร์กแบบน้ำหนักเบา เน้น Python สำหรับสร้างแอปเอเจนต์เดี่ยวและหลายเอเจนต์ มีลูปเอเจนต์ในตัว ฟังก์ชันเครื่องมือ การส่งต่อ (handoff) ราวป้องกัน เซสชัน การอนุมัติโดยมนุษย์ และการทำเทรซ โดยไม่เพิ่มเลเยอร์นามธรรมมากเกินไป

ชอบใช้ OpenAI Agents SDK เพราะเรียบง่าย เชื่อมต่อเร็ว และเข้าใจง่าย ได้สร้างแอปหลายตัวด้วยมันโดยไม่มีปัญหาใหญ่ อีกทั้งยังสร้างเทรซอัตโนมัติที่ดูได้ใน OpenAI Dashboard ทำให้ตรวจสอบการตอบของโมเดล การเรียกเครื่องมือ การส่งต่อ และโฟลว์การทำงานทั้งหมดได้สะดวก

ตัวอย่างต่อไปนี้สร้างเอเจนต์ประวัติศาสตร์ที่สามารถเรียกฟังก์ชัน Python เพื่อดึงข้อเท็จจริงทางประวัติศาสตร์ที่น่าประหลาดใจ

# pip install openai-agents

import asyncio
from agents import Agent, Runner, function_tool


@function_tool
def history_fun_fact() -> str:
    """Return a surprising historical fact."""
    return "The first computer programmer, Ada Lovelace, lived in the 1800s."


agent = Agent(
    name="History Assistant",
    instructions=(
        "Answer history questions clearly and briefly. "
        "Use history_fun_fact when it is helpful."
    ),
    tools=[history_fun_fact],
)


async def main():
    result = await Runner.run(
        agent,
        "Tell me something surprising about the history of computing.",
    )
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

SDK จะรันเอเจนต์ เรียกใช้เครื่องมือประวัติศาสตร์เมื่อจำเป็น ส่งคืนผลลัพธ์ให้โมเดล และสร้างคำตอบสุดท้าย การรันทั้งหมดสามารถตรวจสอบได้ผ่านตัวดูเทรซ

7. Google Agent Development Kit

Agent Development Kit ของ Google หรือ ADK เป็นเฟรมเวิร์กโอเพนซอร์สสำหรับสร้าง ประเมิน และดีพลอยเอเจนต์เดี่ยว ผู้ช่วยที่ใช้เครื่องมือ เวิร์กโฟลว์แบบกราฟ และระบบหลายเอเจนต์ ทำงานได้ดีกับโมเดล Gemini เป็นพิเศษ พร้อมรองรับผู้ให้บริการโมเดลอื่นด้วย

ADK กลายเป็นหนึ่งในเฟรมเวิร์กที่ชื่นชอบเพราะเรียบง่ายและทำงานเข้ากับ Gemini ได้อย่างเป็นธรรมชาติ

ได้ใช้มันสร้างแอปหลายตัวโดยไม่มีปัญหาใหญ่ แม้ยังมองว่า OpenAI Agents SDK เชื่อมต่อง่ายกว่าและยืดหยุ่นกว่าทั้งด้านการควบคุมและฟีเจอร์ในตัว แต่ ADK ก็เป็นทางเลือกที่แข็งแรง โดยเฉพาะสำหรับแอปที่ใช้ Gemini

ตัวอย่างต่อไปนี้สร้างผู้ช่วยงานอีเวนต์ที่สามารถเรียกฟังก์ชัน Python เพื่อดึงเวลาเริ่มงาน

# pip install google-adk

from google.adk.agents.llm_agent import Agent


def get_event_time(city: str) -> dict:
    """Return the event starting time for a city."""
    return {
        "status": "success",
        "city": city,
        "time": "6:00 PM",
    }


root_agent = Agent(
    model="gemini-flash-latest",
    name="event_assistant",
    description="Provides information about events in different cities.",
    instruction=(
        "Answer event questions clearly. "
        "Use the get_event_time tool when the starting time is requested."
    ),
    tools=[get_event_time],
)

เอเจนต์จะใช้ฟังก์ชันเป็นเครื่องมือเมื่อใดก็ตามที่ต้องดึงเวลาเริ่มงานของเมืองที่ระบุ

8. Claude Agent SDK

Claude Agent SDK คือเฟรมเวิร์ก Python และ TypeScript ของ Anthropic สำหรับสร้างเอเจนต์อัตโนมัติโดยใช้ลูปเอเจนต์ เครื่องมือ และการจัดการบริบทแบบเดียวกับที่ขับเคลื่อน Claude Code เหมาะอย่างยิ่งสำหรับเอเจนต์ที่ต้องอ่านไฟล์ แก้ไขโค้ด รันคำสั่ง เชื่อมต่อกับเครื่องมือ MCP และทำงานยาว

Anthropic, OpenAI และ Google ผสานโมเดลของตนอย่างใกล้ชิดกับเฟรมเวิร์กเอเจนต์ของตนเอง ทำให้การตั้งค่าเครื่องมือ เซสชัน การทำเทรซ และฟีเจอร์ขั้นสูงอื่น ๆ ทำได้อย่างรวดเร็ว

อย่างไรก็ตาม Claude Agent SDK ถูกออกแบบมาสำหรับ Claude โดยเฉพาะ ไม่ได้เน้นรองรับโมเดลโอเพนซอร์สหรือโมเดลที่โฮสต์โลคัลทั่วไป สามารถเรียนรู้เพิ่มเติมได้จาก บทเรียน Claude Agent SDK

ตัวอย่างต่อไปนี้สร้างเอเจนต์เขียนโค้ดที่รีวิวไฟล์ Python ระบุบั๊ก และแก้ไขอัตโนมัติ

# pip install claude-agent-sdk

import asyncio
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ResultMessage,
    query,
)


async def main():
    async for message in query(
        prompt="Review app.py for errors that could cause crashes and fix them.",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Glob"],
            permission_mode="acceptEdits",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
                elif hasattr(block, "name"):
                    print(f"Tool used: {block.name}")

        elif isinstance(message, ResultMessage):
            print(f"Completed: {message.subtype}")


if __name__ == "__main__":
    asyncio.run(main())

SDK จะรันลูปเอเจนต์ ขณะที่ Claude อ่านไฟล์ เลือกเครื่องมือที่ต้องใช้ แก้ไขโค้ด และสตรีมความคืบหน้าจนงานเสร็จ

เฟรมเวิร์กออร์เคสเตรตหลายเอเจนต์

เฟรมเวิร์กหลายเอเจนต์จะประสานงานเอเจนต์เฉพาะทางหลายตัว โดยแต่ละเอเจนต์ได้รับมอบหมายบทบาท เป้าหมาย ชุดเครื่องมือ หรือช่วงงานในเวิร์กโฟลว์ที่ใหญ่กว่า 

9. CrewAI

CrewAI เป็นเฟรมเวิร์ก Python ยอดนิยมสำหรับสร้างทีมหลายเอเจนต์ นักพัฒนาสามารถสร้างเอเจนต์ที่มีบทบาท เป้าหมาย และงานต่างกัน จากนั้นรวมเป็นทีมที่ทำงานร่วมกันแบบอัตโนมัติ งานสามารถรันแบบลำดับ หรือผ่านกระบวนการลำดับชั้นที่มีผู้จัดการคอยประสานและมอบหมายงานให้เอเจนต์ที่เหมาะสมที่สุด

ตัวอย่าง Python ต่อไปนี้สร้าง นักวิจัยและนักเขียนที่ทำงานร่วมกันเพื่อผลิตรายงานสั้น ๆ

# pip install crewai
# Set OPENAI_API_KEY before running

from crewai import Agent, Crew, Process, Task

researcher = Agent(
    role="AI Researcher",
    goal="Find the key facts about {topic}",
    backstory="You research technical topics carefully.",
)

writer = Agent(
    role="Technical Writer",
    goal="Turn research into a clear summary",
    backstory="You explain complex topics simply.",
)

research_task = Task(
    description="Research {topic} and identify three key findings.",
    expected_output="Three concise findings.",
    agent=researcher,
)

writing_task = Task(
    description="Write a short summary using the research findings.",
    expected_output="A clear one-paragraph report.",
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

result = crew.kickoff(inputs={"topic": "agentic AI"})
print(result.raw)

นักวิจัยจะทำงานแรกให้เสร็จ และนักเขียนใช้เอาต์พุตนั้นเป็นบริบทในการสร้างรายงานสุดท้าย

10. MetaGPT

MetaGPT เป็นเฟรมเวิร์กหลายเอเจนต์ที่จำลองบริษัทซอฟต์แวร์ โดยใช้เอเจนต์เฉพาะทางเช่น โปรดักต์แมเนเจอร์ สถาปนิก โปรเจ็กต์แมเนเจอร์ และวิศวกร เอเจนต์เหล่านี้ทำตามขั้นตอนการปฏิบัติงานที่เป็นโครงสร้าง เพื่อแปลงความต้องการสั้น ๆ ให้เป็นแผน ออกแบบทางเทคนิค เอกสาร และโค้ดที่ใช้งานได้ 

ตัวอย่างต่อไปนี้สร้างทีมซอฟต์แวร์และขอให้สร้างตัวจัดการงานบนคอมมานด์ไลน์อย่างง่าย

# pip install metagpt
# Configure a supported LLM API before running

import asyncio

from metagpt.roles import (
    Architect,
    Engineer,
    ProductManager,
    ProjectManager,
)
from metagpt.team import Team


async def startup(idea: str):
    company = Team()

    company.hire([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(),
    ])

    company.invest(investment=3.0)
    company.run_project(idea=idea)

    await company.run(n_round=5)


if __name__ == "__main__":
    asyncio.run(
        startup("Build a simple command-line task manager")
    )

เอเจนต์จะแบ่งความต้องการตามบทบาทของตนและร่วมมือกันวางแผนและพัฒนาโปรเจ็กต์ซอฟต์แวร์ 

11. AgentScope

AgentScope เป็นเฟรมเวิร์ก Python สำหรับสร้างเอเจนต์และแอปหลายเอเจนต์ที่ควบคุมได้และตรวจสอบได้ มีเอเจนต์พร้อมใช้ เครื่องมือ หน่วยความจำ การกำหนดเส้นทางข้อความ สตรีมมิง การเรียกเครื่องมือแบบขนาน เวิร์กโฟลว์ การทำเทรซ และการแทรกแซงโดยมนุษย์ AgentScope Studio ยังใช้ตรวจสอบและแสดงภาพการทำงานของเอเจนต์ได้ด้วย

ตัวอย่างต่อไปนี้สร้างเอเจนต์ ReAct ที่สามารถเขียนและรันโค้ด Python เพื่อทำการคำนวณ

# pip install agentscope
# Set DASHSCOPE_API_KEY before running

import asyncio
import os

from agentscope.agent import ReActAgent
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.message import Msg
from agentscope.model import DashScopeChatModel
from agentscope.tool import Toolkit, execute_python_code


async def main():
    toolkit = Toolkit()
    toolkit.register_tool_function(execute_python_code)

    agent = ReActAgent(
        name="Nova",
        sys_prompt="You are a helpful Python assistant named Nova.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=True,
        ),
        formatter=DashScopeChatFormatter(),
        toolkit=toolkit,
        memory=InMemoryMemory(),
    )

    await agent(
        Msg(
            name="user",
            content="Use Python to calculate the sum of numbers from 1 to 100.",
            role="user",
        )
    )


if __name__ == "__main__":
    asyncio.run(main())

เอเจนต์จะตัดสินใจเรียกใช้เครื่องมือรัน Python สร้างโค้ด รัน และใช้ผลลัพธ์ในการตอบผู้ใช้

12. CAMEL-AI

CAMEL-AI เป็นเฟรมเวิร์ก Python แบบโอเพนซอร์สสำหรับสร้างเอเจนต์ สังคมหลายเอเจนต์ และการจำลองบทบาท เน้นงานวิจัยอย่างมาก และมีคอมโพเนนต์สำหรับการทำงานร่วมกันของเอเจนต์ เครื่องมือ หน่วยความจำ การดึงข้อมูล การสร้างข้อมูล และการจำลองโลก รองรับทั้งโมเดลบนคลาวด์และโมเดลที่โฮสต์ภายในผ่านแพลตฟอร์มอย่าง Ollama, vLLM และ SGLang

ตัวอย่างต่อไปนี้สร้างเอเจนต์ที่สามารถค้นเว็บก่อนตอบคำถาม

# pip install "camel-ai[web_tools]"
# Set OPENAI_API_KEY before running

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import SearchToolkit
from camel.types import ModelPlatformType, ModelType

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_5_5,
    model_config_dict={"temperature": 0.0},
)

agent = ChatAgent(
    system_message="You are a helpful AI research assistant.",
    model=model,
    tools=[SearchToolkit().search_duckduckgo],
)

response = agent.step(
    "What are the main uses of multi-agent AI systems?"
)

print(response.msgs[0].content)

เอเจนต์จะใช้การค้นหา DuckDuckGo เมื่อจำเป็นต้องใช้ข้อมูลล่าสุด แล้วจึงส่งคำตอบสุดท้าย

เฟรมเวิร์กข้อมูลและ RAG สำหรับเอเจนต์

เฟรมเวิร์กเหล่านี้ช่วยเชื่อม LLM และเอเจนต์เข้ากับเอกสาร ฐานข้อมูล API และแหล่งข้อมูลส่วนตัวอื่น ๆ เพื่อดึงบริบทที่เกี่ยวข้องมาก่อนตอบ

13. LlamaIndex

LlamaIndex เป็นเฟรมเวิร์ก Python สำหรับสร้างแอปที่รับรู้บริบทเหนือข้อมูลส่วนตัวหรือข้อมูลเฉพาะโดเมน มีคอนเน็กเตอร์ ดัชนี ตัวดึงข้อมูล เอนจินค้นหา เอเจนต์ และเวิร์กโฟลว์ สำหรับแอปอย่าง RAG การค้นหาฝั่งองค์กร และผู้ช่วยเอกสาร

LlamaIndex เคยเป็นเฟรมเวิร์กโปรดเมื่อตอนเริ่มสร้างแอป RAG เพราะทำให้โหลด ทำดัชนี และคิวรีข้อมูลได้ง่ายมาก และมักพบว่าโค้ดสั้นกว่าและง่ายกว่าการสร้างแอปเดียวกันด้วย LangChain สามารถ เรียนคอร์ส LlamaIndex เพื่อรู้จักมากขึ้น

ตัวอย่างต่อไปนี้โหลดเอกสารจากโฟลเดอร์ สร้างดัชนีค้นหาได้ และตอบคำถามด้วยบริบทที่ดึงมา

# pip install llama-index
# Set OPENAI_API_KEY before running

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query(
    "What are the main findings in these documents?"
)

print(response)

LlamaIndex จะทำดัชนีไฟล์ในโฟลเดอร์ data และดึงข้อมูลที่เกี่ยวข้องมาก่อนสร้างคำตอบ

14. Haystack

Haystack เป็นเฟรมเวิร์ก Python แบบโอเพนซอร์สสำหรับสร้างไปป์ไลน์ RAG ที่พร้อมโปรดักชัน ระบบค้นหาเชิงความหมาย เอเจนต์ และแอป AI ที่เน้นข้อมูล โครงสร้างไปป์ไลน์แบบโมดูลาร์มอบการควบคุมที่ชัดเจนว่าข้อมูลถูกดึงมาอย่างไร ใส่ลงในพรอมป์ตอย่างไร และส่งไปยังโมเดลอย่างไร

ได้ใช้ Haystack เพื่อสร้างแอป RAG และหลายเอเจนต์โดยไม่มีปัญหาใหญ่ แม้เป็นเฟรมเวิร์กเอนกประสงค์ แต่มีประโยชน์อย่างยิ่งสำหรับแอปที่เชื่อม LLM เข้ากับเอกสาร ข้อความ ระบบค้นหา และแหล่งข้อมูลอื่น

ตัวอย่างต่อไปนี้เก็บเอกสารไม่กี่ชิ้น ดึงเอกสารที่เกี่ยวข้องที่สุด และใช้เพื่อตอบคำถาม

# pip install -U haystack-ai
# Set OPENAI_API_KEY before running

from haystack import Document, Pipeline
from haystack.components.builders import ChatPromptBuilder
from haystack.components.generators.chat import (
    OpenAIResponsesChatGenerator,
)
from haystack.components.retrievers import InMemoryBM25Retriever
from haystack.dataclasses import ChatMessage
from haystack.document_stores.in_memory import InMemoryDocumentStore

document_store = InMemoryDocumentStore()
document_store.write_documents([
    Document(content="The London AI event starts at 6:00 PM."),
    Document(content="The Berlin AI event starts at 7:00 PM."),
])

template = [
    ChatMessage.from_system(
        "Answer using the following documents:\n"
        "{% for doc in documents %}{{ doc.content }}{% endfor %}"
    ),
    ChatMessage.from_user("{{ question }}"),
]

pipeline = Pipeline()
pipeline.add_component(
    "retriever",
    InMemoryBM25Retriever(document_store),
)
pipeline.add_component(
    "prompt_builder",
    ChatPromptBuilder(template=template),
)
pipeline.add_component(
    "llm",
    OpenAIResponsesChatGenerator(model="gpt-5.5"),
)

pipeline.connect("retriever", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

question = "When does the London AI event start?"

result = pipeline.run({
    "retriever": {"query": question},
    "prompt_builder": {"question": question},
})

print(result["llm"]["replies"][0].text)

Haystack จะดึงเอกสารที่ตรง เพิ่มเข้าไปในพรอมป์ต และใช้ GPT-5.5 เพื่อสร้างคำตอบที่ยึดกับข้อมูล

เฟรมเวิร์กแบบน้ำหนักเบาและโมเดลเปิด

เฟรมเวิร์กเหล่านี้ให้เลเยอร์นามธรรมที่เรียบง่ายสำหรับสร้างเอเจนต์ด้วยโมเดลเปิดที่โฮสต์หรือรันบนเครื่อง

15. Hugging Face smolagents

Hugging Face smolagents เป็นเฟรมเวิร์ก Python แบบน้ำหนักเบาสำหรับสร้างเอเจนต์ด้วยโค้ดเพียงเล็กน้อย CodeAgent ทำงานโดยการเขียน Python ขณะที่ ToolCallingAgent ใช้การเรียกเครื่องมือแบบมีโครงสร้าง ทำงานได้ดีเป็นพิเศษกับโมเดลของ Hugging Face, Inference Providers และโมเดลโอเพนซอร์สที่โฮสต์ภายใน

ตัวอย่างต่อไปนี้สร้างเอเจนต์ค้นเว็บและส่งให้เอเจนต์ผู้จัดการตัดสินใจว่าจะมอบหมายงานค้นคว้าเมื่อใด

# pip install -U "smolagents[toolkit]"
# Set HF_TOKEN before running

from smolagents import (
    CodeAgent,
    InferenceClientModel,
    ToolCallingAgent,
    WebSearchTool,
)

model = InferenceClientModel(
    model_id="Qwen/Qwen3-Next-80B-A3B-Thinking"
)

web_agent = ToolCallingAgent(
    tools=[WebSearchTool()],
    model=model,
    name="web_search_agent",
    description="Searches the web and returns useful information.",
)

manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[web_agent],
)

result = manager_agent.run(
    "Who created Hugging Face, and when was it founded?"
)

print(result)

ผู้จัดการจะตัดสินใจเมื่อใดที่ต้องใช้ข้อมูลล่าสุด มอบหมายการค้นหาให้เอเจนต์เว็บผู้เชี่ยวชาญ แล้วจึงสร้างคำตอบสุดท้าย

ตารางเปรียบเทียบเฟรมเวิร์กโดยย่อ

ตารางด้านล่างเปรียบเทียบจุดแข็งหลักของแต่ละเฟรมเวิร์กและประเภทแอป Agentic AI ที่เหมาะสมที่สุด

ข้อคิดส่งท้าย

หากเพิ่งเริ่มต้นกับ Agentic AI แนะนำให้เริ่มจาก SDK ทางการอย่าง OpenAI Agents SDK Google ADK หรือ Claude Agent SDK เพราะทำงานกับโมเดลและ API ของตนเองอย่างใกล้ชิด การตั้งค่าจึงมักเรียบง่าย เพิ่มคีย์ API เติมเครดิต แล้วเริ่มสร้างได้เลย

ชอบ SDK เหล่านี้เพราะทำให้สร้างเอเจนต์ เชื่อมเครื่องมือ และตรวจสอบสิ่งที่เกิดขึ้นระหว่างการรันได้ง่าย ด้วย Python เพียงไม่กี่บรรทัด ก็สร้างเอเจนต์ที่มีประโยชน์หรือแม้แต่ระบบหลายเอเจนต์ขนาดเล็กได้

เมื่อจำเป็นต้องยืดหยุ่นมากขึ้น มักจะดูที่ LangChain หรือ LangGraph LangChain มีประโยชน์เมื่อจำเป็นต้องเชื่อมต่อจำนวนมาก ขณะที่ LangGraph ให้ การควบคุมสถานะ ลูป และเวิร์กโฟลว์ที่ยาวขึ้นได้มากกว่า

สำหรับทีมเอเจนต์ที่มีบทบาทต่างกัน CrewAI เป็นตัวเลือกที่ดี สำหรับ RAG เอกสารส่วนตัว และแอปที่เชื่อมต่อข้อมูล เลือก LlamaIndex หรือ Haystack

ท้ายที่สุด smolagents เหมาะเมื่ออยากได้สิ่งที่น้ำหนักเบา เรียบง่าย และใช้งานกับโมเดลเปิดหรือโมเดลโลคัลได้สะดวก

คำแนะนำคือเริ่มจากเฟรมเวิร์กที่ง่ายที่สุดซึ่งเหมาะกับโปรเจ็กต์ สร้างเวอร์ชันเล็ก ทดสอบอย่างเหมาะสม และค่อยเพิ่มความซับซ้อนเมื่อจำเป็นจริง ๆ