记忆让Agent拥有知识，但知识本身不能处理问题。Agent需要“思考”——面对一个复杂任务，它能分解步骤、选择策略、发现错误并自我纠正。怎么说呢，这就是规划与推理的主要价值。

说到任务分解，ReAct框架与思维树解析

使用者痛点的观点是，任务拆解不清晰。导致Agent卡死或走弯路

很多开发者在让Agent处理复杂查询时常常只给出“一句话”指令，结果Agent要么一次性尝试全部答案，要么在中途失去上下文。其实，缺乏程序化的任务分解是导致低效和错误的根本原因。

至于ReAct，推理与行动的交织

ReAct是目前最主流的Agent推理框架。它的主要思想极其直观：在每一步中，Agent先“想”再“做”。

思考：使用者问北京今天天气，我不知道实时天气，需要搜索
行动的观点是。调用天气API查询北京
再看观察，北京今天晴，25°C，微风
说到思考，已经获取到天气信息，可以回答了
说到回答，北京今天天气晴朗，气温25度，微风，适合外出活动。

在LangChain中实现ReAct Agent：

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor,create_react_agent
from langchain_core.prompts import PromptTemplate
from langchain_community.tools import DuckDuckGoSearchRun
llm = ChatOpenAI
search = DuckDuckGoSearchRun
tools =
react_template = """
尽可能回答以下问题。你可以使用以下工具：{tools}
再看使用以下格式，问题：{input}
至于思考，你应该总是思考接下来做什么
从行动来看，要采取的行动。应该是中的一个
输入这方面，行动的参数
说到观察，行动的结果...
说到思考，我现在知道最终答案了
从最终答案来看，对原始问题的最终答案
开始！问题的观点是，{input}
从思考来看。{agent_scratchpad}
"""
prompt = PromptTemplate.from_template
agent = create_react_agent
agent_executor = AgentExecutor
result = agent_executor.invoke
print

ReAct的关键参数

参数	说明	建议值
max_iterations	最大推理步数	5
max_execution_time	最大执行时间	-60
handle_parsing_errors	推理失败时的处理策略	"check" 或自定义函数
early_stopping_method	提前停止策略	"generate"

思维树

ReAct 是线性的——每一步只有一个选择。但复杂问题可能需要探索多条方法，这就是思维树的价值。

ToT 允许 Agent 在每一步生成多个候选方案，接下来评估每个方案的价值。选择最优方法继续深入：

问题
/ \
思路A 思路B
/ \ / \
方案A1 方案A2 方案B1 ...
\ | /
评估 & 选择最佳方法
|
最终答案

def tree_of_thought_solve -> str:
"""简化版思维树实现"""
llm = ChatOpenAI # 较高温度增加多样性
def generate_thoughts -> list:
prompt = f"当前状态：{state}
问题这方面，{problem}
请生成 {n} 个不同的接下来思路。"
response = llm.invoke
return
def evaluate_thought -> float:
prompt = f"评估以下思路对处理问题的价值：
思路的观点是，{thought}
问题的观点是，{problem}
评分："
response = llm.invoke
try的观点是，return float)
说到except，return -10.0
best_path = ""
current_state = problem
for d in range:
thoughts = generate_thoughts
scores =
best_thought。best_score = max
best_path += f"
步骤 {d+1}：{best_thought}"
current_state = best_thought
return best_path.strip

说到反思机制，Self‑Reflection 与自我纠错流程

再看使用者痛点，“一次生成后不检查”，导致大量错误代码或误导性答案。

LLM 并非完美——它会产生幻觉、遗漏关键信息、甚至直接给出错误结论。没有反思机制的 Agent 就像一个不会检查作业的学生，犯错了也不会知道。话说回来，

Self‑Reflection 的基本模式

反思机制主要是在 Agent 执行后增加一个“自检”步骤：

执行 → 检查 → 发现问题 → 修正 → 重新执行 → 通过 → 返回结果

from pydantic import BaseModel
class ReflectionResult:
is_correct: bool
issues这方面。list
suggestions: list
class ReflectiveAgent:
def __init__:
self.llm = ChatOpenAI
self.max_retries = 3
def execute_with_reflection -> str:
result = execute_fn
for _ in range:
reflection: ReflectionResult = reflect_fn
if reflection.is_correct:
return result
correction_prompt = f"""原始任务:{task}
再看上次执行结果，{result}
至于发现的问题，{reflection.issues}
至于改进建议，{reflection.suggestions}
请。"""
result = self.llm.invoke.content
return result
def reflect_on_code -> ReflectionResult:
structured_llm = self.llm.with_structured_output
return structured_llm.invoke(f"""检查以下代码是否正确完成了任务：
至于任务。{task}
代码的观点是，{code}
请评估这方面，- 是否完成任务？
- 是否有 bug 或逻辑错误？改进建议，""")

Refine 模式：迭代调整长文本输出

LangChain 提供了 Refine 链，可对报告、分析等长文本进行多轮改进：

from langchain.chains import RefineDocumentsChain
refine_chain = RefineDocumentsChain.from_llm(
llm=ChatOpenAI。question_prompt=initial_analysis_prompt,refine_prompt=refine_improvement_prompt,)
refined_report = refine_chain.run
print

至于多步推理，复杂逻辑下的决策方法调整

从使用者痛点来看，“一步到位”期待导致链式错误累积。话说回来，

复杂任务往往需要多步推理。每一步都依赖上一步结果，其实，如果中间某一步出错，后续所有步骤都会偏离正确轨道。

链式推理示例

import json
class ChainedReasoner:
def __init__:
self.llm = llm
def reason -> dict:
"""按步骤链式推理。每步记录中间结果"""
reasoning_chain = {"problem": problem,"steps": }
for i,desc in enumerate:
step_prompt = f"""当前问题:{problem}
已完成步骤这方面，{json.dumps}
第{i+1}步描述:{desc}
请给出该步明确结论。"""
step_result = self.llm.invoke.content
reasoning_chain.append({
再看"step"，i+1,"description": desc。"conclusion": step_result,})
final_prompt = f"""问题:{problem}
再看推理过程，{json.dumps}
请综合以上所有步骤，给出最终答案。"""
reasoning_chain = self.llm.invoke.content
return reasoning_chain
reasoner = ChainedReasoner)
result = reasoner.reason(
problem="某电商访问使用者转化率下降了20%，如何分析原因？",steps=)
print)

分支推理与回溯

对于高度不确定的问题。可采用分支推理同时探索多条方法；当某条方法进入死胡同时回溯至上一步重新选择：

class BranchingReasoner:
def __init__:
self.llm = llm
self.max_branches = max_branches
def explore -> list:
paths =,"status": "exploring"}]
for d in range:
new_paths =
for path in paths:
if path!= "exploring":
new_paths.append
continue
branches = self._generate_branches
new_paths.extend
paths = new_paths
for path in paths:
path = self._evaluate_path
return sorted)。reverse=True)
# 以下两个方法需自行实现具体提示逻辑
def _generate_branches: ...
def _evaluate_path: ...

幻觉抑制这方面，基于事实核查的推理提高技术

User Pain Point：“模型经常编造不存在的数据”，导致业务决策风险。

L​LM 的幻觉主要表现为三类：

类型	表现	示例
事实性幻觉"Python 4.0 于2023年发布"
逻辑性幻觉"因为 A 所以 B。而实际两者无关联"
忠实性幻觉"上下文说 X，却回答 Y"

事实核查提高策略一：检索提高验证

def fact_check_with_retrieval -> dict:
"""用检索结果验证声明"""
docs = retriever.invoke
verification_prompt = f"""待验证声明:{claim}
说到参考资料，{docs}
从请判断来看，1. 声明是否被支持？2. 是否有证据反驳，怎么说呢，3. 给出可信度评级。"""
llm = ChatOpenAI
return llm.invoke.content

再看策略二，自我一致性检查

def self_consistency_check -> str:
"""通过多次采样检查答案一致性"""
llm_high_temp = ChatOpenAI
answers =
consensus_prompt=f"""问题:{question}

说到策略三。置信度校准

from pydantic import BaseModel class AnswerWithConfidence: 说到answer，str confidence: float   # 0~1 区间表示确信程度 reasoning: str assumptions: list def answer_with_confidence -> AnswerWithConfidence: llm=ChatOpenAI structured=llm.with_structured_output return structured.invoke(f"""请回答下面的问题，并提供置信度、推理过程还有所做假设： {question} 从注意来看，- 若不确定，请降低置信度而不是捏造信息。""")

：应对环境反馈的实时策略修正

User Pain Point：“一次计划后工具故障或数据缺失导致整个流程崩溃”。

A static plan is generated once and executed verbatim;其实，a dynamic planner continuously re‑evaluates environment and rewrites remaining steps.

基于反馈的规划修正示例

import json class DynamicPlanner: def __init__: self.llm=llm def plan->list: prompt=f"""任务:{tasks} 当前上下文的观点是，{context or '无'} 请制定执行计划。每步包含： · 步骤描述· 预期结果· 如果失败该怎么备选· 前置依赖""" resp=self.lll.invoke.content return self._parse_plan def adjust_plan(self,original_plan:list,current_step:int,execution_result=dict,context=dict)->list: prompt=f"""原始计划:{json.dumps} 当前已完成到第 {current_step} 步，执行结果:{json.dumps} 从当前上下文来看，{json.dumps} 请信息重新安排剩余步骤，并给出完整的新计划。""" resp=self.lll.invoke.content return self._parse_plan def _parse_plan->list: # 简单行号解析示例；实际项目建议使用结构化输出 steps= for line in text.split: if line.strip and line.strip.isdigit: steps.append}) return steps # 示例运行 planner=DynamicPlanner) initial_plan=planner.plan print

执行‑评估‑调整循环

def executewithadaptation(task:str,planner:DYNAMICPlanner,executor,maxretriesperstep:int=2): plan=planner.plan history= for i,step in enumerate: for attempt in range: result=executor # 使用者自行实现单步执行函数 if result.get: history.append break 说到else，# 调整剩余计划 plan=planner.adjustplan(plan,i,result,context={"completedsteps":history}) if attempt==maxretriesperstep-1: history.append return history

def dummy_executor: # 假设然后总会失败 if "第 ３ 步" in step.get: return {"success":False,"msg":"API 超时"} return {"success":True,"msg":"ok"}

runlog=executewithadaptation( task="生成并发送财务月报",planner=planner,executor=dummyexecutor。maxretriesper_step=2)

print)

关键设计原则

1. 每次执行后都评估：
2. 保留调整历史：

本章小结

推理技术	主要思想	适用场景
ReAct	交替 “思考→行动” 的线性链式流程	通用 Agent 任務，需要即时调用外部工具时
Tree of Thought	多方法探索 + 方法评分选择	开放式、创造性、需要比较不同解法的问题
Self‑Reflection	执行后自检 + 自动纠错	代码生成、报告撰写等对准确性要求高的输出
链式推理	分步传递中间结果、逐层累加结论	业务分析、数据洞察等多阶段决策过程
分支推理	同时探索多条方法并回溯筛选最佳路线	高不确定性决策、策略游戏等场景
幻觉抑制技术	检索验证 + 自我一致性 + 置信度标注	事实问答、法律合规、金融报告等对真实性敏感领域
动态规划	实时根据反馈修改剩余计划，实现弹性执行

。

---