智能体设计范式与实现模式详解
一、智能体设计范式概述
1.1 范式定义
设计范式（Design Paradigm）：智能体系统设计中经过验证的、可复用的解决方案框架，用于解决特定类型的问题。
1.2 范式分类体系
| 维度 | 分类 | 说明 |
|---|---|---|
| 决策方式 | 反应式、慎思式、混合式 | 智能体如何做出决策 |
| 协作模式 | 单智能体、多智能体、分层智能体 | 智能体之间的关系 |
| 学习能力 | 无学习、监督学习、强化学习、自监督学习 | 智能体如何获取知识 |
| 架构风格 | 管道式、事件驱动、微服务、分层架构 | 系统组织方式 |
1.3 主流设计范式
| 范式 | 核心思想 | 代表框架 | 适用场景 |
|---|---|---|---|
| ReAct | 推理 + 行动交替进行 | LangChain, AutoGPT | 动态环境、工具调用 |
| Plan-and-Execute | 先规划后执行 | LlamaIndex, CrewAI | 复杂任务分解 |
| Reflexion | 自我反思优化 | Reflexion Framework | 需要迭代改进的任务 |
| Tree of Thought | 树状思维探索 | ToT Framework | 需要深度思考的问题 |
| Hierarchical | 分层决策架构 | MetaGPT | 大型项目管理 |
| Role-playing | 角色扮演协作 | ChatDev, MetaGPT | 团队协作模拟 |
二、ReAct 范式
2.1 核心思想
ReAct（Reasoning + Acting）：将推理和行动交替进行，智能体在思考过程中决定是否需要调用工具，然后根据工具结果继续推理。
循环流程：
思考（Reasoning）→ 行动（Action）→ 观察（Observation）→ 思考（Reasoning）→ ...2.2 架构图
┌─────────────────────────────────────────────────────────────┐
│ ReAct 循环 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 用户输入 │
│ │ │
│ ↓ │
│ ┌──────────────┐ │
│ │ Reasoning │ ←─────────────────────────────┐ │
│ │ (思考) │ │ │
│ └──────┬───────┘ │ │
│ │ │ │
│ ↓ │ │
│ ┌──────────────┐ │ │
│ │ Action │ │ │
│ │ (行动) │ │ │
│ └──────┬───────┘ │ │
│ │ │ │
│ ↓ │ │
│ ┌──────────────┐ │ │
│ │ Observation │──────────────────────────────┘ │
│ │ (观察) │ │
│ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘2.3 代码实现
python
class ReActAgent:
def __init__(self, llm, tools):
self.llm = llm
self.tools = tools
self.max_steps = 10
def run(self, task):
thoughts = []
actions = []
observations = []
for step in range(self.max_steps):
# 1. 思考阶段
thought = self._reason(task, thoughts, actions, observations)
thoughts.append(thought)
# 2. 判断是否完成
if self._is_complete(thought):
return self._summarize(thoughts, actions, observations)
# 3. 行动阶段
action = self._decide_action(thought)
actions.append(action)
# 4. 执行工具
observation = self._execute_action(action)
observations.append(observation)
return "任务未完成，已达到最大步数限制"
def _reason(self, task, thoughts, actions, observations):
"""生成思考内容"""
history = "\n".join([
f"步骤{i+1}: 思考={thoughts[i]}, 行动={actions[i]}, 观察={observations[i]}"
for i in range(len(thoughts))
])
prompt = f"""
任务：{task}
历史记录：
{history}
可用工具：{self.tools.describe()}
请思考下一步应该做什么，使用以下格式：
思考：[你的思考内容]
行动：[工具名称]或[完成]
参数：[工具参数，如果是完成则为空]
"""
return self.llm.generate(prompt)
def _is_complete(self, thought):
"""判断任务是否完成"""
return "完成" in thought or "总结" in thought
def _decide_action(self, thought):
"""解析行动"""
# 简单解析，实际应用中需要更复杂的解析逻辑
lines = thought.split("\n")
action_line = [l for l in lines if l.startswith("行动：")][0]
action = action_line.replace("行动：", "").strip()
return action
def _execute_action(self, action):
"""执行工具调用"""
if action in self.tools.get_names():
return self.tools.call(action)
return f"无法执行行动：{action}"
def _summarize(self, thoughts, actions, observations):
"""总结结果"""
prompt = f"""
请总结以下任务的执行过程和结果：
执行记录：
{list(zip(thoughts, actions, observations))}
请给出最终总结。
"""
return self.llm.generate(prompt)2.4 适用场景
| 场景 | 说明 |
|---|---|
| 动态环境交互 | 需要根据环境变化做出决策 |
| 多步工具调用 | 需要连续调用多个工具 |
| 信息收集任务 | 需要逐步收集信息 |
| 探索性任务 | 需要试错和调整策略 |
三、Plan-and-Execute 范式
3.1 核心思想
Plan-and-Execute（规划-执行）：先对任务进行全局规划，生成详细的执行步骤，然后按步骤依次执行。
两阶段流程：
- 规划阶段：分析任务，生成步骤列表
- 执行阶段：按步骤执行，必要时调整
3.2 架构图
┌─────────────────────────────────────────────────────────────┐
│ Plan-and-Execute │
├─────────────────────────────────────────────────────────────┤
│ │
│ 用户输入 │
│ │ │
│ ↓ │
│ ┌──────────────┐ │
│ │ Planner │ ←─── 反馈调整 ───────────────┐ │
│ │ (规划器) │ │ │
│ └──────┬───────┘ │ │
│ │ │ │
│ ↓ │ │
│ ┌──────────────┐ │ │
│ │ Plan │ │ │
│ │ (计划) │ │ │
│ └──────┬───────┘ │ │
│ │ │ │
│ ↓ │ │
│ ┌──────────────┐ │ │
│ │ Executor │─────────── 执行结果 ─────────┘ │
│ │ (执行器) │ │
│ └──────┬───────┘ │
│ │ │
│ ↓ │
│ 最终结果 │
│ │
└─────────────────────────────────────────────────────────────┘3.3 代码实现
python
class PlanAndExecuteAgent:
def __init__(self, planner_llm, executor_llm, tools):
self.planner = planner_llm
self.executor = executor_llm
self.tools = tools
self.max_retries = 3
def run(self, task):
# 1. 生成计划
plan = self._generate_plan(task)
print(f"生成计划：{plan}")
# 2. 执行计划
results = []
for i, step in enumerate(plan["steps"]):
print(f"\n执行步骤 {i+1}/{len(plan['steps'])}: {step['description']}")
try:
result = self._execute_step(step, results)
results.append({"step": step, "result": result, "status": "success"})
except Exception as e:
results.append({"step": step, "result": str(e), "status": "failed"})
# 尝试调整计划
if self.max_retries > 0:
plan = self._adjust_plan(task, plan, results)
self.max_retries -= 1
# 3. 总结
return self._summarize(task, plan, results)
def _generate_plan(self, task):
prompt = f"""
请为以下任务生成详细的执行计划：
任务：{task}
可用工具：{self.tools.describe()}
请输出 JSON 格式的计划：
{{
"goal": "任务目标",
"steps": [
{{"step": 1, "description": "步骤描述", "tool": "工具名称", "params": {{参数}}}},
...
]
}}
"""
response = self.planner.generate(prompt)
return self._parse_json(response)
def _execute_step(self, step, previous_results):
prompt = f"""
请执行以下步骤：
步骤描述：{step['description']}
可用工具：{step['tool']}
参数：{step.get('params', {})}
前置结果：{previous_results}
请调用工具并返回结果。
"""
return self.executor.generate(prompt)
def _adjust_plan(self, task, plan, results):
prompt = f"""
计划执行遇到问题，请调整计划：
原始任务：{task}
当前计划：{plan}
执行结果：{results}
请基于失败情况调整计划，输出新的 JSON 格式计划。
"""
response = self.planner.generate(prompt)
return self._parse_json(response)
def _summarize(self, task, plan, results):
prompt = f"""
请总结以下任务的执行过程：
任务：{task}
计划：{plan}
执行结果：{results}
请给出最终总结。
"""
return self.planner.generate(prompt)
def _parse_json(self, text):
import json
try:
return json.loads(text)
except:
# 简单的容错处理
return {"goal": text, "steps": []}3.4 适用场景
| 场景 | 说明 |
|---|---|
| 复杂任务分解 | 需要多个步骤完成的任务 |
| 项目管理 | 需要规划和执行的项目 |
| 文档生成 | 需要结构化输出的任务 |
| 数据分析 | 需要多步骤处理的分析任务 |
四、Reflexion 范式
4.1 核心思想
Reflexion（反思）：智能体在执行任务后进行自我反思，分析执行过程中的错误和不足，然后基于反思结果调整策略重新执行。
三阶段流程：
- 执行阶段：执行任务
- 反思阶段：分析执行过程
- 优化阶段：调整策略并重试
4.2 架构图
┌─────────────────────────────────────────────────────────────┐
│ Reflexion │
├─────────────────────────────────────────────────────────────┤
│ │
│ 用户输入 │
│ │ │
│ ↓ │
│ ┌──────────────┐ │
│ │ Execute │ │
│ │ (执行) │ │
│ └──────┬───────┘ │
│ │ │
│ ↓ │
│ ┌──────────────┐ │
│ │ Reflexion │ │
│ │ (反思) │ │
│ └──────┬───────┘ │
│ │ │
│ ↓ │
│ ┌──────────────┐ │
│ │ Evaluate │ │
│ │ (评估) │ │
│ └──────┬───────┘ │
│ │ │
│ ├── 成功 → 返回结果 │
│ │ │
│ └── 失败 → 调整策略 → 重新执行 │
│ │
└─────────────────────────────────────────────────────────────┘4.3 代码实现
python
class ReflexionAgent:
def __init__(self, llm, tools):
self.llm = llm
self.tools = tools
self.max_reflections = 3
def run(self, task):
execution_history = []
for attempt in range(self.max_reflections + 1):
print(f"\n第 {attempt + 1} 次尝试")
# 1. 执行任务
result = self._execute(task, execution_history)
execution_history.append({"attempt": attempt + 1, "result": result})
# 2. 评估结果
if self._is_success(result):
return self._summarize(execution_history)
# 3. 反思并调整
if attempt < self.max_reflections:
reflection = self._reflect(task, execution_history)
print(f"反思：{reflection}")
# 调整策略
task = self._adjust_task(task, reflection)
return f"任务失败，已尝试 {self.max_reflections + 1} 次"
def _execute(self, task, history):
prompt = f"""
请执行以下任务：
任务：{task}
可用工具：{self.tools.describe()}
历史尝试：{history}
请给出执行结果。
"""
return self.llm.generate(prompt)
def _is_success(self, result):
prompt = f"""
请评估以下执行结果是否成功完成了任务：
结果：{result}
请返回 "成功" 或 "失败"。
"""
return self.llm.generate(prompt) == "成功"
def _reflect(self, task, history):
prompt = f"""
请分析以下任务执行失败的原因：
任务：{task}
执行历史：{history}
请回答以下问题：
1. 失败的主要原因是什么？
2. 哪些步骤可以改进？
3. 下次应该采用什么不同的策略？
"""
return self.llm.generate(prompt)
def _adjust_task(self, task, reflection):
prompt = f"""
请根据以下反思结果调整任务描述：
原始任务：{task}
反思结果：{reflection}
请生成调整后的任务描述，包含改进策略。
"""
return self.llm.generate(prompt)
def _summarize(self, history):
prompt = f"""
请总结以下任务的执行过程：
执行历史：{history}
请给出最终总结，包括解决方法和经验教训。
"""
return self.llm.generate(prompt)4.4 适用场景
| 场景 | 说明 |
|---|---|
| 需要迭代改进的任务 | 需要多次尝试才能完成的任务 |
| 调试任务 | 需要找出问题并修复 |
| 复杂推理任务 | 需要深度思考和自我修正 |
| 学习型任务 | 需要从失败中学习 |
五、Tree of Thought（ToT）范式
5.1 核心思想
Tree of Thought（思维树）：将问题解决过程建模为树状结构，智能体在每个节点上探索多个可能的推理路径，然后选择最优路径继续。
关键特点：
- 广度优先搜索：探索多个分支
- 评估机制：对每个分支进行评估
- 剪枝策略：剪去无效分支
5.2 架构图
┌─────────────────────────────────────────────────────────────┐
│ Tree of Thought │
├─────────────────────────────────────────────────────────────┤
│ │
│ 问题 │
│ │ │
│ ┌─────────────────┼─────────────────┐ │
│ ↓ ↓ ↓ │
│ 思路1 思路2 思路3 │
│ │ │ │ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ ↓ ↓ ↓ ↓ ↓ ↓ │
│ 子思路1 子思路2 子思路3 子思路4 子思路5 子思路6 │
│ │ │ │ │ │ │ │
│ ↓ ↓ ↓ ↓ ↓ ↓ │
│ 评估→剪枝 评估→保留 评估→保留 评估→剪枝 评估→剪枝 评估→保留 │
│ │
└─────────────────────────────────────────────────────────────┘5.3 代码实现
python
class TreeNode:
def __init__(self, thought, parent=None):
self.thought = thought
self.parent = parent
self.children = []
self.score = None
def add_child(self, thought):
child = TreeNode(thought, self)
self.children.append(child)
return child
class TreeOfThoughtAgent:
def __init__(self, llm, tools, max_depth=3, max_branches=3):
self.llm = llm
self.tools = tools
self.max_depth = max_depth
self.max_branches = max_branches
def run(self, task):
root = TreeNode(f"开始解决任务：{task}")
best_node = self._search(root, depth=0)
return self._extract_solution(best_node)
def _search(self, node, depth):
if depth >= self.max_depth:
self._evaluate(node)
return node
# 生成子思路
thoughts = self._generate_thoughts(node.thought, depth)
# 创建子节点
for thought in thoughts[:self.max_branches]:
child = node.add_child(thought)
self._search(child, depth + 1)
# 选择最佳子节点
best_child = max(node.children, key=lambda c: c.score)
return best_child
def _generate_thoughts(self, context, depth):
prompt = f"""
请为以下问题生成 {self.max_branches} 个可能的解决思路：
当前上下文：{context}
当前深度：{depth}
可用工具：{self.tools.describe()}
请列出 {self.max_branches} 个思路，每个思路一行。
"""
response = self.llm.generate(prompt)
return [t.strip() for t in response.split("\n") if t.strip()]
def _evaluate(self, node):
prompt = f"""
请评估以下解决思路的可行性（0-10分）：
思路：{node.thought}
请返回分数。
"""
try:
node.score = int(self.llm.generate(prompt))
except:
node.score = 0
def _extract_solution(self, node):
path = []
while node:
path.append(node.thought)
node = node.parent
return "\n".join(reversed(path))5.4 适用场景
| 场景 | 说明 |
|---|---|
| 复杂推理问题 | 需要多步推理的问题 |
| 数学证明 | 需要逻辑推导的任务 |
| 创意生成 | 需要探索多个可能性 |
| 决策分析 | 需要权衡多个选项 |
六、Hierarchical（分层）范式
6.1 核心思想
Hierarchical（分层）：将智能体系统按层级组织，高层智能体负责规划和决策，低层智能体负责具体执行。
层级结构：
- 顶层：战略规划
- 中层：战术执行
- 底层：操作实施
6.2 架构图
┌─────────────────────────────────────────────────────────────┐
│ Hierarchical Agent │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────┐ │
│ │ 顶层：战略规划 │ │
│ │ (Strategic Planner) │ │
│ └────────────────────┬─────────────────────┘ │
│ │ │
│ ┌────────────────────┼─────────────────────┐ │
│ ↓ ↓ ↓ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 中层：战术 │ │ 中层：战术 │ │ 中层：战术 │ │
│ │ 执行1 │ │ 执行2 │ │ 执行3 │ │
│ └────┬─────┘ └────┬─────┘ └────┬─────┘ │
│ │ │ │ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ │ 底层： │ │ 底层： │ │ 底层： │ │
│ │ 操作实施 │ │ 操作实施 │ │ 操作实施 │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘6.3 代码实现
python
class HierarchicalAgent:
def __init__(self):
self.strategic_planner = StrategicPlanner()
self.tactical_executors = {
"research": ResearchExecutor(),
"design": DesignExecutor(),
"development": DevelopmentExecutor(),
"testing": TestingExecutor()
}
self.operational_workers = {
"web": WebWorker(),
"api": APIWorker(),
"database": DatabaseWorker()
}
def run(self, task):
# 1. 战略规划
strategy = self.strategic_planner.plan(task)
print(f"战略规划：{strategy}")
# 2. 战术执行
results = {}
for phase in strategy["phases"]:
executor = self.tactical_executors[phase["type"]]
results[phase["name"]] = executor.execute(phase, self.operational_workers)
# 3. 结果汇总
return self.strategic_planner.summarize(results)
class StrategicPlanner:
def __init__(self):
self.llm = llm
def plan(self, task):
prompt = f"""
请为以下任务制定战略规划：
任务：{task}
请输出 JSON 格式：
{{
"goal": "目标",
"phases": [
{{"name": "阶段名称", "type": "research/design/development/testing", "description": "描述"}},
...
]
}}
"""
response = self.llm.generate(prompt)
return self._parse_json(response)
def summarize(self, results):
prompt = f"""
请总结以下执行结果：
结果：{results}
请给出最终总结。
"""
return self.llm.generate(prompt)
class ResearchExecutor:
def execute(self, phase, workers):
print(f"执行研究阶段：{phase['description']}")
# 调用底层工作者
return workers["api"].call("research_api")6.4 适用场景
| 场景 | 说明 |
|---|---|
| 大型项目管理 | 需要多阶段管理的项目 |
| 企业级应用 | 需要分层架构的系统 |
| 复杂系统开发 | 需要分工协作的任务 |
| 多部门协作 | 需要跨部门协调的工作 |
七、Role-playing（角色扮演）范式
7.1 核心思想
Role-playing（角色扮演）：多个智能体分别扮演不同的角色，通过协作完成任务。
角色类型：
- 专业角色：产品经理、设计师、工程师、测试员
- 协调角色：项目经理、架构师
- 专家角色：领域专家、顾问
7.2 架构图
┌─────────────────────────────────────────────────────────────┐
│ Role-playing Agents │
├─────────────────────────────────────────────────────────────┤
│ │
│ 项目经理 │
│ ┌───────────────┼───────────────┐ │
│ ↓ ↓ ↓ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │产品经理 │ │ 设计师 │ │ 架构师 │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ └───────┬───────┴───────┬───────┘ │
│ ↓ ↓ │
│ ┌─────────┐ ┌─────────┐ │
│ │ 开发工程师│ │ 测试工程师│ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘7.3 代码实现
python
class RolePlayingSystem:
def __init__(self, roles):
self.roles = roles
self.project_manager = ProjectManager(roles)
def run(self, task):
# 1. 项目启动
self.project_manager.kickoff(task)
# 2. 角色协作
while not self.project_manager.is_complete():
# 获取当前需要行动的角色
current_role = self.project_manager.get_next_role()
# 执行角色任务
result = current_role.execute()
# 更新状态
self.project_manager.update(result)
# 3. 总结
return self.project_manager.summarize()
class ProjectManager:
def __init__(self, roles):
self.roles = roles
self.status = "planning"
self.task_history = []
def kickoff(self, task):
self.current_task = task
self.task_history.append({"role": "pm", "action": f"启动项目：{task}"})
def get_next_role(self):
# 根据状态决定下一个角色
role_order = ["product_manager", "designer", "architect", "developer", "tester"]
current_index = role_order.index(self.status)
return self.roles[role_order[current_index]]
def update(self, result):
self.task_history.append(result)
self._advance_status()
def _advance_status(self):
status_order = ["planning", "designing", "architecting", "developing", "testing", "completed"]
current_index = status_order.index(self.status)
if current_index < len(status_order) - 1:
self.status = status_order[current_index + 1]
def is_complete(self):
return self.status == "completed"
def summarize(self):
return f"项目完成！执行历史：{self.task_history}"
class ProductManager:
def __init__(self, llm):
self.llm = llm
def execute(self):
prompt = "请生成产品需求文档"
return {"role": "product_manager", "action": self.llm.generate(prompt)}
class Developer:
def __init__(self, llm):
self.llm = llm
def execute(self):
prompt = "请根据需求文档编写代码"
return {"role": "developer", "action": self.llm.generate(prompt)}7.4 适用场景
| 场景 | 说明 |
|---|---|
| 团队协作模拟 | 需要多角色协作的任务 |
| 软件开发 | 模拟开发团队 |
| 创意生成 | 需要多视角思考 |
| 教育训练 | 模拟真实工作场景 |
八、范式选择指南
8.1 选择决策树
任务是否需要工具调用？
├── 是 → ReAct 范式
└── 否 → 任务是否需要多步推理？
├── 是 → Plan-and-Execute 或 ToT
└── 否 → 任务是否需要迭代改进？
├── 是 → Reflexion
└── 否 → 简单 LLM 调用8.2 范式对比表
| 维度 | ReAct | Plan-and-Execute | Reflexion | ToT | Hierarchical | Role-playing |
|---|---|---|---|---|---|---|
| 自主性 | 高 | 中 | 高 | 高 | 中 | 高 |
| 可控性 | 低 | 高 | 中 | 中 | 高 | 低 |
| 推理深度 | 中 | 高 | 高 | 极高 | 高 | 中 |
| 实现复杂度 | 低 | 中 | 中 | 高 | 高 | 高 |
| 适用场景 | 工具调用 | 复杂任务 | 迭代改进 | 深度推理 | 大型项目 | 团队协作 |
8.3 组合使用策略
在实际应用中，可以组合多种范式：
python
class HybridAgent:
def __init__(self, llm, tools):
self.react_agent = ReActAgent(llm, tools)
self.reflexion_agent = ReflexionAgent(llm, tools)
def run(self, task):
# 先用 ReAct 执行
result = self.react_agent.run(task)
# 如果失败，用 Reflexion 优化
if not self._is_success(result):
result = self.reflexion_agent.run(task)
return result九、实战示例：多范式协作
9.1 场景描述
任务：开发一个电商网站的用户分析系统
9.2 架构设计
┌─────────────────────────────────────────────────────────────┐
│ 多范式协作系统 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. Hierarchical 分层管理 │
│ ├── 战略层：确定系统目标 │
│ ├── 战术层：分解任务到各角色 │
│ └── 操作层：执行具体任务 │
│ │
│ 2. Role-playing 角色协作 │
│ ├── 产品经理：定义需求 │
│ ├── 架构师：设计系统架构 │
│ ├── 开发工程师：实现功能 │
│ └── 测试工程师：验证质量 │
│ │
│ 3. Plan-and-Execute 任务规划 │
│ ├── 规划：确定开发步骤 │
│ └── 执行：按步骤实现 │
│ │
│ 4. ReAct 工具调用 │
│ ├── 数据查询工具 │
│ ├── 可视化工具 │
│ └── 报告生成工具 │
│ │
└─────────────────────────────────────────────────────────────┘9.3 代码实现
python
class ECommerceAnalyticsSystem:
def __init__(self):
# 初始化各层组件
self.hierarchical_agent = HierarchicalAgent()
self.role_playing_system = RolePlayingSystem({
"product_manager": ProductManager(llm),
"architect": Architect(llm),
"developer": Developer(llm),
"tester": Tester(llm)
})
self.plan_execute_agent = PlanAndExecuteAgent(planner_llm, executor_llm, tools)
def build(self, requirements):
# 1. 战略规划
strategy = self.hierarchical_agent.strategic_planner.plan(requirements)
# 2. 角色协作
design_doc = self.role_playing_system.run(strategy)
# 3. 任务规划与执行
implementation = self.plan_execute_agent.run(design_doc)
return implementation十、总结
核心要点
- ReAct：推理+行动交替，适合工具调用和动态环境
- Plan-and-Execute：先规划后执行，适合复杂任务分解
- Reflexion：自我反思优化，适合需要迭代改进的任务
- ToT：树状思维探索，适合深度推理问题
- Hierarchical：分层决策架构，适合大型项目管理
- Role-playing：角色扮演协作，适合团队协作模拟
选型建议
| 场景 | 推荐范式 | 理由 |
|---|---|---|
| 工具调用 | ReAct | 动态决策，灵活调用 |
| 复杂任务 | Plan-and-Execute | 结构化规划 |
| 迭代优化 | Reflexion | 自我修正能力 |
| 深度推理 | ToT | 探索多个路径 |
| 大型项目 | Hierarchical | 分层管理 |
| 团队协作 | Role-playing | 角色分工 |
学习路径
简单范式（ReAct）→ 进阶范式（Plan-and-Execute, Reflexion）→
高级范式（ToT）→ 系统范式（Hierarchical, Role-playing）→ 组合应用下一步建议
- 从 ReAct 范式开始实践，掌握工具调用机制
- 学习 Plan-and-Execute 进行任务分解
- 探索 Reflexion 实现自我优化
- 尝试组合多种范式解决复杂问题