最近笔者在找智能体框架，看到一个文章：https://ai.plainenglish.io/11-best-ai-Agent-frameworks-for-software-developers-afa1700644bc，在此翻译翻译给大家。

人工智能 Agent（智能体）彻底改变了软件开发者构建智能应用的方式。这些 AI Agent 框架提供了所需的基础设施、工具集和方法论，用以创建能够以最少的人工干预进行推理、规划并执行复杂任务的自主系统。

进入 2025 年，AI Agent 已从简单的聊天机器人演变为能进行多步推理、工具使用和协同解决问题的复杂系统。对于希望利用这项技术的开发者来说，选择合适的框架对于项目成功至关重要。

本指南将深入探讨当前最优秀的 11 个 AI Agent 框架，比较它们的特性、优势、劣势以及理想的应用场景，帮助您为下一个项目做出明智的决定。

什么是 AI Agent 框架？

AI Agent 框架是软件平台，使开发者能够构建具备以下能力的自主人工智能系统：

这些框架通常利用大型语言模型（LLM）作为其认知引擎，并结合专门的组件来处理记忆、工具使用、规划和执行。

11 个最佳 AI Agent 框架

1. LangChain

LangChain 是一个开源框架，已成为构建 AI 驱动应用最受欢迎的选择之一。它将语言模型与各种工具、API 和外部数据源连接起来，以创建强大的 AI Agent。LangChain 最受欢迎的特点在于它能够无缝地将多个大型语言模型（LLM）调用串联起来，并将其与外部数据源、工具和API 集成。这种模块化、可组合的方法使得开发者能够比直接使用原始 LLM API 更灵活、更轻松地构建复杂的、多步骤的 AI 应用，例如聊天机器人、Agent 和检索增强生成（RAG）系统。### 主要特性：

优势：

劣势：

应用场景：

代码示例：

from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain.tools.ddg_search import DuckDuckGoSearchRun
from langchain_openai import ChatOpenAI

# 定义 Agent 可以使用的工具
search_tool = DuckDuckGoSearchRun()
tools = [
    Tool(name="Search",
        func=search_tool.run,
        description="Useful for searching the internet for current information"
    )
]

# 初始化语言模型
llm = ChatOpenAI(model="gpt-4")

# 使用 React 框架创建 Agent
agent = create_react_agent(llm, tools, "You are a helpful AI assistant.")

# 创建 Agent 执行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 运行 Agent
response = agent_executor.invoke({"input": "What are the latest developments in AI agent frameworks?"})
print(response["output"])

                                                       2. AutoGen (微软)

AutoGen 是微软研究院开发的一个开源编程框架，专为构建和管理具有高级协作能力的 AI Agent 而设计。

AutoGen 基于 Actor 的架构和对 Agent 协作的专注经常被认为是具有变革性的，它在业务流程自动化、金融、医疗健康等领域实现了新型 AI 驱动解决方案。这种对专业化、可对话和可定制 Agent 的编排，被广泛认为是 AutoGen 最受用户赞赏的特性，因为它使得构建复杂、可扩展且可靠的 AI 应用变得更加容易。

主要特性：

优势：

劣势：

应用场景：

代码示例：

import autogen

# 定义LLM 配置
llm_config = {
    "config_list": [{"model": "gpt-4", "api_key": "your-api-key"}]
}

# 创建一个 AssistantAgent
assistant = autogen.AssistantAgent(
    name="assistant",
    llm_config=llm_config,
    system_message="You are a helpful AI assistant."
)

# 创建一个 UserProxyAgent
user_proxy =autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="TERMINATE",  # 任务完成后自动回复 TERMINATE
    max_consecutive_auto_reply=10,is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
    code_execution_config={"work_dir": "coding"}
)

# 在 Agent 之间发起对话
user_proxy.initiate_chat(
    assistant,
    message="Write a Python function to calculate the Fibonacci sequence."
)

3. CrewAI

CrewAI 是一个用 Python 构建的开源多 Agent 编排框架，旨在构建像真实团队一样协同工作的协作式 AI Agent 系统。

主要特性

优势

劣势

应用场景

代码示例

from crewai import Agent, Task, Crew
from langchain_openai import ChatOpenAI

# 初始化语言模型
llm = ChatOpenAI(model="gpt-4")

# 定义具有特定角色的 Agent
researcher = Agent(
    role="Research Analyst",
    goal="Discover and analyze the latest trends inAI technology",
    backstory="You are an expert in AI research with a keen eye for emerging trends",
    verbose=True,
    llm=llm
)

writer = Agent(
    role="TechnicalWriter",
    goal="Create comprehensive reports based on research findings",
    backstory="You are a skilled technical writer who can explain complex concepts clearly",
    verbose=True,
    llm=llm
)# 为每个 Agent 定义任务
research_task = Task(
    description="Research the latest developments in AI agent frameworks",
    expected_output="A comprehensive analysis of current AI agent frameworks",
    agent=researcher
)writing_task = Task(
    description="Write a detailed report on AI agent frameworks based on the research",
    expected_output="A well-structured report on AI agent frameworks",
    agent=writer,
    context=[research_task]  # 写作任务依赖于研究任务
)

# 创建一个包含 Agent 和任务的 Crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True
)

# 执行 Crew 的任务
result = crew.kickoff()
print(result)

4. Semantic Kernel (微软)

微软的 Semantic Kernel 允许用户使用 C#、Python 或 Java 构建 AI Agent 并集成最新的 AI 模型。

Semantic Kernel 是一个开源开发工具包，用于构建支持多种编程语言并能够集成 AI 模型和服务的 AI Agent。

主要特性

优势：

劣势：

应用场景：

代码示例：

import semantic_kernel assk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

# 初始化内核
kernel = sk.Kernel()

# 添加 OpenAI 服务
api_key = "your-api-key"
model= "gpt-4"
kernel.add_chat_service("chat_completion", OpenAIChatCompletion(model, api_key))

# 使用自然语言创建语义函数
prompt = """
Generate a creative story about {{$input}}.
The story should be engaging and approximately 100 words.
"""

# 在内核中注册函数
story_function = kernel.create_semantic_function(prompt, max_tokens=500)# 执行函数
result = story_function("a robot learning to paint")
print(result)

# 使用 Semantic Kernel 创建简单 Agent
from semantic_kernel.planning import ActionPlanner

# 定义规划器
planner = ActionPlanner(kernel)

# 执行计划
# 注意：aiohttp 版本冲突可能导致此处需要异步运行，示例代码展示了同步方式，实际应用可能需调整
# plan = await planner.create_plan("Write a poem aboutartificial intelligence")
# result = await plan.invoke()
# print(result)

# 为了示例的同步执行，这里省略了实际的 planner 运行，仅展示创建语义函数的部分。
# 如果需要运行 planner，需配置异步环境。

5. LangGraph

LangGraph 是 LangChain 创建的一个开源 AI Agent 框架，用于构建和管理复杂的生成式 AI 工作流。

主要特性：

优势：

劣势：

-复杂度较高，可能需要高级开发者技能

应用场景：

代码示例：

from typing import TypedDict, Annotated, Sequence
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.messagesimport HumanMessage, AIMessage

# 定义状态结构
class AgentState(TypedDict):
    messages: Annotated[Sequence[HumanMessage | AIMessage], "The messages in the conversation"]
    next_step: Annotated[str, "The next step to take"]

# 初始化语言模型
llm = ChatOpenAI(model="gpt-4")

# 定义节点（工作流中的步骤）
def research(state: AgentState) -> AgentState:messages = state["messages"]
    response = llm.invoke(messages + [HumanMessage(content="Research this topic thoroughly.")])
    return {"messages": state["messages"] + [response], "next_step": "analyze"}

def analyze(state: AgentState) -> AgentState:
    messages = state["messages"]
    response = llm.invoke(messages + [HumanMessage(content="Analyze the research findings.")])return {"messages": state["messages"] + [response], "next_step": "conclude"}

def conclude(state: AgentState) -> AgentState:
    messages = state["messages"]
    response =llm.invoke(messages + [HumanMessage(content="Provide a conclusion based on the analysis.")])
    return {"messages": state["messages"] + [response], "next_step": "end"}

# 创建图workflow = StateGraph(AgentState)

# 添加节点
workflow.add_node("research", research)
workflow.add_node("analyze", analyze)
workflow.add_node("conclude", conclude)# 添加边缘
workflow.add_edge("research", "analyze")
workflow.add_edge("analyze", "conclude")
workflow.add_edge("conclude", END)

# 设置入口点
workflow.set_entry_point("research")

# 编译图
agent = workflow.compile()

# 执行工作流
result = agent.invoke({
    "messages": [HumanMessage(content="Tell me about AI agent frameworks")],
    "next_step": "research"
})

# 打印最终消息
for message in result["messages"]:
    print(f"{message.type}: {message.content}n")

6. LlamaIndex

LlamaIndex 是一个灵活的开源数据编排框架，专注于为 LLM 应用集成私有和公共数据。

主要特性：

优势：

劣势：

应用场景：

代码示例：

from llama_index.core.agent import FunctionCallingAgentWorker
from llama_index.core.tools import FunctionTool
from llama_index.llms.openai import OpenAI

# 定义一个简单的工具函数
def search_documents(query: str) -> str:
    """Search for information in the document database."""
    # 在实际应用中，这里会查询文档存储
    returnf"Here are the search results for: {query}"

# 创建一个函数工具
search_tool = FunctionTool.from_defaults(
    name="search_documents",
    fn=search_documents,
    description="Search for information in the document database"
)

# 初始化语言模型
llm = OpenAI(model="gpt-4")

# 创建 Agent
agent = FunctionCallingAgentWorker.from_tools(
    [search_tool],
    llm=llm,
    verbose=True
)

# 运行 Agent
response = agent.chat("Find information about AI agent frameworks")
print(response)

7. OpenAI Agents SDK

OpenAI Agents SDK 是一个基于 Python 的工具包，用于构建能够推理、规划和采取行动以完成复杂任务的智能自主系统。

主要特性：

优势：

劣势：

应用场景：

代码示例：

from openai import OpenAI
import json

# 初始化 OpenAI 客户端
client = OpenAI(api_key="your-api-key")

# 定义一个工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g., San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# 处理天气查询工具的函数
defsearch_weather(location):
    # 在实际应用中，这里会调用天气 API
    returnf"The weather in {location} is currently sunny with a temperature of 72°F."

# 创建使用该工具的 Agent
messages = [{"role": "user", "content": "What's the weather like in Boston?"}]
response = client.chat.completions.create(
    model="gpt-4",messages=messages,
    tools=tools,
    tool_choice="auto"
)

# 处理响应
response_message = response.choices[0].message
messages.append(response_message)

#检查模型是否想调用函数
if response_message.tool_calls:
    # 处理每个工具调用
    for tool_call in response_message.tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)

        # 调用函数
        if function_name == "search_weather":
            function_response = search_weather(function_args.get("location"))

            # 将函数响应添加到消息列表
            messages.append({
                "tool_call_id": tool_call.id,
                "role": "tool",
                "name": function_name,
                "content": function_response
            })

    # 从模型获取新响应
    second_response = client.chat.completions.create(
        model="gpt-4",
        messages=messages)

    print(second_response.choices[0].message.content)
else:
    print(response_message.content)

8. Atomic Agents

Atomic Agents 的 GitHub 仓库。

Atomic Agents 是一个轻量级、模块化的框架，用于构建 AI Agent 流水线，强调 AI Agent 开发的原子性。

主要特性：

优势：

劣势：

应用场景：

代码示例：

from pydantic import BaseModel, Field
from typing import List
import os

# 这是一个基于 Atomic Agents 方法的简化示例# 在实际实现中，你需要从 atomic_agents 包导入

# 定义输入/输出模式
class ResearchQuery(BaseModel):
    topic: str = Field(description="The topic to research")
    depth: int = Field(description="The depth of research required (1-5)")

class ResearchResult(BaseModel):
    findings: List[str] = Field(description="Key findings from the research")
    sources: List[str] =Field(description="Sources of information")

# 定义一个原子 Agent 组件
class ResearchAgent:
    def __init__(self, api_key: str):
        self.api_key = api_key
        # 初始化任何必要的客户端或工具

    def process(self, input_data: ResearchQuery) -> ResearchResult:
        # 在实际实现中，这里会使用 LLM 执行研究
        print(f"Researching {input_data.topic} at depth {input_data.depth}")

        # 模拟研究结果
        findings = [
            f"Finding 1 about {input_data.topic}",
            f"Finding 2 about {input_data.topic}",
            f"Finding 3 about {input_data.topic}"
        ]

        sources = [
            "https://github.com/e2b-dev/awesome-ai-agents","https://github.com/e2b-dev/awesome-ai-agents"
        ]

        return ResearchResult(findings=findings, sources=sources)

# 使用示例
if __name__ == "__main__":# 创建 Agent
    agent = ResearchAgent(api_key=os.environ.get("OPENAI_API_KEY", "default-key"))

    # 创建输入数据
    query = ResearchQuery(topic="AIagent frameworks", depth=3)

    # 处理查询
    result = agent.process(query)

    # 显示结果
    print("nResearch Findings:")
    for i, finding in enumerate(result.findings, 1):
        print(f"{i}. {finding}")

    print("nSources:")
    for source in result.sources:
        print(f"- {source}")

9. Rasa

RASA 是一个开源机器学习框架，专注于构建对话式 AI 应用，侧重于文本和语音助手。

主要特性：

优势：

劣势：

应用场景：

代码示例：

# RASA 项目结构示例
# 这通常会分布在 RASA 项目的多个文件中

# domain.yml - 定义助手的领域
"""
version: "3.1"

intents:
  - greet
  - goodbye
  - ask_about_ai_frameworks

responses:
  utter_greet:
    - text: "Hello! How can I help you with AI frameworks today?"

  utter_goodbye:
    - text: "Goodbye! Feel free to ask about AI frameworks anytime."

  utter_about_frameworks:
    - text: "There are several popular AI agent frameworks including LangChain, AutoGen, CrewAI, and more. Which one would you like to know about?"

entities:
  - framework_name

slots:
  framework_name:
    type: text
    mappings:
    - type: from_entity
      entity: framework_name
"""

# data/nlu.yml - 用于 NLU 的训练数据
"""
version: "3.1"nlu:
- intent: greet
  examples: |
    - hey
    - hello
    - hi
    - hello there
    - good morning

- intent: goodbye
  examples: |
    - bye
    -goodbye
    - see you around
    - see you later

- intent: ask_about_ai_frameworks
  examples: |
    - tell me about AI frameworks
    - what are the best AI agent frameworks- I need information about [LangChain](framework_name)
    - How does [AutoGen](framework_name) work?
    - Can you explain [CrewAI](framework_name)?
"""

# data/stories.yml - 用于对话管理的训练数据
"""
version: "3.1"

stories:
- story: greet and ask about frameworks
  steps:
  - intent: greet
  - action: utter_greet- intent: ask_about_ai_frameworks
  - action: utter_about_frameworks

- story: ask about specific framework
  steps:
  - intent: ask_about_ai_frameworks
    entities:
    - framework_name: "LangChain"
  - action: action_framework_info
"""

# actions/actions.py - 自定义操作
"""
from typing import Any, Text, Dict,List
from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher

class ActionFrameworkInfo(Action):
    def name(self) -> Text:
        return "action_framework_info"def run(self, dispatcher: CollectingDispatcher,
            tracker: Tracker,
            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:

        framework = tracker.get_slot("framework_name")

        if framework.lower() == "langchain":
            dispatcher.utter_message(text="LangChain is an open-source framework for building applications using large language models.")
        elif framework.lower()== "autogen":
            dispatcher.utter_message(text="AutoGen is a framework from Microsoft Research that enables the development of LLM applications using multiple agents.")
        elif framework.lower() == "crewai":dispatcher.utter_message(text="CrewAI is a framework for orchestrating role-playing autonomous AI agents.")
        else:
            dispatcher.utter_message(text=f"I don't have specific information about {framework}, but it might be one of the emerging AI agent frameworks.")

        return []
"""

# 要训练和运行 RASA 助手：
# rasa train
# rasa run

10. MetaGPT

MetaGPT 由 Chenglin Wu 创立，是最受欢迎的开源 Agent 框架之一。

MetaGPT 是一个开源的多 Agent 框架，利用 LLM 编排 AI Agent 来模拟协作解决问题。MetaGPT 由 Chenglin Wu 创立，其 GitHub仓库已获得超过 5.6 万星标，这表明开发者们非常喜爱这款灵活且易于使用的开源 Agentic 框架。

主要特性：

优势：

劣势：

应用场景：

-自动化软件开发项目生成

代码示例：

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

asyncdef main():
    # 定义项目需求
    requirement = "Create a web application that allows usersto search for and compare AI agent frameworks"

    # 创建具有不同角色的团队成员
    product_manager = ProductManager()
    project_manager = ProjectManager()
    architect = Architect()
    engineer = Engineer()# 组建一个包含这些的团队
    team = Team(
        name="AI Framework Explorer Team",
        members=[product_manager, project_manager, architect, engineer]
    )

    # 让团队开始处理需求
    await team.run(requirement)

    # 团队将生成：
    # 1. PRD (产品需求文档)
    # 2. 设计文档
    # 3. 架构图
    # 4. 实现代码
    # 5. 测试
if __name__ == "__main__":
    asyncio.run(main())

11. Camel-AI (CAMEL)

Camel-AI (CAMEL — Communicative Agents for Machine Learning) 是一个开源多 Agent 框架，使自主 Agent 能够协作、沟通并解决复杂任务。

主要特性：

优势：

劣势：

应用场景：

代码示例：

from camel.agents import ChatAgent
from camel.messages import BaseMessage
from camel.typing import ModelType
import asyncio

asyncdef main():
    # 创建两个具有不同角色的 Agent
    user_agent = ChatAgent(
        model_type=ModelType.GPT_4,
        system_message="You are a user who needs help analyzing data about AI frameworks."
    )

    assistant_agent = ChatAgent(
        model_type=ModelType.GPT_4,
        system_message="You are an AI assistant specialized in data analysis and AI frameworks."
    )

    # 用户 Agent 发出的初始消息
    user_message = BaseMessage.make_user_message(
        role_name="User",
        content="I need to compare different AI agent frameworks for my project. Can you help me analyze their features?")

    # 开始对话
    assistant_response = await assistant_agent.step(user_message)
    print(f"Assistant: {assistant_response.content}n")

    # 继续对话for _ in range(3):  # 模拟几个回合的对话
        user_response = await user_agent.step(assistant_response)
        print(f"User: {user_response.content}n")assistant_response = await assistant_agent.step(user_response)
        print(f"Assistant: {assistant_response.content}n")

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

开源框架与商业解决方案

开源框架：

商业框架：

AI Agent 框架的关键评估标准

评估 AI Agent 框架时，请考虑以下重要因素：

AI Agent 框架的新兴趋势

AI Agent 领域正在快速发展，呈现出以下几个显著趋势：

如何选择合适的 AI Agent 框架

为您的项目选择 AI Agent 框架时，请考虑：- 您的特定项目需求

结论

AI Agent 框架格局正在快速演变，其中开源解决方案在创新性和灵活性方面遥遥领先。对于希望构建复杂 AI 应用的开发者来说，这些框架提供了创建智能、自主系统所需的工具和基础设施。

无论您需要用于构建对话 Agent、多 Agent 协作系统，还是复杂工作流自动化的框架，本指南介绍的 11 个框架都提供了多种选择，以满足不同的需求和技术专业水平。

随着 AI Agent 技术的不断发展，了解这些框架的能力和局限性对于希望在应用中充分发挥 AI 潜力的开发者来说至关重要。