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

理解和处理自然语言输入- 对复杂问题进行推理

1. LangChain

智能系统设计，处理复杂任务游刃有余

强大且灵活的框架

需要扎实的编程功底

开发智能应用- 创建自主的任务解决系统

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 (微软)

支持多 Agent 协作（包括人工参与和完全自主模式）

精简了 AI Agent 系统的创建与管理流程

框架相对较新（仍在持续开发中）

软件开发

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

Agent 协作，具有特定角色、工具和目标

Agent 设计灵活

需要具备 Python 编程知识

工作流自动化 -支持机器人创建

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 (微软)

集成多个 AI 服务提供商（OpenAI、Azure OpenAI、Hugging Face）

模块化架构

框架相对较新

企业级 AI 解决方案

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

先进的 Agentic 模式（工具调用、React 方法论、Self-Ask 方法）

专为基于语言的 AI Agent 设计的基础架构

主要专注于基于语言的工作流

对话式 Agent

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

AI Agent 功能，可作为“自动化推理和决策引擎”

框架简单灵活

复杂度可能需要高级技术知识

企业知识助手

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

Agent 循环功能（处理工具调用，将结果发送给 LLM）

精简的 Agent 开发方法

依赖 OpenAI 的基础设施

客户支持自动化

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

模块化，允许组合小型、可重用的组件

轻量级架构

框架相对较新（生态系统仍在演变）

构建复杂的 AI 应用

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

先进的自然语言理解 (NLU) 能力

高度可定制

与无代码平台相比，需要更多技术专业知识

聊天机器人开发

# 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

仅凭单行需求即可生成全面的项目材料- 模拟软件开发团队结构

复刻人类的程序性知识

设置复杂度较高

复杂多 Agent 协作解决问题

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)

支持多 Agent 协作

开源

作为一个较新的框架，其文档和特性可能仍在发展中

autónoma 任务求解

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

开源框架：

公开且免费使用

商业框架：

通常提供更完善的企业级功能

易用性

越来越侧重于多 Agent 系统

首选的编程语言

一起“点赞”三连↓