自我反思与纠错
自我反思（Self-Reflection） 是 Agent 的高级能力，让 Agent 能够评估自己的执行结果、分析失败原因、生成改进方案。这是 Agent 从"执行者"升级为"学习者"的关键能力。
一、核心概念
1.1 什么是自我反思？
自我反思 是 Agent 对自身行为和结果进行评估、分析和改进的能力：
┌─────────────────────────────────────────────────────────────┐
│ 自我反思流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 执行任务 │ │
│ │ 得到结果 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 自我反思 │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────┐ │ │
│ │ │ 评估结果 │ → │ 分析原因 │ → │ 改进方案│ │ │
│ │ │ (Evaluate) │ │ (Analyze) │ │ (Improve)│ │ │
│ │ └─────────────┘ └─────────────┘ └─────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 再次执行 │ │
│ │ 改进结果 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘1.2 反思的时机
| 时机 | 描述 | 适用场景 |
|---|---|---|
| 执行后反思 | 任务完成后进行整体评估 | 常规任务、结果验证 |
| 过程中反思 | 执行过程中检测偏差 | 长任务、高风险任务 |
| 失败后反思 | 任务失败时分析原因 | 错误恢复、学习改进 |
1.3 反思的核心要素
┌─────────────────────────────────────────────────────────────┐
│ 反思三要素 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 验证器（Validator） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 作用：判断执行结果是否正确 │ │
│ │ │ │
│ │ 输入：执行结果 + 预期目标 │ │
│ │ 输出：验证通过/失败 + 差异说明 │ │
│ │ │ │
│ │ 示例： │ │
│ │ • 代码测试：运行单元测试 │ │
│ │ • 数学验证：反向计算验证 │ │
│ │ • 人工反馈：用户确认 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 2. 反思器（Reflector） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 作用：分析失败原因，生成改进建议 │ │
│ │ │ │
│ │ 输入：执行历史 + 失败原因 │ │
│ │ 输出：问题分析 + 改进方案 │ │
│ │ │ │
│ │ 示例： │ │
│ │ • "工具参数错误，应该使用正确的格式" │ │
│ │ • "推理方向错误，应该从另一个角度思考" │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 3. 修正器（Corrector） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 作用：根据反思结果修正执行方案 │ │
│ │ │ │
│ │ 输入：原方案 + 改进建议 │ │
│ │ 输出：修正后的执行方案 │ │
│ │ │ │
│ │ 示例： │ │
│ │ • 修改工具参数 │ │
│ │ • 更换工具 │ │
│ │ • 调整推理路径 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘二、反思机制设计
2.1 Reflexion 架构
Reflexion 是一种经典的反思架构，由 Shinn et al. 于 2023 年提出：
┌─────────────────────────────────────────────────────────────────────┐
│ Reflexion 架构 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 任务输入 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Actor（执行器） │ │
│ │ │ │
│ │ 输入：任务 + 记忆（历史反思） │ │
│ │ 输出：行动轨迹 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Evaluator（评估器） │ │
│ │ │ │
│ │ 输入：行动轨迹 │ │
│ │ 输出：奖励分数（成功/失败/部分成功） │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ↓ │
│ ┌────────┴────────┐ │
│ │ 是否成功？ │ │
│ └────────┬────────┘ │
│ │ │
│ ┌──────────────┴──────────────┐ │
│ ↓ ↓ │
│ 成功 失败 │
│ │ │ │
│ ↓ ↓ │
│ 结束 ┌─────────────────────────────────┐ │
│ │ Self-Reflection（自我反思） │ │
│ │ │ │
│ │ 输入：行动轨迹 + 失败原因 │ │
│ │ 输出：反思总结 │ │
│ │ │ │
│ │ 存入记忆，用于下次执行 │ │
│ └─────────────────────────────────┘ │
│ │ │
│ ↓ │
│ 重新执行 │
│ │
└─────────────────────────────────────────────────────────────────────┘2.2 反思类型
| 类型 | 描述 | 示例 |
|---|---|---|
| 结果反思 | 评估最终结果是否符合预期 | "输出格式不符合要求" |
| 过程反思 | 评估执行过程是否合理 | "走了弯路，应该直接搜索" |
| 策略反思 | 评估整体策略是否正确 | "分解策略不合理，粒度太粗" |
| 学习反思 | 从成功/失败中提取经验 | "记住：API 调用需要先认证" |
2.3 反思深度
┌─────────────────────────────────────────────────────────────┐
│ 反思深度层次 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 第一层：表面反思 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 直接观察到的错误 │ │
│ │ 例："工具调用失败，参数格式错误" │ │
│ │ 修正：修改参数格式 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 第二层：原因反思 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 分析错误的根本原因 │ │
│ │ 例："参数格式错误是因为理解了错误的 API 文档" │ │
│ │ 修正：重新阅读文档，确认参数规范 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 第三层：策略反思 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 分析策略层面的问题 │ │
│ │ 例："应该先做小规模测试，再正式调用" │ │
│ │ 修正：添加测试步骤到执行流程 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 第四层：学习反思 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 提取可复用的经验 │ │
│ │ 例："所有 API 调用前都应该先测试连通性" │ │
│ │ 修正：更新默认执行策略 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘三、代码实现
3.1 基础反思机制
"""
自我反思机制基础实现
包含验证器、反思器、修正器
"""
from typing import List, Optional, Dict, Any
from dataclasses import dataclass
from enum import Enum
from langchain_openai import ChatOpenAI
class ReflectionType(Enum):
"""反思类型"""
RESULT = "result" # 结果反思
PROCESS = "process" # 过程反思
STRATEGY = "strategy" # 策略反思
LEARNING = "learning" # 学习反思
@dataclass
class ExecutionTrace:
"""执行轨迹"""
task: str # 任务描述
actions: List[Dict[str, Any]] # 执行动作列表
result: Any # 最终结果
success: bool # 是否成功
error: Optional[str] = None # 错误信息
@dataclass
class Reflection:
"""反思结果"""
type: ReflectionType # 反思类型
issue: str # 发现的问题
cause: str # 问题原因
suggestion: str # 改进建议
confidence: float # 置信度
class Validator:
"""
验证器
判断执行结果是否正确
"""
VALIDATION_PROMPT = """
请验证以下执行结果是否正确完成任务。
任务：{task}
执行结果：{result}
请判断：
1. 任务是否完成？
2. 结果是否符合预期？
3. 有什么问题或不足？
请按以下格式输出：
状态：成功/失败/部分成功
问题：（如果有）
建议：（如果有）
"""
def __init__(self, model_name: str = "gpt-4"):
self.llm = ChatOpenAI(model=model_name, temperature=0)
def validate(self, trace: ExecutionTrace) -> tuple[bool, str]:
"""
验证执行结果
Returns:
(是否成功, 反馈信息)
"""
prompt = self.VALIDATION_PROMPT.format(
task=trace.task,
result=str(trace.result)
)
response = self.llm.invoke(prompt)
content = response.content
# 解析状态
if "成功" in content and "失败" not in content:
return True, content
elif "部分成功" in content:
return False, content
else:
return False, content
class Reflector:
"""
反思器
分析失败原因，生成改进建议
"""
REFLECTION_PROMPT = """
请分析以下执行失败的原因，并提出改进建议。
任务：{task}
执行动作：
{actions}
执行结果：{result}
失败原因：{error}
请进行深度反思：
1. 问题出在哪里？（表面原因）
2. 根本原因是什么？（深层原因）
3. 如何改进？（具体建议）
4. 有什么经验教训？（可复用的知识）
请按以下格式输出：
问题：...
原因：...
建议：...
教训：...
"""
def __init__(self, model_name: str = "gpt-4"):
self.llm = ChatOpenAI(model=model_name, temperature=0.7)
def reflect(self, trace: ExecutionTrace) -> Reflection:
"""
进行反思
Returns:
反思结果
"""
# 格式化动作历史
actions_text = "\n".join([
f" {i+1}. {action}"
for i, action in enumerate(trace.actions)
])
prompt = self.REFLECTION_PROMPT.format(
task=trace.task,
actions=actions_text,
result=str(trace.result),
error=trace.error or "未达到预期目标"
)
response = self.llm.invoke(prompt)
content = response.content
# 解析反思结果
issue = self._extract_section(content, "问题")
cause = self._extract_section(content, "原因")
suggestion = self._extract_section(content, "建议")
return Reflection(
type=ReflectionType.RESULT,
issue=issue,
cause=cause,
suggestion=suggestion,
confidence=0.8
)
def _extract_section(self, text: str, section: str) -> str:
"""提取指定部分"""
lines = text.split('\n')
result = []
capturing = False
for line in lines:
if line.startswith(f"{section}：") or line.startswith(f"{section}:"):
capturing = True
result.append(line.split('：', 1)[-1].split(':', 1)[-1].strip())
elif capturing:
if any(line.startswith(s) for s in ["问题", "原因", "建议", "教训"]):
break
result.append(line.strip())
return '\n'.join(result) if result else ""
class SelfReflectionAgent:
"""
自我反思 Agent
整合验证器、反思器，支持迭代改进
"""
def __init__(
self,
model_name: str = "gpt-4",
max_reflections: int = 3
):
self.llm = ChatOpenAI(model=model_name, temperature=0)
self.validator = Validator(model_name)
self.reflector = Reflector(model_name)
self.max_reflections = max_reflections
self.reflection_memory: List[Reflection] = []
def execute(self, task: str) -> ExecutionTrace:
"""执行任务（简化实现）"""
# 这里简化为直接调用 LLM
response = self.llm.invoke(task)
return ExecutionTrace(
task=task,
actions=[{"type": "llm_call", "input": task}],
result=response.content,
success=True
)
def run_with_reflection(self, task: str) -> dict:
"""
带反思的执行
Args:
task: 任务描述
Returns:
执行结果和反思历史
"""
for iteration in range(self.max_reflections):
# 执行任务
trace = self.execute(task)
# 验证结果
is_success, feedback = self.validator.validate(trace)
trace.success = is_success
if is_success:
return {
"task": task,
"success": True,
"result": trace.result,
"iterations": iteration + 1
}
# 反思失败原因
trace.error = feedback
reflection = self.reflector.reflect(trace)
self.reflection_memory.append(reflection)
# 根据反思调整任务描述
task = self._adjust_task(task, reflection)
return {
"task": task,
"success": False,
"result": trace.result,
"iterations": self.max_reflections,
"reflections": [
{
"issue": r.issue,
"cause": r.cause,
"suggestion": r.suggestion
}
for r in self.reflection_memory
]
}
def _adjust_task(self, task: str, reflection: Reflection) -> str:
"""根据反思调整任务"""
return f"""
原始任务：{task}
注意避免以下问题：
- {reflection.issue}
原因：{reflection.cause}
建议：{reflection.suggestion}
请重新执行任务，注意改进。
"""
# 使用示例
if __name__ == "__main__":
agent = SelfReflectionAgent(max_reflections=3)
result = agent.run_with_reflection(
"写一个 Python 函数，计算斐波那契数列的第 n 项"
)
print(f"任务：{result['task']}")
print(f"成功：{result['success']}")
print(f"迭代次数：{result['iterations']}")
if not result['success']:
print("\n反思历史：")
for i, r in enumerate(result['reflections'], 1):
print(f"\n第{i}次反思：")
print(f" 问题：{r['issue']}")
print(f" 原因：{r['cause']}")
print(f" 建议：{r['suggestion']}")3.2 使用 LangGraph 实现
"""
使用 LangGraph 实现反思循环
"""
from typing import TypedDict, List, Optional
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
class ReflectionState(TypedDict):
"""反思状态"""
task: str
actions: List[str]
result: str
is_valid: bool
feedback: str
reflection: str
iteration: int
max_iterations: int
def create_reflection_graph():
"""创建反思图"""
llm = ChatOpenAI(model="gpt-4", temperature=0)
# 执行节点
def execute(state: ReflectionState) -> ReflectionState:
"""执行任务"""
# 构建带反思历史的提示
prompt = state["task"]
if state["reflection"]:
prompt = f"""
任务：{state['task']}
之前的反思：
{state['reflection']}
请改进后重新执行。
"""
response = llm.invoke(prompt)
return {
**state,
"result": response.content,
"actions": state["actions"] + [prompt[:100]],
"iteration": state["iteration"] + 1
}
# 验证节点
def validate(state: ReflectionState) -> ReflectionState:
"""验证结果"""
prompt = f"""
验证以下结果是否正确完成任务。
任务：{state['task']}
结果：{state['result']}
请判断：成功/失败
如果失败，请说明原因。
"""
response = llm.invoke(prompt)
content = response.content
is_valid = "成功" in content and "失败" not in content
return {
**state,
"is_valid": is_valid,
"feedback": content
}
# 反思节点
def reflect(state: ReflectionState) -> ReflectionState:
"""反思失败原因"""
prompt = f"""
分析失败原因并提出改进建议。
任务：{state['task']}
执行结果：{state['result']}
失败原因：{state['feedback']}
请分析问题并提出改进建议。
"""
response = llm.invoke(prompt)
return {
**state,
"reflection": response.content
}
# 条件判断
def should_continue(state: ReflectionState) -> str:
"""判断是否继续"""
if state["is_valid"]:
return "end"
if state["iteration"] >= state["max_iterations"]:
return "end"
return "reflect"
# 创建图
workflow = StateGraph(ReflectionState)
# 添加节点
workflow.add_node("execute", execute)
workflow.add_node("validate", validate)
workflow.add_node("reflect", reflect)
# 设置入口
workflow.set_entry_point("execute")
# 添加边
workflow.add_edge("execute", "validate")
workflow.add_conditional_edges(
"validate",
should_continue,
{
"end": END,
"reflect": "reflect"
}
)
workflow.add_edge("reflect", "execute")
return workflow.compile()
# 使用示例
if __name__ == "__main__":
graph = create_reflection_graph()
result = graph.invoke({
"task": "实现一个冒泡排序算法",
"actions": [],
"result": "",
"is_valid": False,
"feedback": "",
"reflection": "",
"iteration": 0,
"max_iterations": 3
})
print(f"最终结果：{result['is_valid']}")
print(f"迭代次数：{result['iteration']}")四、反思的应用场景
4.1 适用场景
| 场景 | 反思价值 | 示例 |
|---|---|---|
| 代码生成 | 验证代码正确性 | 运行测试用例 |
| 数学推理 | 验证计算结果 | 反向计算验证 |
| 创意写作 | 质量评估改进 | 自我评分改进 |
| 问题解决 | 多次尝试优化 | 穷举搜索优化 |
4.2 反思时机选择
┌─────────────────────────────────────────────────────────────┐
│ 反思时机决策 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 是否需要反思？ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────┴───────────┐ │
│ ↓ ↓ │
│ 需要验证 不需要 │
│ │ │ │
│ ↓ ↓ │
│ ┌─────────────────┐ 直接输出 │
│ │ 验证成本高吗？ │ │
│ └────────┬────────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ ↓ ↓ │
│ 高 低 │
│ │ │ │
│ ↓ ↓ │
│ 事后反思 过程中反思 │
│ （执行完再验证） （边执行边验证） │
│ │
│ 示例决策： │
│ • 写代码 → 高验证成本 → 事后反思（运行测试） │
│ • 数学计算 → 低验证成本 → 过程中反思（逐步检查） │
│ • 创意写作 → 主观评估 → 事后反思（自我评分） │
│ │
└─────────────────────────────────────────────────────────────┘五、反思机制的挑战
5.1 主要挑战
| 挑战 | 描述 | 影响 |
|---|---|---|
| 反思本身可能出错 | LLM 的反思结论不一定正确 | 可能导致错误修正 |
| 无限循环 | 反思后仍然失败，继续反思 | 资源浪费 |
| 反思频率权衡 | 反思次数多成本高，少则效果差 | 效率与质量权衡 |
| 经验提取难 | 从失败中提取可复用经验不容易 | 学习效果有限 |
5.2 解决方案
┌─────────────────────────────────────────────────────────────┐
│ 挑战应对策略 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 反思验证 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ • 使用外部验证器验证反思结论 │ │
│ │ • 多次反思取共识 │ │
│ │ • 设置置信度阈值 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 2. 循环控制 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ • 设置最大反思次数 │ │
│ │ • 检测重复反思（无新进展则终止） │ │
│ │ • 降级策略（多次失败后换方法） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 3. 成本优化 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ • 快速失败检测（先做简单验证） │ │
│ │ • 分层反思（先浅层，失败再深层） │ │
│ │ • 缓存反思结果（类似问题复用） │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 4. 经验固化 │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ • 将反思结论写入长期记忆 │ │
│ │ • 结构化存储（问题-原因-解决方案） │ │
│ │ • 定期总结提炼 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘六、面试高频问题
Q1: 自我反思机制的核心要素是什么？
答案要点：
- 验证器：判断结果是否正确
- 反思器：分析失败原因
- 修正器：生成改进方案
- 三者形成闭环，支持迭代改进
Q2: 如何避免无限反思循环？
答案要点：
- 设置最大反思次数
- 检测重复反思（无新进展则终止）
- 实现降级策略（多次失败后换方法）
- 使用外部验证器判断
Q3: 反思机制适用于哪些场景？
答案要点：
- 代码生成：通过测试验证正确性
- 数学推理：通过反向计算验证
- 复杂任务：需要多次尝试优化
- 学习场景：需要从失败中积累经验
Q4: 反思深度如何选择？
答案要点：
- 表面反思：快速定位明显错误
- 原因反思：分析根本原因
- 策略反思：优化执行策略
- 学习反思：提取可复用经验
- 根据失败次数递进深入
Q5: Reflexion 架构的核心思想是什么？
答案要点：
- Actor 执行任务
- Evaluator 评估结果
- Self-Reflection 反思失败原因
- 反思结果存入记忆，用于下次执行
- 形成"执行-评估-反思-改进"的闭环
七、小结
| 概念 | 一句话总结 | 面试关键词 |
|---|---|---|
| 自我反思 | Agent 评估自身行为并改进的能力 | Self-Reflection、迭代改进 |
| 验证器 | 判断执行结果是否正确 | Validator、结果验证 |
| 反思器 | 分析失败原因 | Reflector、原因分析 |
| Reflexion | 经典的反思架构 | Actor-Evaluator-Reflector |
一句话总结：自我反思是 Agent 从"执行者"升级为"学习者"的关键能力，通过验证-反思-改进的闭环实现持续优化。
最后更新：2026年3月19日