Python

主题

Agent框架概述 ​

什么是Agent框架？ ​

Agent框架是用于构建AI Agent的软件框架，提供了工具调用、记忆管理、规划决策等核心功能，帮助开发者快速构建能够自主完成任务的智能系统。

核心概念 ​

1. Agent定义 ​

Agent是能够感知环境、做出决策并采取行动的智能系统：

  • 自主性：能够独立做出决策
  • 反应性：能够响应环境变化
  • 主动性：能够主动采取行动
  • 社会性：能够与其他Agent交互

2. 核心组件 ​

Agent框架的核心组件：

  • LLM引擎：大语言模型作为推理引擎
  • 工具集：Agent可使用的工具集合
  • 记忆系统：短期和长期记忆管理
  • 规划器：任务规划和分解
  • 执行器：任务执行和监控

3. 工作模式 ​

Agent的常见工作模式：

  • ReAct模式：推理-行动-观察循环
  • Plan-and-Execute：先规划后执行
  • Reflexion：反思和改进
  • Multi-Agent：多Agent协作

主流Agent框架对比 ​

框架特点优势劣势适用场景
AutoGPT自主Agent完全自主、持续运行不稳定、成本高探索性任务
BabyAGI任务驱动简单、易理解功能有限任务管理
MetaGPT多角色协作角色明确、协作高效复杂度高软件开发
CrewAI多Agent协作易用、灵活相对较新团队协作
AutoGen对话式Agent微软支持、企业级学习曲线陡企业应用
ChatDev虚拟公司场景明确、易于理解限制较多软件开发
CAMEL通信Agent通信机制完善应用场景窄研究探索

技术方案对比 ​

Agent框架架构对比 ​

框架架构模式自主程度协作方式学习成本适用场景
AutoGPT单Agent自主循环完全自主无低探索性任务
BabyAGI任务队列驱动半自主无低任务管理
MetaGPT角色扮演协作半自主角色分工中等软件开发
CrewAI团队协作半自主任务分配低团队协作
AutoGen对话式协作半自主对话协商中等企业应用
ChatDev虚拟公司半自主角色分工低软件开发
CAMEL通信Agent半自主消息传递中等研究探索

Agent工作模式对比 ​

模式原理优点缺点适用场景
ReAct推理-行动-观察循环简单、可解释可能陷入循环通用任务
Plan-and-Execute先规划后执行计划清晰规划可能不准确复杂任务
Reflexion反思和改进能从错误学习需要多次尝试需要改进的任务
Multi-Agent多Agent协作能力互补协调复杂团队任务

如何选择Agent框架？ ​

选择流程：

任务类型？
├── 探索性任务 → AutoGPT（完全自主）
├── 任务管理 → BabyAGI（任务驱动）
├── 软件开发 → MetaGPT/ChatDev（角色协作）
└── 团队协作 → CrewAI/AutoGen（多Agent）

自主程度？
├── 完全自主 → AutoGPT
├── 半自主 → BabyAGI/CrewAI
└── 需要人工监督 → AutoGen

协作需求？
├── 无需协作 → AutoGPT/BabyAGI
├── 简单协作 → CrewAI
└── 复杂协作 → AutoGen/MetaGPT

设计原理与目的 ​

为什么需要Agent框架？ ​

直接使用LLM的问题：

问题1：无法执行操作
LLM只能生成文本，无法：
- 调用API
- 读写文件
- 执行代码

问题2：无法处理复杂任务
复杂任务需要：
- 分解子任务
- 逐步执行
- 处理中间结果

问题3：无法持续运行
有些任务需要：
- 长时间运行
- 多次尝试
- 从错误中恢复

Agent框架的解决方案：

解决方案1：工具调用
让LLM能够调用外部工具：
- 搜索引擎
- 计算器
- 文件系统
- API接口

解决方案2：任务规划
让LLM能够规划和分解任务：
- 分析任务需求
- 制定执行计划
- 分解为子任务

解决方案3：执行循环
让Agent能够持续运行：
- 执行行动
- 观察结果
- 调整策略
- 重复循环

Agent的核心原理 ​

1. ReAct模式（推理-行动-观察）

执行循环：

用户输入 → 思考(Thought) → 行动(Action) → 观察(Observation)
                ↑                              ↓
                └──────── 重复循环 ←───────────┘

示例：
用户：北京天气怎么样？

思考1：我需要查询北京的天气信息
行动1：调用天气API，参数：北京
观察1：北京今天晴，25℃

思考2：我已经获取到天气信息，可以回答用户
行动2：生成回答
观察2：任务完成

回答：北京今天天气晴朗，温度25度。

2. 工具调用机制

工具定义：
{
    "name": "search",
    "description": "搜索互联网信息",
    "parameters": {
        "query": {"type": "string", "description": "搜索关键词"}
    }
}

工具调用过程：
1. LLM分析用户需求
2. LLM决定使用哪个工具
3. LLM生成工具参数
4. 执行工具
5. 将结果返回给LLM
6. LLM基于结果生成回答

3. 记忆管理机制

记忆类型：

短期记忆（对话历史）：
- 当前对话的上下文
- 最近的消息
- 用于保持对话连贯

长期记忆（知识库）：
- 用户偏好
- 历史信息
- 用于个性化服务

工作记忆（当前任务）：
- 任务状态
- 中间结果
- 用于任务执行

为什么多Agent协作有效？ ​

问题： 单个Agent能力有限

解决方案： 多个Agent协作

类比：团队协作

单Agent：
一个人完成所有工作
- 精力有限
- 技能有限
- 效率有限

多Agent：
多人协作完成工作
- 分工明确
- 技能互补
- 效率更高

示例：软件开发团队
- 产品经理：分析需求
- 架构师：设计系统
- 程序员：编写代码
- 测试员：测试质量

为什么角色扮演有效？ ​

问题： LLM默认行为可能不适合特定任务

解决方案： 让LLM扮演特定角色

角色扮演的作用：

1. 约束行为
"你是一个专业的Python程序员"
→ LLM会以程序员的视角回答问题

2. 明确职责
"你的职责是审查代码质量"
→ LLM会专注于代码审查

3. 提高质量
"你有10年的开发经验"
→ LLM会提供更专业的建议

Agent基本循环：Observe → Think → Act ​

循环原理 ​

Agent的核心是感知-思考-行动循环，这是Agent能够自主完成任务的基础。

┌─────────────────────────────────────────────────────────────────┐
│                    Agent 基本循环                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                                                         │   │
│   │   ┌─────────┐                                           │   │
│   │   │ Observe │ ←─────────────────────────────┐           │   │
│   │   │ (感知)  │                               │           │   │
│   │   └────┬────┘                               │           │   │
│   │        │                                    │           │   │
│   │        ▼                                    │           │   │
│   │   ┌─────────┐                               │           │   │
│   │   │  Think  │                               │           │   │
│   │   │ (思考)  │                               │           │   │
│   │   └────┬────┘                               │           │   │
│   │        │                                    │           │   │
│   │        ▼                                    │           │   │
│   │   ┌─────────┐                               │           │   │
│   │   │   Act   │ ──────────────────────────────┘           │   │
│   │   │ (行动)  │                                           │   │
│   │   └─────────┘                                           │   │
│   │                                                         │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│   循环条件：任务未完成 且 未达到最大迭代次数                        │
│   终止条件：任务完成 或 达到最大迭代次数 或 用户中断               │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

各阶段详解 ​

1. Observe（感知） ​

作用：收集当前状态信息

感知的内容：

  • 用户输入
  • 环境状态
  • 工具返回结果
  • 记忆中的信息

代码示例：

python
def observe(user_input: str, tool_results: list, memory: dict) -> dict:
    """
    感知阶段：收集当前状态信息
    
    Args:
        user_input: 用户输入
        tool_results: 工具返回的结果
        memory: 记忆中的信息
    
    Returns:
        当前状态的完整信息
    """
    state = {
        "user_input": user_input,
        "tool_results": tool_results,
        "memory": memory,
        "timestamp": "2024-01-15 10:30:00"
    }
    return state

2. Think（思考） ​

作用：分析状态，做出决策

思考的内容：

  • 分析用户意图
  • 评估当前状态
  • 决定下一步行动
  • 选择合适的工具

代码示例：

python
from openai import OpenAI

client = OpenAI()

def think(state: dict) -> dict:
    """
    思考阶段：分析状态，做出决策
    
    Args:
        state: 当前状态
    
    Returns:
        决策结果
    """
    # 构建思考提示
    prompt = f"""
    当前状态：
    - 用户输入：{state['user_input']}
    - 工具结果：{state['tool_results']}
    - 记忆：{state['memory']}
    
    请分析当前状态，决定下一步行动。
    """
    
    # 调用LLM进行思考
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )
    
    decision = {
        "action": "call_tool",  # 或 "answer", "think_more"
        "tool": "search",
        "parameters": {"query": "人工智能"},
        "reasoning": response.choices[0].message.content
    }
    
    return decision

3. Act（行动） ​

作用：执行决策，获取结果

行动的类型：

  • 调用工具
  • 生成回答
  • 更新记忆
  • 请求更多信息

代码示例：

python
def act(decision: dict, tools: dict) -> dict:
    """
    行动阶段：执行决策
    
    Args:
        decision: 决策结果
        tools: 可用工具
    
    Returns:
        行动结果
    """
    if decision["action"] == "call_tool":
        # 调用工具
        tool_name = decision["tool"]
        tool_params = decision["parameters"]
        
        if tool_name in tools:
            result = tools[tool_name](**tool_params)
            return {
                "status": "success",
                "result": result,
                "tool": tool_name
            }
        else:
            return {
                "status": "error",
                "error": f"工具 {tool_name} 不存在"
            }
    
    elif decision["action"] == "answer":
        # 直接回答
        return {
            "status": "complete",
            "answer": decision.get("answer", "")
        }
    
    else:
        return {
            "status": "continue",
            "reasoning": decision.get("reasoning", "")
        }

完整的Agent循环实现 ​

python
from openai import OpenAI
from typing import Dict, List, Callable
import json

client = OpenAI()

class Agent:
    """
    完整的Agent实现
    
    实现了 Observe -> Think -> Act 循环
    """
    
    def __init__(self, tools: Dict[str, Callable], max_iterations: int = 5):
        """
        初始化Agent
        
        Args:
            tools: 可用工具字典
            max_iterations: 最大迭代次数
        """
        self.tools = tools
        self.max_iterations = max_iterations
        self.memory = {}  # 记忆
        self.history = []  # 执行历史
    
    def observe(self, user_input: str, tool_results: List[Dict] = None) -> Dict:
        """
        感知阶段
        
        Args:
            user_input: 用户输入
            tool_results: 工具返回结果
        
        Returns:
            当前状态
        """
        return {
            "user_input": user_input,
            "tool_results": tool_results or [],
            "memory": self.memory,
            "history": self.history
        }
    
    def think(self, state: Dict) -> Dict:
        """
        思考阶段
        
        Args:
            state: 当前状态
        
        Returns:
            决策结果
        """
        # 构建思考提示
        prompt = f"""你是一个智能助手。请分析当前状态，决定下一步行动。

当前状态：
- 用户输入：{state['user_input']}
- 工具结果：{json.dumps(state['tool_results'], ensure_ascii=False)}
- 历史记录：{json.dumps(state['history'][-3:], ensure_ascii=False) if state['history'] else '无'}

可用工具：
{json.dumps([{"name": name, "description": func.__doc__ or "无描述"} for name, func in self.tools.items()], ensure_ascii=False, indent=2)}

请以JSON格式返回你的决策：
{{
    "action": "call_tool" 或 "answer" 或 "think_more",
    "tool": "工具名称（如果action是call_tool）",
    "parameters": {{}},
    "answer": "最终答案（如果action是answer）",
    "reasoning": "你的思考过程"
}}"""
        
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"}
        )
        
        decision = json.loads(response.choices[0].message.content)
        return decision
    
    def act(self, decision: Dict) -> Dict:
        """
        行动阶段
        
        Args:
            decision: 决策结果
        
        Returns:
            行动结果
        """
        if decision["action"] == "call_tool":
            # 调用工具
            tool_name = decision.get("tool")
            tool_params = decision.get("parameters", {})
            
            if tool_name in self.tools:
                try:
                    result = self.tools[tool_name](**tool_params)
                    return {
                        "status": "success",
                        "result": result,
                        "tool": tool_name
                    }
                except Exception as e:
                    return {
                        "status": "error",
                        "error": str(e),
                        "tool": tool_name
                    }
            else:
                return {
                    "status": "error",
                    "error": f"工具 {tool_name} 不存在"
                }
        
        elif decision["action"] == "answer":
            return {
                "status": "complete",
                "answer": decision.get("answer", "")
            }
        
        else:
            return {
                "status": "continue",
                "reasoning": decision.get("reasoning", "")
            }
    
    def run(self, user_input: str) -> str:
        """
        运行Agent的主循环
        
        Args:
            user_input: 用户输入
        
        Returns:
            最终回答
        """
        print(f"用户输入：{user_input}")
        
        tool_results = []
        
        for iteration in range(self.max_iterations):
            print(f"\n--- 迭代 {iteration + 1} ---")
            
            # Observe：感知当前状态
            state = self.observe(user_input, tool_results)
            print(f"感知状态：{json.dumps(state, ensure_ascii=False, indent=2)[:200]}...")
            
            # Think：思考并决策
            decision = self.think(state)
            print(f"决策：{json.dumps(decision, ensure_ascii=False, indent=2)}")
            
            # Act：执行行动
            result = self.act(decision)
            print(f"结果：{json.dumps(result, ensure_ascii=False, indent=2)}")
            
            # 更新历史
            self.history.append({
                "iteration": iteration + 1,
                "decision": decision,
                "result": result
            })
            
            # 检查是否完成
            if result["status"] == "complete":
                return result["answer"]
            
            # 如果是工具调用，将结果添加到工具结果列表
            if result["status"] == "success":
                tool_results.append({
                    "tool": result["tool"],
                    "result": result["result"]
                })
        
        return "达到最大迭代次数，任务未完成"

# 使用示例
def search(query: str) -> str:
    """搜索互联网信息"""
    return f"搜索结果：关于'{query}'的最新信息..."

def calculate(expression: str) -> str:
    """计算数学表达式"""
    try:
        result = eval(expression)
        return f"计算结果：{result}"
    except Exception as e:
        return f"计算错误：{e}"

# 创建Agent
agent = Agent(
    tools={
        "search": search,
        "calculate": calculate
    },
    max_iterations=5
)

# 运行Agent
# result = agent.run("搜索人工智能的最新进展，并计算相关数据")
# print(f"\n最终结果：{result}")

循环终止条件 ​

终止条件：

1. 任务完成
   - Agent生成了最终答案
   - 用户问题得到解决

2. 达到最大迭代次数
   - 防止无限循环
   - 节省资源

3. 用户中断
   - 用户主动停止
   - 超时处理

4. 错误终止
   - 发生不可恢复的错误
   - 工具调用失败

应用场景详解 ​

场景一：自主研究Agent ​

需求： 自动研究某个主题并生成报告

实现：

python
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

# 1. 定义工具
@tool
def search_web(query: str) -> str:
    """搜索互联网信息"""
    # 这里应该是实际的搜索API
    return f"搜索结果：关于'{query}'的最新研究..."

@tool
def save_notes(content: str) -> str:
    """保存研究笔记"""
    with open("research_notes.txt", "a", encoding="utf-8") as f:
        f.write(content + "\n")
    return "笔记已保存"

@tool
def read_notes() -> str:
    """读取研究笔记"""
    try:
        with open("research_notes.txt", "r", encoding="utf-8") as f:
            return f.read()
    except:
        return "暂无笔记"

# 2. 创建Agent
tools = [search_web, save_notes, read_notes]

prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个专业的研究员。你的任务是研究指定主题并生成报告。

研究流程：
1. 搜索相关信息
2. 保存重要发现
3. 整理和分析
4. 生成报告

请使用提供的工具完成研究。"""),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

llm = ChatOpenAI(model="gpt-4o-mini")
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 3. 使用
response = agent_executor.invoke({
    "input": "请研究人工智能在医疗领域的应用，并生成一份报告"
})
print(response["output"])

设计要点：

  • 定义研究相关的工具
  • 使用提示模板引导研究流程
  • Agent可以自主执行多步研究

场景二：任务管理Agent ​

需求： 自动分解和管理复杂任务

实现：

python
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from typing import List, Dict
import json

# 1. 任务存储
tasks_db = []

@tool
def create_task(title: str, description: str, priority: str = "medium") -> str:
    """创建新任务"""
    task = {
        "id": len(tasks_db) + 1,
        "title": title,
        "description": description,
        "priority": priority,
        "status": "pending"
    }
    tasks_db.append(task)
    return f"任务已创建：{task['id']} - {title}"

@tool
def list_tasks() -> str:
    """列出所有任务"""
    if not tasks_db:
        return "暂无任务"
    
    task_list = []
    for task in tasks_db:
        task_list.append(f"- [{task['status']}] {task['id']}. {task['title']} ({task['priority']})")
    
    return "\n".join(task_list)

@tool
def complete_task(task_id: int) -> str:
    """完成任务"""
    for task in tasks_db:
        if task["id"] == task_id:
            task["status"] = "completed"
            return f"任务已完成：{task_id} - {task['title']}"
    return f"未找到任务：{task_id}"

# 2. 创建Agent
tools = [create_task, list_tasks, complete_task]

prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个任务管理助手。你可以帮助用户：
1. 分解复杂任务为子任务
2. 创建和管理任务列表
3. 跟踪任务进度

请使用提供的工具管理任务。"""),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

llm = ChatOpenAI(model="gpt-4o-mini")
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 3. 使用
response = agent_executor.invoke({
    "input": "帮我分解这个任务：开发一个电商网站"
})
print(response["output"])

设计要点：

  • 定义任务管理工具
  • Agent可以自动分解任务
  • 支持任务状态管理

场景三：代码助手Agent ​

需求： 自动编写、测试和调试代码

实现：

python
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

# 1. 定义工具
@tool
def write_code(filename: str, code: str) -> str:
    """编写代码到文件"""
    with open(filename, "w", encoding="utf-8") as f:
        f.write(code)
    return f"代码已写入：{filename}"

@tool
def read_code(filename: str) -> str:
    """读取代码文件"""
    try:
        with open(filename, "r", encoding="utf-8") as f:
            return f.read()
    except:
        return f"文件不存在：{filename}"

@tool
def run_code(filename: str) -> str:
    """运行代码"""
    import subprocess
    try:
        result = subprocess.run(
            ["python", filename],
            capture_output=True,
            text=True,
            timeout=10
        )
        if result.returncode == 0:
            return f"运行成功：\n{result.stdout}"
        else:
            return f"运行失败：\n{result.stderr}"
    except Exception as e:
        return f"运行错误：{e}"

# 2. 创建Agent
tools = [write_code, read_code, run_code]

prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个专业的Python程序员。你可以：
1. 编写Python代码
2. 读取和分析代码
3. 运行和测试代码
4. 调试和修复错误

请使用提供的工具完成编程任务。"""),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

llm = ChatOpenAI(model="gpt-4")  # 代码任务建议使用GPT-4
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 3. 使用
response = agent_executor.invoke({
    "input": "请写一个Python函数，实现快速排序算法，并测试它"
})
print(response["output"])

设计要点：

  • 定义代码相关工具
  • 使用GPT-4获得更好的代码生成效果
  • 支持代码编写、运行和调试

场景四：客服Agent ​

需求： 智能客服系统，能回答问题和处理请求

实现：

python
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory

# 1. 定义工具
@tool
def lookup_order(order_id: str) -> str:
    """查询订单状态"""
    # 模拟订单查询
    orders = {
        "ORD001": {"status": "已发货", "tracking": "SF1234567890"},
        "ORD002": {"status": "待付款", "amount": 299.00}
    }
    order = orders.get(order_id)
    if order:
        return f"订单{order_id}：{order}"
    return f"未找到订单：{order_id}"

@tool
def create_ticket(subject: str, description: str) -> str:
    """创建工单"""
    # 模拟创建工单
    ticket_id = "TKT001"
    return f"工单已创建：{ticket_id} - {subject}"

@tool
def search_faq(query: str) -> str:
    """搜索常见问题"""
    # 模拟FAQ搜索
    faq = {
        "退货": "7天无理由退货，请在订单页面申请退货",
        "发货": "订单付款后48小时内发货",
        "支付": "支持支付宝、微信、银行卡支付"
    }
    for key, value in faq.items():
        if key in query:
            return value
    return "未找到相关问题，请联系人工客服"

# 2. 创建Agent
tools = [lookup_order, create_ticket, search_faq]

prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个专业的客服助手。你可以：
1. 查询订单状态
2. 创建客服工单
3. 回答常见问题

请用友好专业的语气与客户沟通。如果无法解决问题，请创建工单转接人工客服。"""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

llm = ChatOpenAI(model="gpt-4o-mini")
memory = ConversationBufferMemory(return_messages=True, memory_key="chat_history")
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)

# 3. 使用
response = agent_executor.invoke({"input": "我的订单ORD001发货了吗？"})
print(response["output"])

response = agent_executor.invoke({"input": "怎么退货？"})
print(response["output"])

设计要点：

  • 定义客服相关工具
  • 使用记忆保持对话上下文
  • 引导Agent友好专业地服务

选型指南 ​

1. 需求分析 ​

  • 任务类型：探索性任务、确定性任务
  • 自主程度：完全自主、半自主、人工监督
  • 协作需求：单Agent、多Agent协作
  • 性能要求：响应时间、准确性、稳定性

2. 技术评估 ​

  • 成熟度：框架的稳定性和社区活跃度
  • 扩展性：功能扩展和定制能力
  • 集成性：与现有系统的集成难度
  • 学习成本：团队学习和使用成本

深入学习 ​

Agent核心API和技术详解 ​

深入学习Agent开发的核心技术：

文档内容关键技术
Agent核心API详解LLM引擎、工具注册、记忆管理、规划器、执行器6大核心API的详细实现
Agent核心技术详解ReAct、CoT、ToT、Plan-and-Execute、Reflexion6种推理框架的原理和实现

Agent框架详解 ​

选择一个Agent框架深入学习：

框架特点详细文档
AutoGPT自主AI代理AutoGPT详解
BabyAGI任务驱动的自主AgentBabyAGI详解
MetaGPT多角色协作框架MetaGPT详解
CrewAI多Agent协作框架CrewAI详解
AutoGen多Agent对话框架AutoGen详解
ChatDev基于角色的开发框架ChatDev详解
CAMEL通信Agent框架CAMEL详解

下一步学习 ​