kaggle竞赛宝典 | 智能体框架：11 个顶级 AI Agent 框架！-CSDN博客

本文链接：https://blog.csdn.net/csdn_xmj/article/details/149096946

本文来源公众号“kaggle竞赛宝典”，仅用于学术分享，侵权删，干货满满。

最近笔者在找智能体框架，看到一个文章：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）系统。### 主要特性：

智能系统设计，处理复杂任务游刃有余
精细控制 Agent 工作流
支持多 Agent 交互
允许人工干预（Human-in-the-loop）
无缝集成外部工具和 API

优势：

强大且灵活的框架
开源且拥有强大的社区支持
支持处理复杂任务
能够实时获取信息
提供对 AI Agent 的精细控制

劣势：

需要扎实的编程功底
设计复杂 Agent 时复杂度较高
依赖底层 LLM 的能力

应用场景：

开发智能应用- 创建自主的任务解决系统
构建复杂的多步工作流 Agent
将 AI 能力集成到现有软件中

代码示例：

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 Logo

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

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

主要特性：

支持多 Agent 协作（包括人工参与和完全自主模式）
集成大型语言模型 (LLM)
支持代码执行与调试
可扩展性与分布式计算
异步消息传递
自主和交互式工作流

优势：

精简了 AI Agent 系统的创建与管理流程
简化了协作与推理型 AI 系统的构建
允许 Agent 间交互以解决复杂问题

劣势：

框架相对较新（仍在持续开发中）
设置多 Agent 交互较为复杂
性能可能因 Agent 配置而异

应用场景：

软件开发
复杂任务求解
交互式 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 Logo

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

主要特性

Agent 协作，具有特定角色、工具和目标
可通过定义角色进行 Agent 定制
提供高级别的简易性和精确的低级别控制
支持跨行业的自动化工作流
与各种 LLM 和云平台兼容

优势

Agent 设计灵活
实现简单
支持完成复杂的协作任务
Agent 架构模块化且可重用

劣势

需要具备 Python 编程知识
框架相对较新（社区支持可能有限）
设计复杂的 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 Logo

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

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

主要特性

集成多个 AI 服务提供商（OpenAI、Azure OpenAI、Hugging Face）
支持多种 Agent 类型的 Agent 框架
轻量级且灵活的架构
企业级支持
多 Agent 系统能力

优势：

模块化架构
易于使用的开发方法
支持创建复杂的工作流
能够将 AI 嵌入到现有开发流程中

劣势：

框架相对较新
需要理解 AI 集成概念
对于不熟悉 AI框架的开发者可能存在学习曲线

应用场景：

企业级 AI 解决方案
自定义 AI Agent 开发
工作流自动化
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

LangGraph Logo

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

主要特性：

先进的 Agentic 模式（工具调用、React 方法论、Self-Ask 方法）
支持节点（LLM）和边缘（工具）的可视化表示
对工作流流程和状态进行细粒度控制
构建有状态应用的灵活框架
支持复杂的多 Agent 场景

优势：

专为基于语言的 AI Agent 设计的基础架构
能够创建精密的、相互关联的 Agent 系统
支持复杂工作流的设计与管理

劣势：

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

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

应用场景：

对话式 Agent
复杂任务自动化
自定义 LLM 支持的工作流
专注于语言处理的AI 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

LlamaIndex Logo

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

主要特性：

AI Agent 功能，可作为“自动化推理和决策引擎”
函数调用能力
与各种格式的数据交互
工具集成
支持多模态应用（文本、图像及其他数据类型）

优势：

框架简单灵活
支持集成各种数据源
能够进行自定义 AI Agent 开发 -开源且适应性强

劣势：

复杂度可能需要高级技术知识
需要理解 LLM 和 Agent 开发概念

应用场景：

企业知识助手
自主 AI Agent
复杂数据交互与分析
构建生产级 AI 应用

代码示例：

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 Logo

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

主要特性：

Agent 循环功能（处理工具调用，将结果发送给 LLM）
工具集成（将 Python 函数转换为 Agent 可用的工具）
支持跟踪功能，可视化 Agent 工作流

优势：

精简的 Agent 开发方法
内置Agent 工作流可视化功能
步步跟踪 Agent 行动

劣势：

依赖 OpenAI 的基础设施
需要扎实的 Python 编程功底
可能受 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

Atomic Agents Logo

Atomic Agents 的 GitHub 仓库。

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

主要特性：

模块化，允许组合小型、可重用的组件
使用 Pydantic 通过清晰的输入/输出模式实现可预测性
可扩展性，用于集成新组件
支持多 Agent 系统开发

优势：

轻量级架构
Agent 构建灵活性高
对 AI Agent 组件的控制精细
开源且对开发者友好

劣势：

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

应用场景：

构建复杂的 AI 应用
开发多 Agent 系统 -创建模块化 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

Rasa Logo

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

主要特性：

先进的自然语言理解 (NLU) 能力
提供灵活性和控制力，构建上下文感知的对话 Agent
机器学习能力，用于构建、测试和部署 AI 应用

优势：

高度可定制
强大的机器学习框架
文档完善丰富
支持复杂的对话场景

劣势：

与无代码平台相比，需要更多技术专业知识
对于初学者来说学习曲线较陡峭
可能需要大量开发资源

应用场景：

聊天机器人开发
虚拟助手
客户服务界面 -语音交互系统
企业级对话式 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 Logo

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

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

主要特性：

仅凭单行需求即可生成全面的项目材料- 模拟软件开发团队结构
为 Agent 分配不同的基于 GPT 的角色
能够进行复杂的协作解决问题

优势：

复刻人类的程序性知识
优化多 Agent 系统交互 -自动化全面的软件开发工作流
可模拟整个团队的角色

劣势：

设置复杂度较高
依赖大型语言模型的能力
多 Agent 交互可能存在不一致性

应用场景：

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

复杂多 Agent 协作解决问题
高级 AI 驱动的研究与分析
模拟组织决策过程

代码示例：

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 Logo

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

主要特性：

支持多 Agent 协作
支持 Agent 系统的持续演进- 为多 Agent 应用提供通用基础架构
集成用于文本和图像任务的 AI 模型

优势：

开源
框架灵活
支持集成各种 AI 模型
能够实现自主 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())