用于构建完整代理型 AI 应用的 15 大 Python 框架

如今，构建代理型 AI 应用比几年前容易得多。开发者无需从零开始实现代理循环、工具集成、记忆、检索和编排，而是可以直接使用已提供上述大多数组件的 Python 框架。

我使用过本文中的许多框架来构建 RAG 应用、自主代理、多代理系统以及可部署的 AI 工具。

我常用 LangChain 来实现灵活的代理工作流，用 LlamaIndex 和 Haystack 构建数据连接型应用；当需要更快速地集成到提供商模型时，我会选择 OpenAI Agents SDK 或 Google ADK。

部分框架的成熟度已经很高，以至于往往不必再自研定制方案。只需一个 API 密钥、一些模型额度，再配上合适的框架，您就能创建一个代理，将其连接到工具或私有数据，完成测试，并通过 API 或用户界面部署。

本文从五个类别对 15 个 Python 框架进行比较：通用代理框架、官方代理 SDK、多代理编排框架、数据与 RAG 框架，以及轻量级开放模型框架。

每个部分还包含一个简短的 Python 示例，您可以复制、粘贴并运行，以快速理解该框架的工作方式。

通用代理框架

这些框架提供创建代理、连接工具、管理状态以及控制多步工作流的通用构件。

1. LangChain

对许多开发者而言，现代 LLM 应用开发始于 LangChain。这是一款开源 Python 框架，旨在将语言模型与外部数据、工具、API 和应用逻辑连接起来。它成为最早被广泛采用的框架之一，可将 OpenAI API 与网站、文档、向量数据库及其他数据源结合，用于构建具备更强上下文感知能力的应用。

如今，LangChain 已发展为一个完整生态，支持端到端的代理型 AI 应用构建，包括 RAG 系统、会用工具的代理、工作流、集成、监控与评估。建议查看LangChain AI 工程学习路径了解更多。

以下示例创建了一个简单的 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 来自 Pydantic 团队，是一个用于构建代理与生成式 AI 应用的原生 Python 框架。它的体验与使用 Pydantic 模型或 FastAPI 相似：代理、工具、依赖与输出均通过标准的 Python 函数、类型注解、装饰器和 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 为先的框架，用于构建单代理与多代理应用。它内置代理循环、函数工具、交接、护栏、会话、人工审批与追踪，同时不过度抽象。

我很喜欢使用 OpenAI Agents SDK，因为它简单、集成快速且易于理解。我用它构建过许多应用，基本没有遇到重大问题。它还会自动创建可在 OpenAI 控制台中查看的追踪记录，便于检查模型响应、工具调用、交接以及完整执行流。

以下示例创建了一个历史助手代理，它可调用 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

Google 的 Agent Development Kit（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 是 Anthropic 的 Python 与 TypeScript 框架，用于基于与 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、企业搜索与文档助手等应用。

我在刚开始构建 RAG 应用时非常喜欢 LlamaIndex。它让数据加载、索引与查询变得异常简单，而且我常常发现，使用它编写的代码比用 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 模型、推理提供商以及本地托管的开源模型协作良好。

以下示例创建了一个网页搜索代理，并将其交给一个管理者代理，由后者决定何时委派研究任务。

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

管理者会在需要最新信息时作出判断，将搜索任务委派给专门的网页代理，然后生成最终答案。

框架速览对比

下表比较了各框架的主要优势及其最适合的代理型 AI 应用类型。

结语

如果您刚开始接触代理型 AI，我建议从OpenAI Agents SDK、Google ADK 或 Claude Agent SDK 等官方 SDK 入手。它们与自家模型和 API 紧密配合，通常配置简单。添加一个 API 密钥、充值一些额度，就可以上手构建了。

我喜欢这些 SDK，因为它们便于创建代理、连接工具，并检查一次运行过程中发生的事情。只需几行 Python 代码，您就能构建一个实用代理，甚至是一个小型多代理系统。

当我需要更多灵活性时，通常会考虑 LangChain 或 LangGraph。需要大量集成时选 LangChain，而 LangGraph 则能在状态、循环与更长工作流上提供更多控制。

对于具有不同角色的代理团队，CrewAI 是不错的选择。若涉及 RAG、私有文档与数据连接型应用，我会优先选择 LlamaIndex 或 Haystack。

最后，smolagents 在我想要轻量、简单并易于与开放或本地模型配合时是个好选择。

我的建议是，从最简单且契合项目需求的框架开始。先搭建一个小版本，充分测试，只有在确有需要时再引入更多复杂度。