01.2 — Agent 架构模式
定位: 理解 AI Agent 的三种经典架构模式——从最简单的 Self-Reflection 到最复杂的 Multi-agent 协作 面试高频度: ⭐⭐⭐⭐⭐ 考查方式: 模式辨析（什么时候用什么模式）、设计题（设计一个 XX 场景的 Agent）、架构对比
一、这是什么？为什么需要它？
是什么
Agent 架构模式 是构建 AI Agent 的"套路"——经过验证的、可复用的 Agent 系统设计方案。不同的模式适用于不同的任务复杂度。
为什么需要架构模式？
没有架构模式之前，构建 Agent 就像"让 LLM 自由发挥"：
❌ 没有模式的 Agent：
- 同一个问题可能走完全不同的路径
- 无法保证行为的一致性
- 遇到复杂任务就"迷路"
- 难以 debug、难以优化
✅ 有模式的 Agent：
- 行为可预测、可控制
- 复杂度可以渐进式增长
- 每个模式解决特定类型的问题
- 团队沟通有共同语言核心洞察：架构模式就是给 Agent 的"思考框架"——不限制它的能力，但给它一个结构化的思维路径。
二、原理拆解
2.1 三大经典模式总览
| 模式 | 核心思想 | 复杂度 | 何时使用 |
|---|---|---|---|
| Reflection | Agent 自己检查自己的输出 | ⭐ | 需要质量把控的简单任务 |
| Tool Use | Agent 调用外部工具完成任务 | ⭐⭐⭐ | 需要与外部世界交互 |
| ReAct | 推理 + 行动交替进行 | ⭐⭐⭐⭐⭐ | 需要深度推理+多步骤的复杂任务 |
2.2 模式一：Reflection（自我反思）
核心思想：Agent 生成输出后，自我 review 并改进。
┌──────────────────────────────────────────────┐
│ Reflection 架构 │
│ │
│ 用户请求 │
│ │ │
│ ▼ │
│ ┌──────────┐ 生成 ┌────────────┐ │
│ │ Actor │───────→│ 初始输出 │ │
│ │ (生成) │ └──────┬─────┘ │
│ └──────────┘ │ │
│ ▼ │
│ ┌──────────┐ 评价 ┌────────────┐ │
│ │ Critic │───────→│ 质量评价 │ │
│ │ (评价) │ └──────┬─────┘ │
│ └──────────┘ │ │
│ ┌─────┴─────┐ │
│ │ │ │
│ ▼ ▼ │
│ ┌────────┐ ┌────────┐ │
│ │ 合格 ✅ │ │ 不合格 │ │
│ │ 输出 │ │ 重新生成│ │
│ └────────┘ └────────┘ │
│ │
└──────────────────────────────────────────────┘实现要点：
- Actor 和 Critic 可以是同一个 LLM（不同 prompt）
- 循环次数需要限制（通常 2-3 轮）
- 质量评价标准要具体（不要"看起来对不对"，要"checklist 式"）
python
# 最小 Reflection 实现
def agent_with_reflection(task: str, max_rounds: int = 3):
for round in range(max_rounds):
# Actor：生成/改进
output = llm.call(f"生成：{task}\n之前反馈：{feedback if round > 0 else '无'}")
# Critic：评价
critique = llm.call(f"检查以下输出是否满足要求：{output}\n问题：1. 完整性？2. 正确性？")
if "完全正确" in critique:
return output
feedback = critique
return output # 达到最大轮次后返回最后一次结果实战场景：
- 代码生成 + 代码审查
- 文章写作 + 质量改进
- SQL 生成 + 验证
2.3 模式二：Tool Use（工具使用）
核心思想：LLM 输出结构化工具调用指令，系统执行并返回结果。
┌─────────────────────────────────────────────────────┐
│ Tool Use 架构 │
│ │
│ 用户请求 │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ LLM 推理引擎 │ │
│ │ │ │
│ │ 我需要查询数据库 → 调用 query_db() │ │
│ │ 需要计算结果 → 调用 calculator() │ │
│ └──────────────┬──────────────────────┘ │
│ │ tool_call │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ 工具注册中心 / Runtime │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────┐ │ │
│ │ │ search() │ │ calc() │ │ db() │ │ ... │
│ │ └──────────┘ └──────────┘ └──────┘ │ │
│ └──────────────┬──────────────────────┘ │
│ │ result │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ LLM 整合结果 → 生成最终回答 │ │
│ └─────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────┘关键设计决策：
| 决策 | 选项 | 说明 |
|---|---|---|
| 工具如何被发现？ | 预注册 / 动态发现 | 预注册更可靠，动态发现更灵活 |
| 工具调用是同步/异步？ | 同步 / 异步 | 耗时工具用异步，避免阻塞 |
| 工具执行出错怎么办？ | 重试 / 换工具 / 报错 | 优雅降级优于直接失败 |
| 谁来选择工具？ | LLM / 路由规则 | LLM 更灵活，路由更可控 |
python
# 最小 Tool Use 实现
TOOLS = {
"search": lambda q: f"搜索结果: {q}的相关信息",
"calculate": lambda expr: eval(expr),
"current_time": lambda: "2026-07-16 12:00:00"
}
def agent_with_tools(user_input: str):
messages = [{"role": "user", "content": user_input}]
while True:
response = llm.call(messages, tools=list(TOOLS.keys()))
if response.has_tool_call():
# 执行工具
for tool_call in response.tool_calls:
result = TOOLS[tool_call.name](**tool_call.args)
messages.append({"role": "tool", "content": result})
else:
return response.content # 纯文本回答2.4 模式三：ReAct（推理 + 行动）
核心思想：推理(Thought) 和行动(Action) 交替进行，每一步的观察(Observation) 作为下一步推理的输入。
┌──────────────────────────────────────────────────────────┐
│ ReAct 循环 │
│ │
│ Question: 2025年巴黎奥运会中国获得了多少金牌？ │
│ │
│ ┌─ Thought ────────────────────────────────────────┐ │
│ │ 我需要查找 2025 年巴黎奥运会的金牌数据。 │ │
│ │ 先搜索"2025 Paris Olympics China gold medals" │ │
│ └──────────────────┬──────────────────────────────┘ │
│ │ │
│ ┌─ Action ─────────▼──────────────────────────────┐ │
│ │ search("2025 Paris Olympics China gold medals") │ │
│ └──────────────────┬──────────────────────────────┘ │
│ │ │
│ ┌─ Observation ────▼──────────────────────────────┐ │
│ │ 中国在 2025 年巴黎奥运会获得 40 枚金牌 │ │
│ └──────────────────┬──────────────────────────────┘ │
│ │ │
│ ┌─ Thought ────────▼──────────────────────────────┐ │
│ │ 找到数据了。不过我需要验证一下这个数字的准确性。 │ │
│ │ 再搜索其他来源确认。 │ │
│ └──────────────────┬──────────────────────────────┘ │
│ │ │
│ ┌─ Action ─────────▼──────────────────────────────┐ │
│ │ search("2025 Paris Olympics medal table China") │ │
│ └──────────────────┬──────────────────────────────┘ │
│ │ │
│ ┌─ Observation ────▼──────────────────────────────┐ │
│ │ 多源确认：中国 40 金，排名第一 │ │
│ └──────────────────┬──────────────────────────────┘ │
│ │ │
│ ┌─ Final Answer ───▼──────────────────────────────┐ │
│ │ 中国在 2025 年巴黎奥运会获得 40 枚金牌，排名第一 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────┘ReAct vs Tool Use 的关键区别：
| 维度 | Tool Use | ReAct |
|---|---|---|
| 推理是否外显 | 不强制 | 强制——每一步都有 Thought |
| 行动序列 | 可能一次调多个工具 | 一步一步交替 |
| 可解释性 | 中 | 高——可见推理过程 |
| 适用场景 | 直接的工具调用 | 需要推理的复杂任务 |
| 代表框架 | OpenAI Functions | LangGraph ReAct Agent |
python
# 最小 ReAct 实现
def react_agent(question: str, max_steps: int = 5):
prompt = f"""你是一个 ReAct Agent。请交替进行：
Thought: 思考下一步做什么
Action: 调用工具（格式: 工具名(参数)）
Observation: 工具返回的结果
完成时输出: Final Answer: 你的答案
可用工具: search(query), calculate(expr)
问题: {question}"""
for step in range(max_steps):
response = llm.call(prompt)
if "Final Answer:" in response:
return response.split("Final Answer:")[1].strip()
if "Action:" in response:
action = parse_action(response)
result = execute_tool(action)
prompt += f"\nObservation: {result}"
return "达到最大步骤限制"三、图解全景
┌────────────────────────────────────────────────────────────┐
│ Agent 架构模式选择决策树 │
│ │
│ 任务开始 │
│ │ │
│ ▼ │
│ 需要外部工具/信息吗？ │
│ ├── 否 ──→ Reflection 模式足够吗？ │
│ │ ├── 是 ─→ 🟢 Reflection │
│ │ └── 否 ─→ 需要更复杂的架构（见下文） │
│ │ │
│ └── 是 ──→ 任务需要多步推理吗？ │
│ ├── 否 ─→ 🟢 Tool Use │
│ └── 是 ─→ 🟢 ReAct │
│ │
│ 复杂度递进: │
│ Reflection → Tool Use → ReAct → Multi-agent │
│ (本笔记) (本笔记) (本笔记) (见板块5) │
│ │
└────────────────────────────────────────────────────────────┘四、实战验证
4.1 用 Python 对比三种模式
python
# === 场景：分析销售数据并生成报告 ===
# Reflection 模式：先生成再自我改进
def reflection_approach(data: str):
draft = llm.call(f"根据数据生成报告：{data}")
review = llm.call(f"审查并改进这份报告：{draft}\n标准：数据准确、结构清晰")
return review
# Tool Use 模式：调用分析工具
def tool_use_approach(data: str):
stats = analyze_tool(data) # 调用分析工具
chart = chart_tool(stats) # 调用制图工具
return llm.call(f"基于分析结果{stats}和图表{chart}生成报告")
# ReAct 模式：边推理边操作
def react_approach(query: str):
# Thought: 需要先分析数据趋势
# Action: analyze_tool(data)
# Observation: 发现 Q3 销售额下降
# Thought: 需要查找原因
# Action: search("Q3 sales decline reason")
# Observation: 发现是因为产品线调整
# Final: 综合分析报告
pass4.2 模式选择决策验证
python
# 通过任务特征验证模式选择是否正确
test_cases = [
{
"task": "写一篇 500 字的文章",
"best_mode": "Reflection",
"reason": "不需要外部信息，重点在质量改进"
},
{
"task": "查询北京上海之间的高铁班次",
"best_mode": "Tool Use",
"reason": "需要实时数据，但不需要多步推理"
},
{
"task": "比较三种云服务商的成本并推荐最优方案",
"best_mode": "ReAct",
"reason": "需要多步查询+推理+比较"
}
]
for case in test_cases:
print(f"任务: {case['task']} → 推荐: {case['best_mode']} ({case['reason']})")五、面试视角
| 追问 | 答案要点 |
|---|---|
| 三种架构模式的区别和选择标准？ | Reflection 用于质量改进（输出自检），Tool Use 用于工具调用（一步到位），ReAct 用于复杂推理（思考行动交替）。选择看：是否需要外部信息 + 是否需要多步推理 |
| ReAct 和 Tool Use 的本质区别？ | ReAct 强制 Thought 步骤，推理过程外显可追踪；Tool Use 可以一次调用多个工具，不强制中间推理。ReAct 更"慢但可靠"，Tool Use 更"快但浅" |
| Reflection 的 Actor-Critic 可以用同一个 LLM 吗？ | 可以，但需要用不同的 prompt。同一个 LLM 做 Critic 时容易"对自己的输出过于自信"——建议用不同的 temperature（Actor 高、Critic 低） |
| ReAct 如何防止无限循环？ | 最大步数限制（hard stop）、时间超时、相似状态检测（如果连续 3 步 Thought 相似，强制终止）、确定性工具使用（避免 LLM 反复调用同一工具） |
| 模式可以组合吗？ | 可以。实际生产系统中通常是组合使用：ReAct 循环中每个 Action 步骤内部可能用 Reflection 来提高工具调用的质量 |
| 如何评估 Agent 架构选择的合理性？ | 评估维度：任务完成率、平均步数、工具调用准确率、用户满意度。核心指标是"用最低复杂度解决了问题" |
📚 相关链接
- **什么是AI Agent** — Agent 定义与核心概念
- **感知-行动循环** — 感知-行动循环的深入解析
- **CoT 与 ReAct** — ReAct 模式的深入展开
- **多智能体系统** — 第四种架构模式的深入
- ← 返回 **Agent基础索引**