经典智能体范式

一、引言：为什么需要智能体

1.1 大模型的局限

之前的GPT-4等大模型停留在聊天框中且存在一些问题：一是“幻觉”，可能生成错误信息或不存在的内容；二是时效性不足，对未训练的新内容缺乏准确认知；三是复杂任务可靠性差，多步骤任务中易出现逻辑混乱。这些问题无法仅靠模型调优解决，所以智能体成为关键方案。

1.2 智能体的核心价值

智能体通过“大脑（LLM）-感知（环境信息捕捉）-动作（工具调用）”闭环，让LLM具备“思考、行动、感知”能力。相比单纯调用大模型，智能体可动态适应、与外部工具交互，高效处理复杂任务，比如代码生成、自动完成任务等。

二、什么是智能体

智能体（Agent）是能自主感知环境、推理决策、执行动作，并通过反馈迭代优化的智能系统。在目前大模型加持下，智能体以LLM为“决策大脑”，结合外部工具与环境交互，核心目标是将抽象任务转化为可落地的分步操作，解决单纯大模型“只会说不会做”“易幻觉”的问题。

核心特征：

自主性（无需人工干预即可推进任务）
交互性（能与工具、环境、用户反馈交互）
迭代性（可基于结果优化决策逻辑）

简单来说，大模型是“知识库”，智能体是“执行者”，二者结合可实现复杂任务的端到端落地。

智能体基础架构：三大核心组件

智能体由以下三个核心部分组成：

大脑：大语言模型，负责任务推理、决策与记忆；
感知模块：捕捉外部信息（工具反馈、任务状态等）；
动作模块：调用工具执行操作（API、代码解释器等。

为了更好地组织智能体的“思考”与“行动”过程，目前出现很多智能体的架构范式，本文聚焦最经典的三种ReAct、Plan-and-Solve、Reflection三种范式，深入了解智能体。

三、范式深度解析

3.1 ReAct：边想边做，动态适配

3.1.1 核心原理

ReAct（Reason + Act）范式的核心是“边推理边行动”，通过“思考-行动-观察”的闭环迭代，让智能体在动态交互中完成任务。其核心概念是“推理与行动绑定”——智能体不预先规划完整路径，而是每一步先分析当前状态（Thought），再执行具体动作（Action），最后根据反馈调整下一步策略（Observation）。

模拟人类解决未知问题的过程：比如查陌生城市天气+景点推荐，不会先规划所有步骤，而是先查天气（行动），根据天气结果（观察）再推荐室内/室外景点（思考+行动）。ReAct通过将推理过程显性化，能有效降低大模型幻觉，提升任务执行的可靠性。

3.1.2 代码示例（天气查询场景）

基于Python实现轻量ReAct智能体，含工具注册、闭环执行核心逻辑：

import requests from pydantic import BaseModel, Field from typing import Union, Optional, Tuple, Dict # 1. 工具定义：天气查询工具 def get_weather(city: str) -> str: """调用公开天气API，返回城市天气信息""" api_key = "your-weather-api-key" # 替换为实际API密钥 url = f"http://apis.juhe.cn/simpleWeather/query?city={city}&key={api_key}" try: res = requests.get(url).json() if res["error_code"] == 0: data = res["result"]["realtime"] return f"{city}今日天气：{data['info']}，温度{data['temperature']}℃" return f"查询失败：{res['reason']}" except Exception as e: return f"异常：{str(e)}" # 2. 工具执行器：管理工具注册与调用 class ToolExecutor: def __init__(self): self.tools = {} # key:工具名，value:(描述, 函数) def register(self, name: str, desc: str, func): """注册工具""" self.tools[name] = (desc, func) def get_tool(self, name: str) -> Optional[callable]: """获取工具函数""" return self.tools.get(name, (None, None))[1] def get_tool_desc(self) -> str: """生成工具描述（用于LLM提示词）""" return "\n".join([f"{k}: {v[0]}" for k, v in self.tools.items()]) # 3. LLM输出格式约束（避免解析混乱） class ToolAction(BaseModel): type: str = Field(default="tool", description="动作类型：tool/finish") name: Optional[str] = Field(None, description="工具名，type为tool时必填") input: Optional[str] = Field(None, description="工具输入，type为tool时必填") answer: Optional[str] = Field(None, description="最终答案，type为finish时必填") # 4. ReAct智能体核心类 class ReActAgent: def __init__(self, llm_client, tool_executor: ToolExecutor, max_steps: int = 5): self.llm = llm_client # LLM客户端（封装OpenAI/本地化模型） self.tool_exec = tool_executor self.max_steps = max_steps # 最大迭代步数（防死循环） self.history = [] # 存储执行历史（思考+动作+观察） def _parse_llm_output(self, output: str) -> Tuple[Optional[str], Optional[Dict]]: """解析LLM输出，提取思考过程和动作""" try: # 简化解析：实际可结合JSON Schema严格校验 import json res = json.loads(output) return res.get("thought"), res.get("action") except: return None, None def run(self, question: str) -> Optional[str]: """执行任务：思考-行动-观察闭环""" self.history = [] for step in range(self.max_steps): # 1. 构建提示词 tool_desc = self.tool_exec.get_tool_desc() history_str = "\n".join(self.history) prompt = f""" 你可调用以下工具： {tool_desc} 请按JSON格式输出：{{"thought":"思考过程","action":{{"type":"tool/finish","name":"工具名","input":"输入","answer":"最终答案"}}}} 示例：调用工具{{"thought":"需查天气","action":{{"type":"tool","name":"get_weather","input":"北京"}}}} 示例：完成任务{{"thought":"已获取结果","action":{{"type":"finish","answer":"北京今日晴"}}}} 问题：{question} 历史记录：{history_str} """ # 2. 调用LLM获取响应 llm_output = self.llm.chat(prompt) thought, action = self._parse_llm_output(llm_output) if not action: print(f"步骤{step+1}：解析失败，跳过") continue print(f"步骤{step+1}：思考：{thought}") # 3. 处理动作（完成/调用工具） if action["type"] == "finish": return action["answer"] if action["type"] == "tool": tool_name = action["name"] tool_input = action["input"] tool_func = self.tool_exec.get_tool(tool_name) if not tool_func: observation = f"工具{tool_name}未注册" else: observation = tool_func(tool_input) print(f"步骤{step+1}：动作：调用{tool_name}({tool_input})，观察：{observation}") # 4. 记录历史，进入下一轮 self.history.append(f"思考：{thought}") self.history.append(f"动作：{tool_name}({tool_input})") self.history.append(f"观察：{observation}") return "任务超时未完成" # 5. 运行示例 if __name__ == "__main__": # 初始化LLM客户端（此处简化，实际需封装API调用） class SimpleLLMClient: def chat(self, prompt: str) -> str: # 模拟LLM输出（实际替换为真实调用） return '{"thought":"用户查上海天气，需调用get_weather工具","action":{"type":"tool","name":"get_weather","input":"上海"}}' # 注册工具并运行 tool_exec = ToolExecutor() tool_exec.register("get_weather", "查询城市天气，输入为城市名", get_weather) agent = ReActAgent(SimpleLLMClient(), tool_exec) result = agent.run("上海今天天气怎么样？") print(f"最终结果：{result}")

3.1.3 总结

特点：

可解释：通过Thought链，清晰展示逻辑与流程，有利于理解、信任和调试智能体；
动态规划：根据当前情况再处理问题，加强了纠错能力；
工具协作：模型推理，工具处理具体任务，解决了之前大模型只能说的问题。

不足：

依赖大模型的推理能力；
因为边思考边行动的模式，导致使用LLM的频率会很高，导致任务的总耗时和花费比较高
可能是局部最优，缺少全局规划

3.2 Plan-and-Solve：先规划后执行

3.2.1 核心原理

Plan-and-Solve（规划-执行）范式的核心是“先谋后动”，核心概念是“规划与执行解耦”——将复杂任务拆分为可落地、有依赖关系的子步骤（Planning Phase），再按步骤执行(Solving Phase)并验证结果。如果某一步失败则动态调整计划（重规划阶段）。

其核心逻辑是“结构化拆解”，适合任务目标清晰、步骤可预判的场景。比如开发一个用户管理系统，不会直接上手编码，而是先拆分“需求分析→技术选型→数据库设计→开发→测试”等步骤，再逐一落地，若技术选型不合理则调整计划后重新推进。

3.2.2 代码示例（项目拆分场景）

含任务规划、步骤执行、重规划核心逻辑：

import json from typing import List, Optional, Tuple # 1. 规划器：生成/调整任务步骤 class Planner: def __init__(self, llm_client): self.llm = llm_client def generate_plan(self, task: str) -> List[str]: """生成初始任务计划（拆分子步骤）""" prompt = f""" 请将以下任务拆分为3-5个可执行子步骤，按JSON数组返回，仅输出数组： 任务：{task} 示例：["步骤1：需求分析", "步骤2：技术选型", "步骤3：代码开发"] """ llm_output = self.llm.chat(prompt) try: return json.loads(llm_output) except: return ["步骤1：默认处理任务"] def replan(self, task: str, original_plan: List[str], failed_step: str, reason: str) -> List[str]: """重规划：基于失败步骤调整计划""" prompt = f""" 原始任务：{task} 原始计划：{original_plan} 失败步骤：{failed_step} 失败原因：{reason} 请调整计划，返回新的子步骤（JSON数组，仅输出数组）： """ llm_output = self.llm.chat(prompt) try: return json.loads(llm_output) except: return original_plan # 失败则沿用原计划 # 2. 执行器：执行步骤并验证结果 class Executor: def __init__(self, llm_client): self.llm = llm_client def execute_step(self, step: str) -> str: """执行单个步骤（模拟开发场景任务执行）""" prompt = f""" 请模拟执行以下开发步骤，返回执行结果（简洁直白）： 步骤：{step} """ return self.llm.chat(prompt) def validate_step(self, step: str, result: str) -> Tuple[bool, str]: """验证步骤执行结果（成功/失败+原因）""" prompt = f""" 步骤：{step} 执行结果：{result} 请判断执行是否成功（true/false），并返回原因（格式：布尔值|原因）： """ llm_output = self.llm.chat(prompt) try: success, reason = llm_output.split("|") return success.lower() == "true", reason.strip() except: return False, "验证失败" # 3. Plan-and-Solve智能体核心类 class PlanAndSolveAgent: def __init__(self, llm_client, max_replan: int = 2): self.llm = llm_client self.planner = Planner(llm_client) self.executor = Executor(llm_client) self.max_replan = max_replan # 最大重规划次数 def run(self, task: str) -> str: """执行任务：规划→执行→重规划闭环""" # 1. 生成初始计划 plan = self.planner.generate_plan(task) print(f"初始计划：{plan}") if not plan: return "生成计划失败" replan_count = 0 current_idx = 0 # 当前执行步骤索引 while current_idx < len(plan): step = plan[current_idx] print(f"\n执行步骤{current_idx+1}/{len(plan)}：{step}") # 2. 执行步骤并验证 step_result = self.executor.execute_step(step) print(f"步骤结果：{step_result}") success, reason = self.executor.validate_step(step, step_result) if success: print(f"步骤{current_idx+1}：执行成功") current_idx += 1 continue # 3. 步骤失败，触发重规划 print(f"步骤{current_idx+1}：执行失败，原因：{reason}") if replan_count >= self.max_replan: return f"任务失败：步骤{current_idx+1}多次执行失败，已达最大重规划次数" replan_count += 1 print(f"第{replan_count}次重规划...") plan = self.planner.replan(task, plan, step, reason) print(f"重规划后计划：{plan}") current_idx = 0 # 重规划后从第一步重新执行 return f"任务成功完成，执行步骤：{plan}" # 4. 运行示例 if __name__ == "__main__": # 初始化简化LLM客户端 class SimpleLLMClient: def chat(self, prompt: str) -> str: # 模拟LLM输出（实际替换为真实调用） if "拆分为" in prompt: return '["步骤1：需求分析（明确用户管理功能）", "步骤2：技术选型（React+Node.js）", "步骤3：数据库设计（用户表）", "步骤4：代码开发", "步骤5：测试部署"]' elif "执行步骤1" in prompt: return "已完成需求分析，明确需包含注册、登录、权限管理功能" elif "验证步骤1" in prompt: return "true|需求分析全面，符合预期" else: return "执行中..." agent = PlanAndSolveAgent(SimpleLLMClient()) result = agent.run("开发一个用户管理系统") print(f"\n最终结果：{result}")

3.2.3 总结

核心要点：

提供稳定、结构化的执行流程；
适合路径清晰，侧重推理和步骤分解的任务；
执行路径清晰，便于调试追溯

不足：灵活性不足，应对突发需求调整繁琐。

3.3 Reflection：自我迭代，持续优化

3.3.1 核心原理

Reflection（反思）的核心是“自我迭代优化”，核心概念是“反馈驱动改进”——智能体先生成初始结果(Execution)，再从多维度自我评审（Reflection），识别不足后迭代优化(Refinement)，直至达到预期质量。

模拟人类“初稿-修改-定稿”的工作流程，比如编写代码时，先写初始版本，再自查语法错误、逻辑漏洞、性能问题，逐轮优化。通过“反思”模块，让智能体具备纠错能力，大幅提升输出质量。

3.3.2 代码示例（代码优化场景）

Reflection智能体，含多维度反思、迭代优化核心逻辑：

from typing import List, Dict # 1. 反思维度定义（代码优化核心维度） REFLECTION_DIMENSIONS = [ "语法正确性：是否存在语法错误", "逻辑完整性：是否覆盖所有场景（如空值处理）", "性能优化：是否存在冗余代码，执行效率如何", "格式规范：是否符合PEP 8编码规范" ] # 2. 反思器：多维度评审结果 class Reflector: def __init__(self, llm_client): self.llm = llm_client def reflect(self, task: str, result: str) -> Dict[str, str]: """多维度反思，返回各维度反馈""" prompt = f""" 任务：{task} 生成结果（代码）：{result} 请按以下维度评审，返回各维度反馈（JSON格式，key为维度，value为反馈）： {REFLECTION_DIMENSIONS} 示例：{{"语法正确性":"无语法错误","逻辑完整性":"缺少空值处理"}} """ llm_output = self.llm.chat(prompt) try: import json return json.loads(llm_output) except: return {"默认反馈": "评审失败，无有效反馈"} # 3. Reflection智能体核心类 class ReflectionAgent: def __init__(self, llm_client, max_iter: int = 3): self.llm = llm_client self.reflector = Reflector(llm_client) self.max_iter = max_iter # 最大迭代优化次数 def generate_initial(self, task: str) -> str: """生成初始结果（代码）""" prompt = f""" 请完成以下开发任务，返回代码（仅输出代码，无需解释）： 任务：{task} """ return self.llm.chat(prompt) def optimize(self, task: str, current_result: str, feedback: Dict[str, str]) -> str: """基于反馈优化结果（代码）""" feedback_str = "\n".join([f"{k}：{v}" for k, v in feedback.items()]) prompt = f""" 任务：{task} 当前代码：{current_result} 评审反馈：{feedback_str} 请根据反馈优化代码，仅输出优化后的代码（无需解释）： """ return self.llm.chat(prompt) def run(self, task: str) -> str: """执行任务：生成→反思→优化闭环""" # 1. 生成初始代码 current_code = self.generate_initial(task) print(f"初始代码：\n{current_code}") if not current_code: return "生成初始代码失败" # 2. 多轮迭代优化 for iter in range(self.max_iter): print(f"\n第{iter+1}轮优化：") # 反思评审 feedback = self.reflector.reflect(task, current_code) print(f"评审反馈：{feedback}") # 检查是否无需优化 if all(["无问题" in v or "符合" in v for v in feedback.values()]): print("所有维度符合要求，停止优化") break # 优化代码 current_code = self.optimize(task, current_code, feedback) print(f"优化后代码：\n{current_code}") return f"最终优化代码：\n{current_code}" # 4. 运行示例 if __name__ == "__main__": # 初始化简化LLM客户端 class SimpleLLMClient: def chat(self, prompt: str) -> str: # 模拟LLM输出（实际替换为真实调用） if "生成初始代码" in prompt or "完成以下开发任务" in prompt: # 初始代码（存在空值未处理问题） return '''def add(a, b): return a + b def calculate_sum(numbers): total = 0 for num in numbers: total += num return total''' elif "评审反馈" in prompt: # 反思反馈 return '''{ "语法正确性":"无语法错误", "逻辑完整性":"calculate_sum函数未处理numbers为空列表的场景", "性能优化":"无冗余代码，执行效率良好", "格式规范":"符合PEP 8规范" }''' elif "优化代码" in prompt: # 优化后代码（处理空值问题） return '''def add(a, b): return a + b def calculate_sum(numbers): if not numbers: return 0 total = 0 for num in numbers: total += num return total''' else: return "" agent = ReflectionAgent(SimpleLLMClient()) result = agent.run("编写两个函数：add（两数相加）、calculate_sum（列表求和）") print(f"\n任务结果：{result}")

3.3.3 总结

核心要点：自我纠错能力强，可以明显提高输出质量；

缺点：明显增加响应时长和任务花费。

四、三大范式对比

范式名称	核心特征	适用场景	优点	缺点
ReAct	边推理边行动，动态交互，无预先规划	实时信息查询（天气、股票）、API调用、不确定场景下的任务处理	1. 动态适配性强，能应对突发反馈；2. 幻觉概率低，推理过程显性化；3. 代码实现简单，易上手	1. 多步骤任务Token消耗高；2. 依赖LLM实时推理能力，复杂任务易混乱；3. 无全局规划，长期任务效率低
Plan-and-Solve	先规划后执行，结构化拆解，支持重规划	项目开发拆解、流程化任务、目标清晰的复杂任务（旅行规划）	1. 执行路径清晰，便于调试与追溯；2. 步骤化执行，任务推进可控；3. 支持重规划，容错性较强	1. 灵活性不足，应对突发需求调整繁琐；2. 初始规划质量依赖LLM拆分能力；3. 重规划后需重新执行，部分场景效率低
Reflection	自我反思，多轮迭代，反馈驱动优化	代码生成与优化、文案打磨、技术方案设计、高精度输出任务	1. 自我纠错能力强，输出质量高；2. 多维度评审，覆盖场景全面；3. 结果可迭代，无需人工干预优化	1. 多轮迭代耗时久，资源消耗高；2. 反思质量依赖LLM评审能力；3. 简单任务冗余，效率较低

五、未来去哪

5.1 总结

ReAct、Plan-and-Solve、Reflection 三种范式，分别对应 “动态交互、结构化执行、迭代优化三大核心能力：

若充满不确定性，需要与外部交互，优先选 ReAct，可以根据实时反馈调整；
若任务逻辑路径清晰，侧重推理和步骤分解，优先选 Plan-and-Solve，确保稳定、结构化的执行流程；
若任务对输出质量和可靠性要求高，优先选 Reflection，通过迭代优化可以提升结果质量。

5.2 未来方向

当前智能体开发还在快速迭代，未来的方向可能集中在以下几点：

范式融合：单一范式难以覆盖复杂场景，范式融合，比如“Plan-and-Solve+Reflection”（结构化规划+迭代优化）、“ReAct+Plan-and-Solve”（动态交互+局部规划），兼顾效率、灵活性与质量。
多模态：从文本向“文本+语音+图像+视频”多模态延伸，比如智能体可直接识别图片、调用语音等，适配更丰富的真实场景。
自主学习：引入强化学习（RL）与记忆机制，让智能体从历史任务中自主学习最优策略（如工具选择、步骤拆分），自我升级。

5.3 开发框架

实际开发中，我们无需从零搭建，可以基于成熟框架快速落地：

LangChain：目前最流行的智能体开发框架之一，生态完善，支持链条式任务拆解、记忆管理、多范式集成，适配OpenAI、本地化大模型等多种LLM，适合中大型智能体项目开发。
AutoGPT：基于GPT系列模型的自主智能体框架，核心优势是“高度自主化”，无需人工干预即可完成复杂任务（如市场调研、代码开发），但资源消耗较高，适合追求极致自主性的场景。
MetaGPT：微软开源的多智能体协作框架，模拟软件开发团队（产品经理、开发者、测试工程师）的协作模式，支持多智能体分工完成复杂任务，适合大型项目的智能化开发。

Tips：