一、引言：为什么需要智能体
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：
- 文中所有示例的完整代码均在我的 GitHub 仓库。需要查看完整代码或关注更多内容的，可前往仓库查看GitHub，如果觉得内容有帮助，欢迎 Star⭐ 支持
- 感谢 helloagents 项目。
