【高级应用】Day1:AI Agent架构设计模式–7种主流设计模式深度解析
章节导语
如果你用同一个AI模型，装在不同架构里，效果可能差好几倍。就像同样的食材，在不同厨师手里，能做出完全不同的菜。
这就是Agent架构设计的意义。大模型是”大脑”，架构是”神经系统”——决定信息怎么传递、决策怎么做、行动怎么执行。
本文会带你从0开始，理解7种主流Agent架构模式。不只是讲概念，每种架构都有完整的代码实现和运行结果，让你真正学懂。
一、前置说明
1.1 本文学习路径
建议按以下顺序学习：
| 阶段 | 架构 | 难度 |
|---|---|---|
| 入门 | Direct模式 | ⭐ |
| 基础 | ReAct模式 | ⭐⭐ |
| 进阶 | Plan-and-Execute、Tool Use | ⭐⭐⭐ |
| 高级 | 多Agent协作模式 | ⭐⭐⭐⭐ |
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-dotenv2.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模式 | 一问一答，最简单 | ⭐ |
| ReAct模式 | 推理+行动循环 | ⭐⭐ |
| Plan-and-Execute | 先规划后执行 | ⭐⭐ |
| Tool Use | 调用外部工具 | ⭐⭐ |
| Agent Orchestra | 多Agent编排 | ⭐⭐⭐ |
| Hierarchical | 层级治理 | ⭐⭐⭐⭐ |
| HiveMind | 去中心化协作 | ⭐⭐⭐⭐⭐ |
四、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。循环过程：
- Thought（思考）：AI分析当前情况，决定下一步做什么
- Action（行动）：执行工具或生成回答
- Observation（观察）：获取行动结果，作为下一步的输入
- 循环直到任务完成
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
最终答案: 5795.5 ReAct vs Direct对比
| 方面 | Direct | ReAct |
|---|---|---|
| 复杂度 | 低 | 中 |
| 推理过程 | 隐式（AI自己知道但不说） | 显式（输出推理步骤） |
| 多步骤任务 | ❌ 容易跳步或遗忘 | ✅ 可追溯每步 |
| 工具调用 | ❌ 不支持 | ✅ 支持 |
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
| 场景 | 推荐 |
|---|---|
| 步骤相对固定、可提前规划 | Plan-and-Execute |
| 需要根据上一步结果动态调整 | ReAct |
| 需要快速响应 | ReAct（规划开销小） |
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 模式对比
| 模式 | 协调方式 | 复杂度 | 适用场景 |
|---|---|---|---|
| Orchestra | 协调者分配 | 中 | 任务明确、可分类 |
| Hierarchical | 层级管理 | 高 | 复杂业务流程 |
| HiveMind | 投票共识 | 高 | 创意/分析类 |
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
🤖 助手: 5799.5 扩展方向
这个基础版本可以扩展：
- 接入真实搜索API
- 添加持久化记忆（存数据库）
- 支持多轮上下文
- 添加更多工具（发邮件、管日程）
十、总结与练习
10.1 要点回顾
- Agent = 大模型 + 工具 + 记忆 + 规划
- Direct：最简单，一问一答，适合简单任务
- ReAct：推理+行动循环，适合多步骤任务
- Plan-and-Execute：先规划后执行，适合复杂长任务
- Tool Use：工具扩展，连接真实世界
- 多Agent协作：Orchestra/Hierarchical/HiveMind
10.2 选型指南
| 任务 | 推荐架构 |
|---|---|
| 简单问答 | Direct |
| 多步骤任务 | ReAct |
| 复杂长周期 | Plan-and-Execute |
| 需要工具 | Tool Use |
| 多领域协作 | Orchestra |
10.3 避坑总结
- 无限循环：设置max_loops限制
- Token爆炸：定期清理或摘要历史
- 工具参数错误：添加参数验证
- 架构选择错误：根据任务特性选合适的架构
10.4 延伸阅读
- LangChain：一个用于构建Agent的流行框架，封装了很多常用模式
- AutoGen：微软开源的多Agent框架，支持Agent间对话协作
- ReAct论文：SYcHOLOGICAL REASONING
10.5 课后练习
基础题：为ReAct Agent添加”搜索”工具。
进阶题：实现Plan-and-Execute的动态计划调整。
挑战题：设计一个多Agent客服系统（接待+咨询+技术）。
