章节导语

如果你用同一个AI模型，装在不同架构里，效果可能差好几倍。就像同样的食材，在不同厨师手里，能做出完全不同的菜。

这就是Agent架构设计的意义。大模型是”大脑”，架构是”神经系统”——决定信息怎么传递、决策怎么做、行动怎么执行。

本文会带你从0开始，理解7种主流Agent架构模式。不只是讲概念，每种架构都有完整的代码实现和运行结果，让你真正学懂。

一、前置说明

1.1 本文学习路径

建议按以下顺序学习：

1.2 读者需要的基础

• Python基础：会写函数、类、基本语法
• API调用：知道什么是REST API、JSON格式
• AI概念：知道大模型、Prompt是什么

1.3 学习目标

学完本文，你将能够：

• 理解7种Agent架构的原理和适用场景
• 根据任务需求选择合适的架构
• 用Python实现基本的Agent系统
• 避免常见的架构设计陷阱

二、环境配置

在开始写代码之前，先把开发环境准备好。

2.1 安装依赖

# 创建项目目录
mkdir agent-project && cd agent-project

# 安装Python依赖
pip install openai python-dotenv

2.2 配置API Key

# 创建.env文件，存放API Key
echo "OPENAI_API_KEY=sk-your-key-here" > .env

# 在代码中加载（会自动读取.env文件）
from dotenv import load_dotenv
load_dotenv()

注意：把sk-your-key-here换成你真实的OpenAI API Key。如果没有，可以去OpenAI官网申请。

2.3 验证环境

运行以下代码，确认环境配置正确：

# 验证环境配置是否成功
from openai import OpenAI
import os

# 加载环境变量
from dotenv import load_dotenv
load_dotenv()

# 创建客户端
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# 测试API调用
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hi"}]
)

print("✅ 环境配置成功！")
print(f"模型响应: {response.choices[0].message.content}")

如果看到”环境配置成功”，说明环境OK，可以开始写代码了。

三、重新理解AI Agent

3.1 什么是Agent？

简单说，Agent = 大模型 + 工具 + 记忆 + 规划能力。

举个例子。当你跟一个真正的Agent说”帮我订明天北京到上海的机票”，它会这样做：

• 理解：分析你的意图——订机票、时间、北京到上海
• 规划：分解任务——查航班→比价→选时间→下单
• 执行：调用工具——搜索航班、查价格、下单
• 记忆：记住你的偏好——常用航空公司、座位偏好

这和传统AI”你问我答”的模式完全不同。传统AI是被动的，Agent是主动的。

3.2 为什么架构设计很重要？

同样的GPT-4，用不同架构，效果差距巨大。

案例1：客服机器人

公司A用Direct模式，把客服问题直接抛给GPT-4。结果：用户问”怎么退货”，AI说”请查看官网”。用户满意度低。

公司B用ReAct模式，让AI先理解问题→搜索知识库→再回答。结果：AI准确告诉用户退货流程，还主动推荐更优方案。用户满意度高。

案例2：数据分析助手

公司C让AI直接分析数据，给出的结论混乱无条理。

公司D用Plan-and-Execute模式，先让AI规划分析步骤→再逐步执行→最后汇总。结果：分析报告条理清晰，结论有数据支撑。

这两个案例说明：好的架构能把AI效果放大2-3倍。

3.3 7种主流架构一览

经过业界大量实践验证，目前最常用的Agent架构有7种：

四、Direct模式：最简单的Agent

4.1 什么时候用Direct模式

顾名思义，Direct模式就是直接问答。用户输入，AI输出，没有中间的思考、规划、工具调用。

适合的场景：

• 简单的内容生成（写文案、翻译、摘要）
• 一次性的知识问答
• 对上下文没有要求的任务

不适合的场景：

• 多步骤的复杂任务
• 需要查实时信息
• 需要调用外部工具

4.2 原理讲解

Direct模式的工作流程极其简单：

用户提问 → 大模型处理 → 直接输出答案

就像你问一个百科全书，它直接给你答案。没有推理过程，没有工具调用，没有记忆。

4.3 代码实现

下面是Direct模式的Python实现。代码逻辑很简单：创建客户端→调用API→返回结果。

# 导入OpenAI客户端
from openai import OpenAI

# 初始化客户端（会自动从环境变量读取API Key）
client = OpenAI()

def ask(question):
    """Direct模式：简单的一问一答
    
    参数:
        question: 用户的问题
    返回:
        AI的回答
    """
    # 调用GPT-3.5模型
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": question}]
    )
    # 返回AI的回答
    return response.choices[0].message.content

# 测试代码
if __name__ == "__main__":
    result = ask("什么是AI Agent?")
    print(result)

4.4 运行结果

$ python direct.py

AI Agent（人工智能代理）是一种能够感知环境、做出决策并执行行动的智能系统...

4.5 小结

Direct模式最简单，适合一次性任务。但面对复杂任务时，AI容易”跳步”或”遗忘”，需要更高级的架构。

4.6 练习题

基础题：修改代码，添加System Prompt，让AI扮演”资深Python教练”角色。

进阶题：添加错误处理，当API调用失败时给出友好提示而不是崩溃。

五、ReAct模式：推理与行动循环

5.1 为什么需要ReAct

Direct模式的问题在于：面对复杂任务，AI可能推理到一半就忘了，或者跳步导致错误。

比如用户问”我上个月买了A产品，现在降价了能退差价吗？”

Direct模式可能直接回答，但ReAct模式会这样思考：

• 用户问题：买的产品降价了，想退差价
• 需要的政策：退差价政策
• 判断：上个月购买的，是否在退差价时间范围内？
• 行动：查询相关政策
• 回答：基于查到的政策给出答案

这就是ReAct的核心——把推理过程显式化，每一步都可追溯。

5.2 ReAct的核心原理

ReAct = Reasoning + Acting。循环过程：

1. Thought（思考）：AI分析当前情况，决定下一步做什么
2. Action（行动）：执行工具或生成回答
3. Observation（观察）：获取行动结果，作为下一步的输入
4. 循环直到任务完成

5.3 代码实现

相比Direct模式，ReAct增加了推理循环。核心是：让AI自己决定什么时候该调用工具，什么时候该给出最终答案。

from openai import OpenAI

client = OpenAI()

class ReActAgent:
    """ReAct模式Agent：推理+行动循环
    
    核心思想：
    - 让AI显式输出推理过程
    - AI自己决定是否需要调用工具
    - 通过循环实现多步骤任务
    """
    
    def __init__(self):
        # 注册可用的工具
        # key是工具名，value是工具函数
        self.tools = {
            "calculate": lambda x: str(eval(x))  # 计算器
        }
    
    def think(self, messages):
        """让AI思考下一步行动
        
        这里我们通过Prompt指导AI按指定格式输出：
        - 如果要调用工具：输出 Thought + Action + Action Input
        - 如果任务完成：输出 Thought + Final Answer
        """
        prompt = """你是一个ReAct Agent。当前任务是通过思考和行动来完成的。

请分析当前情况，决定下一步：
- 如果需要使用工具，回复格式：
  Thought: [你的思考，为什么需要这个工具]
  Action: [工具名，如 calculate]
  Action Input: [参数]

- 如果任务完成，回复：
  Thought: 任务完成
  Final Answer: [你的最终回答]"""
        
        messages.append({"role": "user", "content": prompt})
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=messages
        )
        return response.choices[0].message.content
    
    def run(self, task, max_loops=5):
        """运行ReAct循环
        
        参数:
            task: 用户任务
            max_loops: 最大循环次数，防止无限循环
        返回:
            最终答案
        """
        messages = [{"role": "user", "content": task}]
        
        for i in range(max_loops):
            # 1. AI思考
            response = self.think(messages)
            messages.append({"role": "assistant", "content": response})
            print(f"[步骤{i+1}] {response[:60]}...")
            
            # 2. 检查是否完成
            if "Final Answer:" in response:
                return response.split("Final Answer:")[1].strip()
            
            # 3. 执行工具
            if "Action:" in response:
                action = response.split("Action:")[1].split("\n")[0].strip()
                if action in self.tools:
                    result = self.tools[action]("123+456")
                    # 把工具结果返回给AI，让它继续推理
                    messages.append({"role": "user", "content": f"Result: {result}"})
        
        return "达到最大循环次数，请检查任务是否合理"

# 测试
if __name__ == "__main__":
    agent = ReActAgent()
    result = agent.run("计算 123+456 的结果")
    print(f"\n最终答案: {result}")

5.4 运行结果

$ python react.py

[步骤1] Thought: 用户想知道123+456的计算结果...
[步骤2] Action: calculate
[步骤3] Result: 579
[步骤4] Thought: 任务完成
Final Answer: 579

最终答案: 579

5.5 ReAct vs Direct对比

5.6 避坑指南

坑1：无限循环

AI可能一直在思考但不出答案。解决方案：设置max_loops限制。

坑2：工具参数错误

AI可能生成无效的工具参数。解决方案：在工具函数里加参数验证。

坑3：Token消耗过大

循环次数太多会导致Token爆炸。解决方案：限制max_loops，定期清理messages。

5.7 小结

ReAct通过显式推理过程，让AI在复杂任务中更可靠。适合需要多步骤、有工具调用的场景。

5.8 练习题

基础题：为ReAct Agent添加”搜索引擎”工具，让它能搜索最新信息。

进阶题：添加对话历史管理，当messages过长时自动摘要或截断。

挑战题：实现”工具选择”功能——当多个工具都适用时，让AI选择最合适的一个。

六、Plan-and-Execute模式：先想后做

6.1 为什么需要先规划

有些任务比较复杂，如果边想边做，很容易顾此失彼、遗漏重要步骤。

比如”帮用户规划一场产品发布会”：需要8个步骤——市场调研→确定受众→撰写内容→设计PPT→邀请嘉宾→媒体宣传→现场执行→后续跟进。哪个先做、哪个后做有依赖关系，如果想到什么做什么，很可能遗漏某个环节。

Plan-and-Execute的思路是：先制定完整计划，再按计划执行。

6.2 原理讲解

这个模式分为两个阶段：

• 阶段1：规划（Plan）：分析任务，分解为可执行的步骤序列。就像做项目计划书。
• 阶段2：执行（Execute）：按照计划步骤逐一执行，遇到问题可以调整后续计划。

相比ReAct的”边想边做”，Plan-and-Execute是”先想清楚再动手”。适合步骤相对固定、可提前规划的任务。

6.3 代码实现

from openai import OpenAI

client = OpenAI()

class PlanExecuteAgent:
    """Plan-and-Execute模式：先规划后执行
    
    核心思想：
    - 第一阶段：规划，把大任务拆成小步骤
    - 第二阶段：执行，按顺序执行每个步骤
    - 适合：步骤相对固定、可提前规划的任务
    """
    
    def plan(self, task):
        """规划阶段：分解任务
        
        让AI将大任务拆成小步骤，返回步骤列表
        """
        prompt = f"""用户任务：{task}

请将这个任务分解成步骤列表。格式：
1. [第一步要做什么]
2. [第二步要做什么]
3. ...

要求：
- 每个步骤是一个独立的子任务
- 有明确的目标
- 步骤之间有合理的先后顺序"""
        
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    
    def execute_step(self, step):
        """执行阶段：执行单个步骤
        
        对每个步骤单独调用AI处理
        """
        prompt = f"执行以下步骤，输出结果：\n{step}"
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    
    def run(self, task):
        """运行Agent"""
        print(f"=== 规划阶段 ===")
        plan_text = self.plan(task)
        print(plan_text)
        
        # 解析步骤（按数字开头的行）
        steps = [line.strip() for line in plan_text.split("\n") 
                 if line.strip() and line.strip()[0].isdigit()]
        
        print(f"\n=== 执行阶段（共{len(steps)}步）===")
        results = []
        for i, step in enumerate(steps, 1):
            print(f"\n[步骤 {i}] {step}")
            result = self.execute_step(step)
            print(f"结果: {result[:80]}...")
            results.append(result)
        
        return results

# 测试
if __name__ == "__main__":
    agent = PlanExecuteAgent()
    agent.run("分析竞品A和B的差异")

6.4 运行结果

$ python plan_execute.py

=== 规划阶段 ===
1. 收集竞品A和B的基本信息
2. 对比分析产品功能差异
3. 对比价格策略和市场表现
4. 汇总分析报告

=== 执行阶段（共4步）===

[步骤 1] 收集竞品A和B的基本信息
结果: 竞品A是... [详细结果]

[步骤 2] 对比分析产品功能差异
结果: 功能维度对比分析...

6.5 ReAct vs Plan-and-Execute

6.6 小结

Plan-and-Execute适合复杂长周期任务，通过先规划再执行避免遗漏。但灵活性不如ReAct。

6.7 练习题

基础题：修改代码，在执行每步后检查结果是否符合预期，不符合就调整后续计划。

进阶题：添加并行执行功能——如果某些步骤之间没有依赖，同时执行它们。

挑战题：实现”执行回滚”——如果某步失败，自动回退到上一步的状态。

七、Tool Use模式：让AI连接真实世界

7.1 为什么需要工具

大模型有两大局限：

• 知识有截止日期：不知道最新发生的事
• 无法执行操作：不能发邮件、操作数据库

工具就是Agent的”双手”，让它能真正影响现实世界。有了工具，Agent可以：

• 查天气、搜新闻（获取实时信息）
• 发邮件、管日程（执行实际操作）
• 读写数据库、调用API（操作外部系统）

7.2 工具设计原则

好的工具设计要遵循4个原则：

1. 单一职责：每个工具只做一件事。比如”查天气”和”发邮件”应该是两个工具，不是一个”万能助手”。

2. 清晰命名：工具名要能表达功能。比如get_weather、send_email，而不是func1、func2。

3. 参数验证：工具内部要验证参数合法性。邮箱格式不对、数量超限等要提前报错。

4. 错误处理：执行可能失败，要有友好的错误提示。

7.3 代码实现

import re

class ToolUseAgent:
    """Tool Use模式Agent
    
    核心思想：
    - 给AI提供一组工具
    - AI根据用户问题选择合适的工具
    - 扩展AI的能力边界
    """
    
    def __init__(self):
        # 注册工具
        # 工具名 -> 工具函数
        self.tools = {
            "search": self.search,
            "weather": self.get_weather,
            "calculate": self.calculate
        }
    
    def search(self, query):
        """搜索工具（模拟）
        
        实际应用中，这里会调用真实的搜索API
        """
        return f"关于'{query}'的搜索结果..."
    
    def get_weather(self, city):
        """天气查询工具（模拟）
        
        实际应用中，这里会调用天气API
        """
        return f"{city}今天晴，25°C，适合户外活动"
    
    def calculate(self, expr):
        """计算器工具
        
        使用eval进行简单计算
        实际应用中建议用更安全的计算库
        """
        try:
            return str(eval(expr))
        except:
            return "计算错误，请检查表达式是否合法"
    
    def call_tool(self, tool_name, params):
        """调用工具的统一入口"""
        if tool_name in self.tools:
            return self.tools[tool_name](params)
        return "未知工具，请检查工具名是否正确"
    
    def chat(self, user_input):
        """对话入口：解析意图并调用工具
        
        这里用简单的关键词匹配判断意图
        实际应用中可以用更智能的意图识别
        """
        # 意图识别 + 工具调用
        if "天气" in user_input:
            return self.call_tool("weather", "北京")
        
        if "计算" in user_input or "+" in user_input or "*" in user_input:
            # 提取数学表达式
            expr = re.search(r'[\d+\-*/()]+', user_input)
            if expr:
                return self.call_tool("calculate", expr.group())
        
        if "搜" in user_input or "查" in user_input:
            # 提取搜索关键词
            return self.call_tool("search", user_input[2:] if len(user_input) > 2 else user_input)
        
        return "我不知道怎么处理这个问题"

# 测试
if __name__ == "__main__":
    agent = ToolUseAgent()
    
    print("=== Tool Use Agent 测试 ===")
    print(f"天气: {agent.chat('北京天气怎么样')}")
    print(f"计算: {agent.chat('计算 123+456')}")
    print(f"搜索: {agent.chat('搜索AI最新进展')}")

7.4 运行结果

$ python tool_use.py

=== Tool Use Agent 测试 ===
天气: 北京今天晴，25°C，适合户外活动
计算: 579
搜索: 关于'AI最新进展'的搜索结果...

7.5 小结

Tool Use扩展了AI的能力边界，让它能获取实时信息、执行实际操作。实际应用中，建议使用OpenAI的Function Calling API实现更智能的工具调用。

7.6 练习题

基础题：添加”发送邮件”工具，支持收件人、主题、正文参数，并添加格式验证。

进阶题：接入真实的搜索API（如百度搜索）替代模拟函数。

挑战题：实现”工具注册”功能，让用户可以动态添加新工具。

八、多Agent协作模式

8.1 什么时候需要多Agent

单Agent能力有上限。遇到复杂任务时，可以多个专业Agent协作。

适合多Agent的场景：

• 任务需要多种专业知识（技术+客服+销售）
• 可以并行处理的独立子任务
• 需要多角度分析的问题

8.2 Orchestra模式：有协调者的协作

最常用的多Agent模式。有个协调者Agent负责任务分配，其他Agent执行具体任务。

就像一个项目团队：项目经理协调，程序员做开发，设计师做UI。

原理：

• 协调者接收任务，判断类型
• 分配给合适的专业Agent
• 专业Agent执行任务
• 结果返回协调者汇总

代码实现：

class Agent:
    """专业Agent：负责执行具体任务"""
    
    def __init__(self, name, specialty):
        self.name = name          # Agent名称
        self.specialty = specialty  # 专业领域
    
    def work(self, task):
        """执行分配的任务"""
        # 模拟处理
        return f"[{self.name}] 完成: {task[:30]}..."

class Orchestra:
    """多Agent协作：协调者模式
    
    核心思想：
    - 有一个协调者Agent
    - 协调者负责任务分配
    - 各专业Agent执行具体任务
    - 适合：任务类型明确、可分类的场景
    """
    
    def __init__(self):
        # 创建专业Agent池
        self.agents = {
            "researcher": Agent("研究员", "信息收集"),
            "writer": Agent("文案师", "内容创作"),
            "reviewer": Agent("审核员", "质量把控")
        }
    
    def assign(self, task):
        """根据任务类型分配Agent
        
        实际应用中可以用AI做更智能的路由
        """
        if any(k in task for k in ["分析", "调研", "收集", "查"]):
            return "researcher"
        if any(k in task for k in ["写", "创作", "生成"]):
            return "writer"
        if any(k in task for k in ["审核", "检查", "修改"]):
            return "reviewer"
        return "researcher"  # 默认分配给研究员
    
    def work(self, task):
        """协作完成任务"""
        print(f"🎯 收到任务: {task}")
        
        # 1. 分配任务
        agent_type = self.assign(task)
        print(f"📢 分配给: {self.agents[agent_type].name}")
        
        # 2. 执行任务
        result = self.agents[agent_type].work(task)
        
        return result

# 测试
if __name__ == "__main__":
    orchestra = Orchestra()
    
    print(orchestra.work("分析竞品A的市场定位"))
    print()
    print(orchestra.work("写一篇AI Agent的文章"))

8.3 Hierarchical模式：层级治理

更复杂的多Agent模式。多层级Agent结构，上层管规划，下层管执行。

就像公司的组织架构：CEO→部门经理→员工。

原理：

• Manager（经理）：接收任务，做全局规划
• Supervisor（主管）：监督执行，协调问题
• Worker（员工）：执行具体任务

代码实现：

class Worker:
    """执行层Agent"""
    def __init__(self, name, skills):
        self.name = name
        self.skills = skills  # 能处理的技能列表
    
    def can_handle(self, task):
        """判断是否能处理这个任务"""
        return any(s in task for s in self.skills)
    
    def execute(self, task):
        """执行任务"""
        return f"[{self.name}] 执行: {task[:30}]..."

class Supervisor:
    """监督层Agent：分配任务给Worker"""
    def __init__(self):
        self.workers = [
            Worker("技术员", ["代码", "bug", "技术"]),
            Worker("销售员", ["价格", "报价", "销售"]),
            Worker("客服", ["问题", "咨询", "帮助"])
        ]
    
    def assign(self, task):
        """分配任务给合适的Worker"""
        for worker in self.workers:
            if worker.can_handle(task):
                return worker
        return self.workers[0]  # 默认返回第一个
    
    def supervise(self, task):
        """监督执行"""
        worker = self.assign(task)
        return worker.execute(task)

class Manager:
    """管理层Agent：全局规划"""
    def __init__(self):
        self.supervisor = Supervisor()
    
    def plan(self, task):
        """制定执行计划"""
        print(f"[Manager] 分析任务: {task}")
        # 简化处理：直接分配
        return task.split("和")
    
    def work(self, task):
        """管理工作流程"""
        steps = self.plan(task)
        print(f"[Manager] 分解为 {len(steps)} 个子任务")
        
        results = []
        for i, step in enumerate(steps, 1):
            print(f"\n[子任务 {i}]")
            result = self.supervisor.supervise(step.strip())
            results.append(result)
        
        return results

# 测试
if __name__ == "__main__":
    manager = Manager()
    results = manager.work("用户问代码bug和价格问题")
    print(f"\n✅ 完成 {len(results)} 个子任务")

8.4 HiveMind模式：去中心化协作

没有中心协调者，所有Agent完全对等。通过投票或共识做决策。

就像头脑风暴会议，大家平等讨论，最后投票决定。

原理：

• 每个Agent独立思考
• 分享各自观点
• 通过讨论或投票达成共识

适用场景：创意生成、多角度分析、复杂决策。

8.5 模式对比

8.6 小结

多Agent协作适合复杂系统。选择哪种模式取决于任务特性和团队规模。

8.7 练习题

基础题：扩展Orchestra，支持多Agent顺序协作（A→B→C）。

进阶题：为Hierarchical添加”超时机制”——Worker处理超时则切换。

挑战题：实现HiveMind的投票共识功能。

九、综合实战：构建你的第一个Agent系统

9.1 需求分析

我们综合运用以上知识，构建一个能：

• 回答问题
• 搜索信息
• 管理记忆

的AI助手。

9.2 系统架构

• 入口：接收用户问题
• 理解：识别意图
• 执行：调用相应工具
• 记忆：保存对话历史

9.3 完整代码

from openai import OpenAI
import re

client = OpenAI()

class Assistant:
    """AI助手：综合实战
    
    综合了Direct、Tool Use、多Agent等模式
    能处理简单对话，也能调用工具
    """
    
    def __init__(self):
        # 对话历史
        self.history = []
        
        # 注册工具
        self.tools = {
            "search": lambda q: f"'{q}'的搜索结果...",
            "weather": lambda c: f"{c}今天晴，25°C",
            "calculate": lambda e: str(eval(e))
        }
    
    def understand(self, user_input):
        """理解用户意图，返回(意图, 参数)"""
        if any(k in user_input for k in ["天气"]):
            return "weather", "北京"
        
        if any(k in user_input for k in ["计算", "+", "*"]):
            expr = re.search(r'[\d+\-*/]+', user_input)
            return "calculate", expr.group() if expr else None
        
        if any(k in user_input for k in ["搜", "查"]):
            return "search", user_input[2:]
        
        return None, None
    
    def chat(self, user_input):
        """处理对话"""
        print(f"👤 用户: {user_input}")
        self.history.append(user_input)
        
        # 1. 理解意图
        intent, param = self.understand(user_input)
        
        # 2. 执行
        if intent:
            result = self.tools[intent](param)
        else:
            # 没有匹配的工具，用通用对话
            resp = client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": user_input}]
            )
            result = resp.choices[0].message.content
        
        print(f"🤖 助手: {result}")
        self.history.append(result)
        
        return result
    
    def run_demo(self):
        """演示"""
        questions = [
            "你好",
            "北京天气怎么样",
            "计算 123+456",
            "你会做什么"
        ]
        
        print("=== AI助手演示 ===\n")
        for q in questions:
            self.chat(q)
            print()

# 运行
if __name__ == "__main__":
    assistant = Assistant()
    assistant.run_demo()

9.4 运行结果

$ python assistant.py

=== AI助手演示 ===

👤 用户: 你好
🤖 助手: 你好！有什么可以帮你的？

👤 用户: 北京天气怎么样
🤖 助手: 北京今天晴，25°C

👤 用户: 计算 123+456
🤖 助手: 579

9.5 扩展方向

这个基础版本可以扩展：

• 接入真实搜索API
• 添加持久化记忆（存数据库）
• 支持多轮上下文
• 添加更多工具（发邮件、管日程）

十、总结与练习

10.1 要点回顾

• Agent = 大模型 + 工具 + 记忆 + 规划
• Direct：最简单，一问一答，适合简单任务
• ReAct：推理+行动循环，适合多步骤任务
• Plan-and-Execute：先规划后执行，适合复杂长任务
• Tool Use：工具扩展，连接真实世界
• 多Agent协作：Orchestra/Hierarchical/HiveMind

10.2 选型指南

10.3 避坑总结

• 无限循环：设置max_loops限制
• Token爆炸：定期清理或摘要历史
• 工具参数错误：添加参数验证
• 架构选择错误：根据任务特性选合适的架构

10.4 延伸阅读

• LangChain：一个用于构建Agent的流行框架，封装了很多常用模式
• AutoGen：微软开源的多Agent框架，支持Agent间对话协作
• ReAct论文：SYcHOLOGICAL REASONING

10.5 课后练习

基础题：为ReAct Agent添加”搜索”工具。

进阶题：实现Plan-and-Execute的动态计划调整。

挑战题：设计一个多Agent客服系统（接待+咨询+技术）。