Top 15 framework Python để xây dựng ứng dụng AI tác tử hoàn chỉnh

Việc xây dựng các ứng dụng AI tác tử hiện nay đã dễ dàng hơn nhiều so với vài năm trước. Thay vì phải tự tạo vòng lặp tác tử, tích hợp công cụ, bộ nhớ, truy xuất và điều phối từ đầu, nhà phát triển có thể dùng các framework Python đã cung cấp sẵn hầu hết các thành phần này.

Tôi đã sử dụng nhiều framework trong bài viết này để xây dựng ứng dụng RAG, tác tử tự động, hệ thống đa tác tử và các công cụ AI có thể triển khai.

Tôi thường dùng LangChain cho quy trình tác tử linh hoạt, LlamaIndex và Haystack cho các ứng dụng kết nối dữ liệu, và OpenAI Agents SDK hoặc Google ADK khi muốn tích hợp nhanh với các mô hình của nhà cung cấp.

Một số framework đã cải thiện đến mức việc xây dựng giải pháp tuỳ chỉnh thường không còn cần thiết. Chỉ với một khóa API, một ít tín dụng mô hình và framework phù hợp, bạn có thể tạo một tác tử, kết nối nó với công cụ hoặc dữ liệu riêng tư, kiểm thử và triển khai qua API hoặc giao diện người dùng.

Bài viết này so sánh 15 framework Python trong năm nhóm: framework tác tử đa dụng, SDK tác tử chính thức, framework điều phối đa tác tử, framework dữ liệu và RAG, và framework gọn nhẹ dành cho mô hình mở.

Mỗi phần cũng có một ví dụ Python ngắn để bạn có thể sao chép, dán và thử nghiệm nhằm nhanh chóng hiểu cách framework hoạt động.

Framework tác tử đa dụng

Các framework này cung cấp các khối xây dựng toàn diện để tạo tác tử, kết nối công cụ, quản lý trạng thái và kiểm soát quy trình nhiều bước.

1. LangChain

Với nhiều nhà phát triển, phát triển ứng dụng LLM hiện đại bắt đầu với LangChain, một framework Python mã nguồn mở được thiết kế để kết nối mô hình ngôn ngữ với dữ liệu, công cụ, API và logic ứng dụng bên ngoài. Đây là một trong những framework đầu tiên được áp dụng rộng rãi để dùng OpenAI API với website, tài liệu, cơ sở dữ liệu vector và các nguồn dữ liệu khác nhằm xây dựng ứng dụng có nhận thức ngữ cảnh tốt hơn.

Hiện nay, LangChain đã phát triển thành một hệ sinh thái hoàn chỉnh để xây dựng ứng dụng AI tác tử đầu-cuối, bao gồm hệ thống RAG, tác tử biết dùng công cụ, workflow, tích hợp, giám sát và đánh giá. Tôi khuyên bạn nên xem lộ trình AI Engineering với LangChain để tìm hiểu thêm.

Ví dụ sau tạo một tác tử LangChain đơn giản có thể dùng công cụ tìm kiếm tài liệu để tìm thông tin liên quan trước khi trả lời câu hỏi.

# 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

Trong khi LangChain giúp việc tạo tác tử và công cụ trở nên dễ dàng, LangGraph cung cấp nhiều kiểm soát hơn đối với cách các tác tử đó vận hành. Nó cho phép nhà phát triển cấu trúc ứng dụng như một đồ thị các bước được kết nối, giúp dễ dàng kiểm soát vòng lặp, lời gọi công cụ, trạng thái chia sẻ, phê duyệt của con người và quy trình đa tác tử.

Tôi thấy nó đặc biệt hữu ích khi xây dựng các tác tử tự động phải liên tục quyết định cần làm gì, chọn đúng công cụ, kiểm tra kết quả và tiếp tục cho đến khi hoàn thành nhiệm vụ. LangGraph cũng hỗ trợ lưu bền, streaming, checkpoint và khôi phục cho các ứng dụng chạy lâu hơn. Hướng dẫn LangGraph của chúng tôi cung cấp thêm chi tiết.

Ví dụ sau tạo một tác tử có thể lặp lại việc gọi các công cụ máy tính cho đến khi có đủ thông tin để trả lời:

# 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)

Đồ thị gửi yêu cầu đến mô hình, chạy các công cụ cần thiết và lặp lại về mô hình cho đến khi tạo ra câu trả lời cuối cùng.

3. Agno

Agno là một framework Python để xây dựng tác tử, đội nhóm đa tác tử và các workflow có cấu trúc. Nó cũng bao gồm AgentOS, giúp nhà phát triển mở tác tử qua API, lưu trữ phiên và vết chạy, và quản lý chúng như các ứng dụng sản xuất. Vì có thể chạy trên hạ tầng riêng, tổ chức giữ được mức kiểm soát cao hơn đối với dữ liệu và bảo mật.

Ví dụ sau tạo một tác tử nghiên cứu có thể tìm kiếm web trước khi đưa ra phản hồi súc tích.

# 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,
)

Tác tử dùng công cụ tìm kiếm để lấy thông tin hiện tại và stream một bản tóm tắt ngắn cho người dùng.

4. Pydantic AI

Pydantic AI là một framework Python-native từ đội ngũ phía sau Pydantic để xây dựng tác tử và ứng dụng AI sinh sinh. Cảm giác sử dụng tương tự như làm việc với các model Pydantic hoặc FastAPI vì tác tử, công cụ, phụ thuộc và đầu ra được định nghĩa bằng hàm Python chuẩn, type hint, decorator và lớp BaseModel. Sau đó, nó dùng xác thực Pydantic để giữ cho tham số công cụ và đầu ra mô hình có cấu trúc và đáng tin cậy.

Tôi có thể gợi ý hướng dẫn Pydantic AI để tìm hiểu thêm về framework này.

Ví dụ sau tạo một tác tử trả về kế hoạch bài viết đã được xác thực dưới dạng model 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)

Tác tử tạo một đối tượng ArticlePlan và xác thực rằng mọi trường khớp với kiểu và quy tắc Python yêu cầu trước khi trả về.

SDK tác tử chính thức

SDK tác tử chính thức được duy trì bởi các nhà cung cấp AI và thường mang lại khả năng tích hợp đơn giản nhất với mô hình, API, công cụ, hệ thống triển khai và nền tảng quan sát của họ.

5. OpenAI Agents SDK

OpenAI Agents SDK là một framework gọn nhẹ, ưu tiên Python để xây dựng ứng dụng tác tử đơn lẻ và đa tác tử. Nó cung cấp vòng lặp tác tử tích hợp, công cụ hàm, chuyển giao, rào chắn, phiên làm việc, phê duyệt của con người và tracing mà không thêm quá nhiều tầng trừu tượng.

Tôi rất thích dùng OpenAI Agents SDK vì đơn giản, tích hợp nhanh và dễ hiểu. Tôi đã xây dựng nhiều ứng dụng với nó mà không gặp vấn đề lớn. Nó cũng tự động tạo trace có thể xem trong OpenAI Dashboard, giúp dễ dàng kiểm tra phản hồi của mô hình, lời gọi công cụ, chuyển giao và toàn bộ luồng thực thi.

Ví dụ sau tạo một tác tử lịch sử có thể gọi hàm Python để truy xuất một sự thật lịch sử bất ngờ.

# 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 chạy tác tử, gọi công cụ lịch sử khi cần, trả kết quả về cho mô hình và tạo phản hồi cuối cùng. Toàn bộ lần chạy cũng có thể được kiểm tra qua trình xem trace.

7. Google Agent Development Kit

Agent Development Kit của Google, hay ADK, là một framework mã nguồn mở để xây dựng, đánh giá và triển khai các tác tử riêng lẻ, trợ lý biết dùng công cụ, workflow dạng đồ thị và hệ thống đa tác tử. Nó hoạt động đặc biệt tốt với các mô hình Gemini, đồng thời hỗ trợ các nhà cung cấp mô hình khác.

ADK đã trở thành một trong những framework tôi ưa thích vì đơn giản và làm việc tự nhiên với Gemini.

Tôi đã dùng nó để xây dựng một số ứng dụng mà không gặp vấn đề lớn. Dù tôi vẫn thấy OpenAI Agents SDK dễ tích hợp hơn và linh hoạt hơn về kiểm soát và tính năng tích hợp sẵn, ADK là lựa chọn mạnh mẽ và đặc biệt cạnh tranh cho các ứng dụng dựa trên Gemini.

Ví dụ sau tạo một trợ lý sự kiện có thể gọi hàm Python để truy xuất giờ bắt đầu của một sự kiện.

# 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],
)

Tác tử dùng hàm như một công cụ bất cứ khi nào cần truy xuất giờ sự kiện cho một thành phố cụ thể.

8. Claude Agent SDK

Claude Agent SDK là framework Python và TypeScript của Anthropic để xây dựng tác tử tự động, sử dụng cùng vòng lặp tác tử, công cụ và quản lý ngữ cảnh làm nền tảng cho Claude Code. Nó đặc biệt hữu ích cho các tác tử cần đọc tệp, chỉnh sửa mã, chạy lệnh, kết nối với công cụ MCP và hoàn thành tác vụ dài.

Anthropic, OpenAI và Google tích hợp chặt chẽ các mô hình với framework tác tử riêng, khiến công cụ, phiên, tracing và các tính năng nâng cao khác trở nên nhanh chóng để thiết lập.

Tuy nhiên, Claude Agent SDK được thiết kế riêng cho Claude hơn là các mô hình mã nguồn mở hoặc chạy cục bộ bất kỳ. Bạn có thể tìm hiểu thêm trong hướng dẫn Claude Agent SDK của chúng tôi.

Ví dụ sau tạo một tác tử lập trình để rà soát tệp Python, xác định lỗi và tự động sửa chúng.

# 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 chạy vòng lặp tác tử trong khi Claude đọc tệp, chọn công cụ cần thiết, chỉnh sửa mã và stream tiến trình cho đến khi hoàn tất nhiệm vụ.

Framework điều phối đa tác tử

Framework đa tác tử điều phối nhiều tác tử chuyên biệt, mỗi tác tử đảm nhận một vai trò, mục tiêu, bộ công cụ hoặc giai đoạn nhất định trong một workflow lớn hơn. 

9. CrewAI

CrewAI là framework Python phổ biến để xây dựng đội nhóm đa tác tử. Nhà phát triển có thể tạo tác tử với các vai trò, mục tiêu và nhiệm vụ khác nhau, rồi kết hợp chúng thành một “crew” làm việc tự động cùng nhau. Nhiệm vụ có thể chạy tuần tự hoặc theo quy trình phân cấp, trong đó một quản lý điều phối và phân công công việc cho tác tử phù hợp nhất.

Ví dụ Python sau tạo một nhà nghiên cứu và một người viết hợp tác để tạo một báo cáo ngắn.

# 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)

Nhà nghiên cứu hoàn thành nhiệm vụ đầu tiên, và người viết dùng đầu ra đó làm ngữ cảnh để tạo báo cáo cuối cùng.

10. MetaGPT

MetaGPT là framework đa tác tử mô phỏng một công ty phần mềm với các tác tử chuyên môn như quản lý sản phẩm, kiến trúc sư, quản lý dự án và kỹ sư. Các tác tử này tuân theo quy trình vận hành có cấu trúc để biến yêu cầu ngắn thành kế hoạch, thiết kế kỹ thuật, tài liệu và mã chạy được. 

Ví dụ sau tạo một đội phần mềm và yêu cầu đội xây dựng một trình quản lý tác vụ dòng lệnh đơn giản.

# 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")
    )

Các tác tử phân chia yêu cầu theo vai trò khác nhau và cộng tác để lập kế hoạch và phát triển dự án phần mềm. 

11. AgentScope

AgentScope là framework Python để xây dựng các tác tử có khả năng kiểm soát và quan sát, cũng như ứng dụng đa tác tử. Nó cung cấp sẵn tác tử, công cụ, bộ nhớ, định tuyến thông điệp, streaming, gọi công cụ song song, workflow, tracing và can thiệp của con người. AgentScope Studio cũng có thể dùng để kiểm tra và trực quan hóa quá trình thực thi của tác tử.

Ví dụ sau tạo một tác tử ReAct có thể viết và thực thi mã Python để hoàn thành phép tính.

# 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())

Tác tử quyết định gọi công cụ thực thi Python, chạy đoạn mã sinh ra và dùng kết quả để trả lời người dùng.

12. CAMEL-AI

CAMEL-AI là framework Python mã nguồn mở để xây dựng tác tử, xã hội đa tác tử và mô phỏng đóng vai. Nó có định hướng nghiên cứu mạnh và cung cấp các thành phần cho hợp tác giữa tác tử, công cụ, bộ nhớ, truy xuất, sinh dữ liệu và mô phỏng thế giới. Nó cũng hỗ trợ mô hình đám mây và mô hình chạy cục bộ thông qua các nền tảng như Ollama, vLLM và SGLang.

Ví dụ sau tạo một tác tử có thể tìm kiếm web trước khi trả lời câu hỏi.

# 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)

Tác tử dùng tìm kiếm DuckDuckGo khi cần thông tin hiện tại rồi trả về câu trả lời cuối cùng.

Framework dữ liệu và RAG cho tác tử

Các framework này giúp kết nối LLM và tác tử với tài liệu, cơ sở dữ liệu, API và các nguồn dữ liệu riêng tư khác để chúng có thể truy xuất ngữ cảnh liên quan trước khi phản hồi.

13. LlamaIndex

LlamaIndex là framework Python để xây dựng ứng dụng nhận thức ngữ cảnh trên dữ liệu riêng tư hoặc theo miền. Nó cung cấp connector, index, retriever, query engine, tác tử và workflow cho các ứng dụng như RAG, tìm kiếm doanh nghiệp và trợ lý tài liệu.

LlamaIndex từng là một trong những framework tôi yêu thích khi bắt đầu xây dựng ứng dụng RAG. Nó giúp việc tải, lập chỉ mục và truy vấn dữ liệu cực kỳ dễ dàng, và tôi thường thấy mã của nó đơn giản và ngắn gọn hơn so với khi xây dựng cùng ứng dụng bằng LangChain. Bạn có thể tham gia khóa học LlamaIndex để tìm hiểu thêm.

Ví dụ sau tải tài liệu từ một thư mục, tạo chỉ mục có thể tìm kiếm và trả lời một câu hỏi bằng ngữ cảnh đã truy xuất.

# 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 lập chỉ mục các tệp trong thư mục data và truy xuất thông tin liên quan trước khi tạo câu trả lời.

14. Haystack

Haystack là framework Python mã nguồn mở để xây dựng pipeline RAG sẵn sàng sản xuất, hệ thống tìm kiếm ngữ nghĩa, tác tử và các ứng dụng AI tập trung vào dữ liệu. Cấu trúc pipeline dạng mô-đun của nó cung cấp khả năng kiểm soát rõ ràng cách thông tin được truy xuất, thêm vào prompt và gửi đến mô hình.

Tôi đã dùng Haystack để xây dựng ứng dụng RAG và đa tác tử mà không gặp vấn đề lớn. Dù là một framework đa dụng, nó đặc biệt hữu ích cho các ứng dụng kết nối LLM với tài liệu, văn bản, hệ thống tìm kiếm và các nguồn dữ liệu khác.

Ví dụ sau lưu trữ vài tài liệu, truy xuất tài liệu liên quan nhất và dùng nó để trả lời câu hỏi.

# 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 truy xuất tài liệu khớp, thêm vào prompt và dùng GPT-5.5 để tạo câu trả lời có căn cứ.

Framework gọn nhẹ và dành cho mô hình mở

Các framework này cung cấp tầng trừu tượng đơn giản hơn để xây dựng tác tử với mô hình mở được lưu trữ hoặc chạy cục bộ.

15. Hugging Face smolagents

Hugging Face smolagents là framework Python gọn nhẹ để xây dựng tác tử chỉ với một lượng mã nhỏ. CodeAgent thực hiện hành động bằng cách viết Python, trong khi ToolCallingAgent dùng lời gọi công cụ có cấu trúc. Nó hoạt động đặc biệt tốt với các mô hình Hugging Face, Inference Providers và các mô hình mã nguồn mở chạy cục bộ.

Ví dụ sau tạo một tác tử tìm kiếm web và giao nó cho một tác tử quản lý quyết định khi nào cần ủy thác nghiên cứu.

# 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)

Tác tử quản lý quyết định khi nào cần thông tin hiện tại, ủy thác việc tìm kiếm cho tác tử web chuyên trách rồi tạo câu trả lời cuối cùng.

So sánh nhanh các framework

Bảng dưới đây so sánh thế mạnh chính của mỗi framework và loại ứng dụng AI tác tử mà nó phù hợp nhất.

Lời kết

Nếu bạn mới bắt đầu với AI tác tử, tôi sẽ khởi đầu với một SDK chính thức như OpenAI Agents SDK, Google ADK hoặc Claude Agent SDK. Chúng hoạt động sát với mô hình và API của riêng mình nên việc thiết lập thường đơn giản. Bạn thêm khóa API, nạp một ít tín dụng và bắt đầu xây dựng.

Tôi thích các SDK này vì chúng giúp dễ dàng tạo tác tử, kết nối công cụ và kiểm tra những gì đã xảy ra trong một lần chạy. Chỉ với vài dòng Python, bạn có thể xây dựng một tác tử hữu ích hoặc thậm chí một hệ thống đa tác tử nhỏ.

Khi cần linh hoạt hơn, tôi thường xem xét LangChain hoặc LangGraph. LangChain hữu ích khi tôi cần nhiều tích hợp, trong khi LangGraph cho tôi nhiều kiểm soát hơn đối với trạng thái, vòng lặp và workflow dài.

Với các đội tác tử có vai trò khác nhau, CrewAI là một lựa chọn tốt. Với RAG, tài liệu riêng tư và ứng dụng kết nối dữ liệu, tôi sẽ chọn LlamaIndex hoặc Haystack.

Cuối cùng, smolagents là lựa chọn tốt khi tôi muốn thứ gì đó gọn nhẹ, đơn giản và dễ dùng với mô hình mở hoặc cục bộ.

Lời khuyên của tôi là hãy bắt đầu với framework đơn giản nhất phù hợp với dự án của bạn. Xây dựng một phiên bản nhỏ, kiểm thử kỹ, và chỉ thêm độ phức tạp khi bạn thực sự cần.