Reflexion 反思模式
Reflexion 是一种基于语言反馈的自我反思 Agent 架构，由 Shinn et al. 于 2023 年提出。其核心思想是通过"执行→评估→反思→改进"的闭环，让 Agent 从失败经验中学习，无需微调底层模型即可提升任务表现。
一、核心原理
1.1 设计哲学
Reflexion 的核心思想源于人类的"反思学习"模式：
┌─────────────────────────────────────────────────────────────┐
│ Reflexion 设计哲学 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 传统 Agent： │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 输入 │ ──→ │ 执行 │ ──→ │ 输出 │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ 执行一次，失败即终止 │
│ │
│ Reflexion 模式： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌─────────┐ │ │
│ │ │ 输入 │ │ │
│ │ └────┬────┘ │ │
│ │ ↓ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Actor │ ──→ │ Evaluator│ ──→ │Reflector│ │ │
│ │ │ 执行 │ │ 评估 │ │ 反思 │ │ │
│ │ └────┬────┘ └────┬────┘ └────┬────┘ │ │
│ │ │ │ │ │ │
│ │ │ 失败时反馈 语言化反思 │ │
│ │ │ │ │ │ │
│ │ └───────────────┴───────────────┘ │ │
│ │ ↓ │ │
│ │ ┌─────────────────┐ │ │
│ │ │ 迭代改进 │ │ │
│ │ │ Retry with │ │ │
│ │ │ Reflection │ │ │
│ │ └─────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 核心创新：用语言反馈替代标量奖励 │
│ │
└─────────────────────────────────────────────────────────────┘1.2 三大核心组件
| 组件 | 英文 | 职责 | 输出 |
|---|---|---|---|
| Actor | 执行者 | 生成动作序列，执行任务 | 轨迹（Trajectory） |
| Evaluator | 评估者 | 评估执行结果，给出反馈 | 奖励信号/反馈文本 |
| Self-Reflector | 反思器 | 分析失败原因，生成改进建议 | 反思文本（Reflection） |
1.3 工作流程详解
┌─────────────────────────────────────────────────────────────┐
│ Reflexion 工作流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 第一轮尝试（Trial 1） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Actor: 生成初始答案 │ │
│ │ ↓ │ │
│ │ Evaluator: 评估 → 结果：失败 │ │
│ │ ↓ │ │
│ │ Self-Reflector: 分析失败原因 │ │
│ │ "答案不完整，缺少对X的考虑" │ │
│ │ ↓ │ │
│ │ 存入反思记忆 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ ↓ │
│ 第二轮尝试（Trial 2） │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Actor: 参考反思记忆重新规划 │ │
│ │ "注意要考虑X" │ │
│ │ ↓ │ │
│ │ 生成改进后的答案 │ │
│ │ ↓ │ │
│ │ Evaluator: 评估 → 结果：成功 │ │
│ │ ↓ │ │
│ │ 输出最终答案 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘1.4 与传统强化学习的区别
| 对比维度 | Reflexion | 传统 RL |
|---|---|---|
| 奖励类型 | 语言反馈 | 标量奖励 |
| 信息量 | 高（详细解释） | 低（单一数值） |
| 学习方式 | 上下文学习 | 权重更新 |
| 模型要求 | 无需微调 | 需要训练 |
| 适用场景 | 任务可评估 | 需要大量样本 |
二、工作流程
2.1 完整工作流程图
┌─────────────────────────────────────────────────────────────────────┐
│ Reflexion 完整工作流程 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ │ 任务输入 │ │
│ │ (Task) │ │
│ └──────┬──────┘ │
│ │ │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 迭代循环 │ │
│ │ ┌───────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ ┌──────────────────────────────────────────────┐ │ │ │
│ │ │ │ Actor 阶段 │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ Context = Task + History + Reflections │ │ │ │
│ │ │ │ ↓ │ │ │ │
│ │ │ │ 生成动作序列 (Trajectory) │ │ │ │
│ │ │ │ ↓ │ │ │ │
│ │ │ │ 执行工具调用 │ │ │ │
│ │ │ │ ↓ │ │ │ │
│ │ │ │ 生成答案 │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ └──────────────────────────────────────────────┘ │ │ │
│ │ │ │ │ │ │
│ │ │ ↓ │ │ │
│ │ │ ┌──────────────────────────────────────────────┐ │ │ │
│ │ │ │ Evaluator 阶段 │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ 输入：Task + Trajectory + Answer │ │ │ │
│ │ │ │ ↓ │ │ │ │
│ │ │ │ 评估函数判断 │ │ │ │
│ │ │ │ ↓ │ │ │ │
│ │ │ │ 输出：Success / Failure + Feedback │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ └──────────────────────────────────────────────┘ │ │ │
│ │ │ │ │ │ │
│ │ │ ┌─────────┴─────────┐ │ │ │
│ │ │ ↓ ↓ │ │ │
│ │ │ ┌─────────┐ ┌──────────┐ │ │ │
│ │ │ │ 成功 │ │ 失败 │ │ │ │
│ │ │ │ 输出答案 │ │ 进入反思 │ │ │ │
│ │ │ └────┬────┘ └────┬─────┘ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ ↓ │ │ │
│ │ │ │ ┌────────────────────────┐ │ │ │
│ │ │ │ │ Self-Reflector 阶段 │ │ │ │
│ │ │ │ │ │ │ │ │
│ │ │ │ │ 分析失败原因 │ │ │ │
│ │ │ │ │ 生成反思文本 │ │ │ │
│ │ │ │ │ 存入反思记忆 │ │ │ │
│ │ │ │ │ ↓ │ │ │ │
│ │ │ │ │ 返回 Actor 重试 │ │ │ │
│ │ │ │ │ │ │ │ │
│ │ │ │ └────────────────────────┘ │ │ │
│ │ │ │ │ │ │
│ │ │ ↓ │ │ │
│ │ │ ┌─────────────┐ │ │ │
│ │ │ │ 达到最大 │ │ │ │
│ │ │ │ 重试次数？ │ │ │ │
│ │ │ └──────┬──────┘ │ │ │
│ │ │ │ │ │ │
│ │ │ ┌──────┴──────┐ │ │ │
│ │ │ ↓ ↓ │ │ │
│ │ │ ┌────────┐ ┌──────────┐ │ │ │
│ │ │ │ 是 │ │ 否 │ │ │ │
│ │ │ │ 输出 │ │ 继续迭代 │ │ │ │
│ │ │ │ 最佳 │ └──────────┘ │ │ │
│ │ │ └────────┘ │ │ │
│ │ │ │ │ │
│ │ └───────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘2.2 反思记忆结构
@dataclass
class Reflection:
"""反思记录"""
trial_id: int # 尝试次数
task: str # 任务描述
trajectory: List[str] # 执行轨迹
failure_reason: str # 失败原因
improvement: str # 改进建议
timestamp: datetime # 时间戳
class ReflectionMemory:
"""反思记忆管理"""
def __init__(self, max_reflections: int = 5):
self.reflections: List[Reflection] = []
self.max_reflections = max_reflections # 滑动窗口大小
def add(self, reflection: Reflection):
"""添加反思记录"""
self.reflections.append(reflection)
# 滑动窗口：只保留最近的 N 条
if len(self.reflections) > self.max_reflections:
self.reflections.pop(0)
def get_context(self) -> str:
"""获取反思上下文"""
if not self.reflections:
return ""
context = "历史反思：\n"
for r in self.reflections:
context += f"- \{r.improvement\}\n"
return context2.3 执行轨迹示例
┌─────────────────────────────────────────────────────────────┐
│ Reflexion 执行轨迹示例 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 任务：编写一个 Python 函数，计算列表中的最大值 │
│ │
│ === Trial 1 === │
│ Actor 输出： │
│ ```python │
│ def find_max(lst): │
│ return max(lst) │
│ ``` │
│ │
│ Evaluator 评估： │
│ - 测试用例 1: find_max([1,2,3]) → 3 ✓ │
│ - 测试用例 2: find_max([]) → Error ✗ │
│ 结果：失败 │
│ │
│ Self-Reflector 反思： │
│ "函数没有处理空列表的情况，需要添加边界检查" │
│ │
│ === Trial 2 === │
│ Actor 输出（参考反思）： │
│ ```python │
│ def find_max(lst): │
│ if not lst: │
│ return None │
│ return max(lst) │
│ ``` │
│ │
│ Evaluator 评估： │
│ - 测试用例 1: find_max([1,2,3]) → 3 ✓ │
│ - 测试用例 2: find_max([]) → None ✓ │
│ - 测试用例 3: find_max([-1,-2]) → -1 ✓ │
│ 结果：成功 │
│ │
│ 最终输出：改进后的函数 │
│ │
└─────────────────────────────────────────────────────────────┘三、代码实现
3.1 基础实现
"""
Reflexion Agent 基础实现
基于语言反馈的自我反思学习
"""
from typing import List, Optional, Dict, Any, Callable
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
class EvaluationResult(Enum):
"""评估结果"""
SUCCESS = "success"
FAILURE = "failure"
@dataclass
class Reflection:
"""反思记录"""
trial_id: int
task: str
trajectory: List[str]
answer: str
failure_reason: str
improvement: str
timestamp: datetime = field(default_factory=datetime.now)
@dataclass
class Trial:
"""一次尝试"""
trial_id: int
task: str
trajectory: List[str] = field(default_factory=list)
answer: str = ""
result: Optional[EvaluationResult] = None
feedback: str = ""
class ReflectionMemory:
"""反思记忆"""
def __init__(self, max_size: int = 5):
self.reflections: List[Reflection] = []
self.max_size = max_size
def add(self, reflection: Reflection):
self.reflections.append(reflection)
if len(self.reflections) > self.max_size:
self.reflections.pop(0)
def get_context(self) -> str:
if not self.reflections:
return "暂无历史反思记录。"
context = "【历史反思】\n"
for r in self.reflections:
context += f"- 第\{r.trial_id\}次尝试：\{r.improvement\}\n"
return context
class Actor:
"""执行者：生成动作和答案"""
ACTOR_PROMPT = """
你是一个智能助手，请完成以下任务。
任务：\{task\}
\{reflection_context\}
请生成你的答案：
"""
def __init__(self, llm, tools: List = None):
self.llm = llm
self.tools = tools or []
def generate(self, task: str, reflection_context: str = "") -> Trial:
"""生成答案"""
prompt = self.ACTOR_PROMPT.format(
task=task,
reflection_context=reflection_context
)
response = self.llm(prompt)
trial = Trial(
trial_id=0,
task=task,
answer=response
)
return trial
class Evaluator:
"""评估者：评估答案质量"""
def __init__(self, eval_func: Callable = None):
self.eval_func = eval_func or self._default_eval
def _default_eval(self, task: str, answer: str) -> tuple:
"""默认评估函数"""
# 简单的启发式评估
if "错误" in answer or "失败" in answer:
return EvaluationResult.FAILURE, "答案包含错误标记"
return EvaluationResult.SUCCESS, "答案看起来合理"
def evaluate(self, trial: Trial) -> tuple:
"""评估一次尝试"""
result, feedback = self.eval_func(trial.task, trial.answer)
trial.result = result
trial.feedback = feedback
return result, feedback
class SelfReflector:
"""反思器：生成反思文本"""
REFLECTION_PROMPT = """
任务：\{task\}
你的答案：
\{answer\}
评估结果：失败
反馈：\{feedback\}
请分析失败原因，并给出改进建议：
1. 失败原因是什么？
2. 应该如何改进？
反思：
"""
def __init__(self, llm):
self.llm = llm
def reflect(self, trial: Trial) -> Reflection:
"""生成反思"""
prompt = self.REFLECTION_PROMPT.format(
task=trial.task,
answer=trial.answer,
feedback=trial.feedback
)
reflection_text = self.llm(prompt)
return Reflection(
trial_id=trial.trial_id,
task=trial.task,
trajectory=trial.trajectory,
answer=trial.answer,
failure_reason=trial.feedback,
improvement=reflection_text
)
class ReflexionAgent:
"""Reflexion Agent"""
def __init__(
self,
llm,
eval_func: Callable = None,
max_trials: int = 3,
verbose: bool = True
):
self.llm = llm
self.actor = Actor(llm)
self.evaluator = Evaluator(eval_func)
self.reflector = SelfReflector(llm)
self.memory = ReflectionMemory()
self.max_trials = max_trials
self.verbose = verbose
def run(self, task: str) -> str:
"""运行 Agent"""
best_answer = None
for trial_id in range(self.max_trials):
if self.verbose:
print(f"\n{'='*50}")
print(f"Trial {trial_id + 1}/{self.max_trials}")
print('='*50)
# 1. Actor 生成答案
reflection_context = self.memory.get_context()
trial = self.actor.generate(task, reflection_context)
trial.trial_id = trial_id
if self.verbose:
print(f"\n[Actor] 生成答案:\n\{trial.answer[:200]\}...")
# 2. Evaluator 评估
result, feedback = self.evaluator.evaluate(trial)
if self.verbose:
print(f"\n[Evaluator] 结果: \{result.value\}")
print(f"反馈: \{feedback\}")
# 3. 成功则返回
if result == EvaluationResult.SUCCESS:
if self.verbose:
print(f"\n成功！返回答案")
return trial.answer
# 4. 失败则反思
best_answer = trial.answer # 保存最佳答案
reflection = self.reflector.reflect(trial)
self.memory.add(reflection)
if self.verbose:
print(f"\n[Reflector] 反思:\n\{reflection.improvement[:200]\}...")
# 达到最大尝试次数
if self.verbose:
print(f"\n达到最大尝试次数，返回最佳答案")
return best_answer or "无法完成任务"
# 使用示例
if __name__ == "__main__":
from langchain_openai import OpenAI
# 定义评估函数
def code_eval(task: str, answer: str) -> tuple:
"""代码评估函数"""
# 检查是否包含代码块
if "```python" not in answer:
return EvaluationResult.FAILURE, "答案未包含 Python 代码"
# 提取代码并执行测试
# 这里简化处理
try:
# 执行代码测试...
return EvaluationResult.SUCCESS, "代码测试通过"
except Exception as e:
return EvaluationResult.FAILURE, f"代码执行错误: \{str(e)\}"
# 创建 Agent
llm = OpenAI(temperature=0)
agent = ReflexionAgent(
llm=llm,
eval_func=code_eval,
max_trials=3,
verbose=True
)
# 运行
result = agent.run("编写一个 Python 函数，实现冒泡排序")
print(f"\n最终结果:\n\{result\}")3.2 使用 LangGraph 实现
"""
使用 LangGraph 实现 Reflexion
"""
from typing import TypedDict, List, Optional
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
class ReflexionState(TypedDict):
"""Reflexion 状态"""
task: str
reflections: List[str]
answer: str
result: str # "success" | "failure"
feedback: str
trial_count: int
def create_reflexion_graph(max_trials: int = 3):
"""创建 Reflexion 图"""
llm = ChatOpenAI(model="gpt-4", temperature=0)
# Actor 节点
def actor_node(state: ReflexionState):
reflections = state.get("reflections", [])
reflection_context = "\n".join(reflections) if reflections else ""
prompt = f"""任务：\{state['task']\}
历史反思：
\{reflection_context\}
请生成答案："""
response = llm.invoke(prompt)
return {
"answer": response.content,
"trial_count": state.get("trial_count", 0) + 1
}
# Evaluator 节点
def evaluator_node(state: ReflexionState):
# 简化的评估逻辑
answer = state["answer"]
# 这里应该有真实的评估逻辑
if len(answer) > 50 and "错误" not in answer:
return {"result": "success", "feedback": "答案合理"}
else:
return {"result": "failure", "feedback": "答案不够完整"}
# Reflector 节点
def reflector_node(state: ReflexionState):
prompt = f"""任务：\{state['task']\}
答案：\{state['answer']\}
失败原因：\{state['feedback']\}
请分析失败原因并给出改进建议："""
response = llm.invoke(prompt)
reflections = state.get("reflections", [])
reflections.append(response.content)
return {"reflections": reflections}
# 条件判断
def should_continue(state: ReflexionState):
if state["result"] == "success":
return "end"
if state["trial_count"] >= max_trials:
return "end"
return "reflect"
# 创建图
workflow = StateGraph(ReflexionState)
# 添加节点
workflow.add_node("actor", actor_node)
workflow.add_node("evaluator", evaluator_node)
workflow.add_node("reflector", reflector_node)
# 设置入口
workflow.set_entry_point("actor")
# 添加边
workflow.add_edge("actor", "evaluator")
workflow.add_conditional_edges(
"evaluator",
should_continue,
{
"reflect": "reflector",
"end": END
}
)
workflow.add_edge("reflector", "actor")
return workflow.compile()
# 使用示例
if __name__ == "__main__":
graph = create_reflexion_graph(max_trials=3)
result = graph.invoke({
"task": "编写一个快速排序算法",
"reflections": [],
"trial_count": 0
})
print(f"最终答案: \{result['answer']\}")3.3 代码生成场景实现
"""
Reflexion 在代码生成场景的应用
"""
class CodeReflexionAgent:
"""代码生成 Reflexion Agent"""
CODE_EVAL_PROMPT = """
评估以下代码是否正确完成了任务。
任务：\{task\}
代码：
```python
\{code\}测试用例：{test_cases}
请判断代码是否正确，如果错误请说明原因。 输出格式： 结果：成功/失败 原因：... """
def init(self, llm, max_trials: int = 3): self.llm = llm self.max_trials = max_trials self.memory = ReflectionMemory()
def generate_code(self, task: str, test_cases: str) -> str: """生成代码"""
for trial in range(self.max_trials):
1. 生成代码
reflection_context = self.memory.get_context() code = self._generate(task, reflection_context)
2. 评估代码
result, feedback = self._evaluate(task, code, test_cases)
if result == EvaluationResult.SUCCESS: return code
3. 反思
reflection = self._reflect(task, code, feedback) self.memory.add(reflection)
return code # 返回最后一次尝试
def _generate(self, task: str, context: str) -> str: """生成代码""" prompt = f""" 任务：{task}
{context}
请编写 Python 代码完成任务： """ return self.llm(prompt)
def _evaluate(self, task: str, code: str, test_cases: str) -> tuple: """评估代码"""
方法1：实际执行测试
try: exec_globals = exec(code, exec_globals)
运行测试用例...
return EvaluationResult.SUCCESS, "所有测试通过" except Exception as e: return EvaluationResult.FAILURE, f"执行错误: {str(e)}"
方法2：LLM 评估
prompt = self.CODE_EVAL_PROMPT.format(...)
response = self.llm(prompt)
...
def _reflect(self, task: str, code: str, feedback: str) -> Reflection: """生成反思""" prompt = f""" 代码任务：{task} 代码： {code}
失败原因：{feedback}
请分析问题并给出改进建议： """ reflection_text = self.llm(prompt)
return Reflection( trial_id=0, task=task, trajectory=[code], answer=code, failure_reason=feedback, improvement=reflection_text )
---
## 四、适用场景
### 4.1 最佳适用场景
| 场景类型 | 具体示例 | Reflexion 优势 |
|----------|----------|----------------|
| **代码生成** | 算法实现、函数编写 | 编译/测试反馈明确 |
| **决策任务** | 策略选择、路径规划 | 可验证正确性 |
| **复杂推理** | 数学证明、逻辑推理 | 步骤可追溯 |
| **知识问答** | 多跳问答 | 答案可验证 |
### 4.2 场景详解
┌─────────────────────────────────────────────────────────────┐ │ Reflexion 适用场景详解 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 1. 代码生成场景 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 任务：实现二分查找算法 │ │ │ │ │ │ │ │ Trial 1: │ │ │ │ 代码：缺少边界处理 │ │ │ │ 测试：find([1,2,3], 4) → IndexError │ │ │ │ 反思：需要处理元素不存在的情况 │ │ │ │ │ │ │ │ Trial 2: │ │ │ │ 代码：添加 -1 返回 │ │ │ │ 测试：所有测试通过 ✓ │ │ │ │ │ │ │ │ 优势：从编译/测试错误中快速学习 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 2. 决策任务场景 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 任务：规划最优送货路线 │ │ │ │ │ │ │ │ Trial 1: │ │ │ │ 方案：A→B→C→D │ │ │ │ 评估：总路程 100km，超时 ❌ │ │ │ │ 反思：没有考虑时间窗口约束 │ │ │ │ │ │ │ │ Trial 2: │ │ │ │ 方案：A→C→B→D │ │ │ │ 评估：总路程 80km，满足时间窗口 ✓ │ │ │ │ │ │ │ │ 优势：明确的目标函数，反馈清晰 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 3. 复杂推理场景 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 任务：证明数学命题 │ │ │ │ │ │ │ │ Trial 1: │ │ │ │ 证明：步骤A → 步骤B → 步骤C │ │ │ │ 评估：步骤B推论有误 ❌ │ │ │ │ 反思：步骤B需要额外的中间步骤 │ │ │ │ │ │ │ │ Trial 2: │ │ │ │ 证明：步骤A → 步骤B' → 步骤B → 步骤C │ │ │ │ 评估：逻辑完整 ✓ │ │ │ │ │ │ │ │ 优势：推理步骤可验证，反馈具体 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘
### 4.3 不适用场景
| 场景 | 原因 | 推荐替代方案 |
|------|------|--------------|
| **主观任务** | 难以客观评估 | 直接 LLM 生成 |
| **一次性任务** | 反思价值低 | ReAct 模式 |
| **低延迟要求** | 多次迭代耗时长 | Plan-and-Execute |
| **无验证手段** | 无法给出反馈 | 结合人工审核 |
---
## 五、局限性与优化
### 5.1 主要局限性
| 局限性 | 具体表现 | 影响 |
|--------|----------|------|
| **评估依赖** | 需要可靠的评估函数 | 评估不准导致反思无效 |
| **迭代开销** | 多次尝试消耗资源 | 成本和时间增加 |
| **反思质量** | 反思可能不准确 | 错误反思导致错误改进 |
| **记忆容量** | 滑动窗口有限 | 早期经验可能丢失 |
### 5.2 优化策略
┌─────────────────────────────────────────────────────────────┐ │ Reflexion 优化策略 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 1. 高质量评估函数 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 问题：评估不准确导致反思方向错误 │ │ │ │ │ │ │ │ 优化方案： │ │ │ │ • 多维度评估：正确性、完整性、效率 │ │ │ │ • 自动化测试：单元测试、集成测试 │ │ │ │ • LLM 评估：使用更强的模型评估结果 │ │ │ │ • 人工审核：关键任务加入人工确认 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 2. 结构化反思 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 问题：反思文本过于笼统 │ │ │ │ │ │ │ │ 优化方案：使用结构化格式 │ │ │ │ │ │ │ │ 反思模板： │ │ │ │ 1. 失败原因：[具体原因] │ │ │ │ 2. 问题定位：[哪一步出错] │ │ │ │ 3. 改进建议：[具体措施] │ │ │ │ 4. 注意事项：[需要避免的问题] │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 3. 渐进式改进 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 问题：每次从零开始效率低 │ │ │ │ │ │ │ │ 优化方案： │ │ │ │ • 保留成功部分的代码/内容 │ │ │ │ • 只修改失败的部分 │ │ │ │ • 使用 diff 方式应用改进 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ │ 4. 智能记忆管理 │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 问题：反思记忆容量有限 │ │ │ │ │ │ │ │ 优化方案： │ │ │ │ • 向量化存储：相似任务检索相关反思 │ │ │ │ • 摘要压缩：定期压缩历史反思 │ │ │ │ • 优先级排序：保留最有价值的反思 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘
### 5.3 与其他模式结合
```python
"""
Reflexion + ReAct 混合架构
"""
class ReflexionReActAgent:
"""结合 Reflexion 的 ReAct Agent"""
def run(self, task: str) -> str:
reflections = []
for trial in range(self.max_trials):
# 使用 ReAct 执行
result = self.react_agent.run(
task,
reflection_context=reflections
)
# 评估结果
if self.evaluator.is_success(result):
return result
# 反思
reflection = self.reflector.reflect(task, result)
reflections.append(reflection)
return result六、面试常见问题
Q1: Reflexion 如何实现"无需微调的强化学习"？
A:
核心机制：
传统 RL：
环境 → Agent → Action → Reward（标量）→ 更新权重
Reflexion：
环境 → Actor → Action → Evaluator → 语言反馈 → Self-Reflector → 反思文本
↓
存入上下文，下次参考关键创新：
- 语言反馈替代标量奖励：提供更丰富的信息
- 上下文学习：通过 Prompt 注入反思经验
- 无需权重更新：不改变模型参数
优势对比：
| 维度 | 传统 RL | Reflexion |
|---|---|---|
| 奖励信息 | 单一数值 | 详细文本 |
| 学习方式 | 权重更新 | 上下文学习 |
| 数据需求 | 大量样本 | 少量尝试 |
| 部署成本 | 高（需要训练） | 低（无需微调） |
Q2: Reflexion 适用于哪些任务？不适用于哪些？
A:
适用任务特征：
- ✅ 有明确的评估标准（代码可测试、决策可验证）
- ✅ 失败原因可分析（能给出具体反馈）
- ✅ 改进方向明确（知道怎么修正）
不适用任务特征：
- ❌ 主观评估任务（创意写作、艺术创作）
- ❌ 一次性任务（反思价值低）
- ❌ 无验证手段的任务（难以给出反馈）
具体场景判断：
| 任务类型 | 是否适用 | 原因 |
|---|---|---|
| 代码生成 | ✅ 适用 | 编译/测试反馈明确 |
| 数学推理 | ✅ 适用 | 答案可验证 |
| 创意写作 | ❌ 不适用 | 主观评估，无明确标准 |
| 数据分析 | ✅ 适用 | 结果可验证 |
| 客服对话 | ❌ 不适用 | 难以自动化评估质量 |
Q3: Reflexion 的反思记忆如何管理？
A:
记忆管理策略：
class ReflectionMemory:
"""反思记忆管理"""
def __init__(self, max_size: int = 5):
self.reflections = []
self.max_size = max_size # 滑动窗口大小
def add(self, reflection):
self.reflections.append(reflection)
# 只保留最近的 N 条
if len(self.reflections) > self.max_size:
self.reflections.pop(0)
def get_relevant(self, task: str, top_k: int = 3):
"""检索相关反思"""
# 使用向量相似度检索
# 或使用关键词匹配
pass管理策略选择：
| 策略 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 滑动窗口 | 实现简单 | 可能丢失早期经验 | 简单任务 |
| 向量检索 | 相关性强 | 需要额外存储 | 复杂任务 |
| 摘要压缩 | 信息保留 | 需要额外处理 | 长期记忆 |
Q4: 如何设计高质量的评估函数？
A:
评估函数设计原则：
def design_evaluator():
"""
评估函数设计原则
"""
# 1. 多维度评估
def evaluate_multi_dim(answer):
scores = {
"correctness": check_correctness(answer),
"completeness": check_completeness(answer),
"efficiency": check_efficiency(answer),
"readability": check_readability(answer)
}
return scores
# 2. 可操作的反馈
def evaluate_with_feedback(answer):
if not check_correctness(answer):
return "失败：答案逻辑有误，请检查第3步的推理"
if not check_completeness(answer):
return "失败：答案不完整，缺少边界情况处理"
return "成功"
# 3. 自动化测试
def evaluate_code(code, test_cases):
for test in test_cases:
result = execute(code, test["input"])
if result != test["expected"]:
return f"失败：测试用例 \{test['name']\} 未通过"
return "成功"不同场景的评估函数：
| 场景 | 评估方法 | 示例 |
|---|---|---|
| 代码生成 | 单元测试 | pytest 运行结果 |
| 数学推理 | 答案验证 | 数值比对 |
| 决策任务 | 目标函数 | 成本/收益计算 |
| 知识问答 | 精确匹配 | 字符串比对 |
Q5: Reflexion 与 Plan-and-Execute 如何结合？
A:
结合方案：
class ReflexionPlanExecuteAgent:
"""Reflexion + Plan-Execute 混合"""
def run(self, task: str) -> str:
reflections = []
for trial in range(self.max_trials):
# 1. 规划阶段（参考反思）
plan = self.planner.plan(task, reflections)
# 2. 执行阶段
result = self.executor.execute(plan)
# 3. 评估
if self.evaluator.is_success(result):
return result
# 4. 反思
reflection = self.reflector.reflect(
task, plan, result
)
reflections.append(reflection)
return result结合优势：
- Plan-and-Execute 提供结构化执行
- Reflexion 提供失败恢复能力
- 两者互补，提升整体可靠性
Q6: Reflexion 的 Token 消耗如何优化？
A:
Token 优化策略：
| 策略 | 方法 | 效果 |
|---|---|---|
| 反思压缩 | 摘要反思文本 | 减少 50% |
| 选择性反思 | 只保留关键反思 | 减少 30% |
| 模板化输出 | 使用结构化模板 | 减少 20% |
| 早期终止 | 成功即停止 | 减少迭代次数 |
优化代码示例：
def compress_reflection(reflection: str) -> str:
"""压缩反思文本"""
# 提取关键信息
lines = reflection.split("\n")
compressed = []
for line in lines:
if any(kw in line for kw in ["原因", "建议", "注意"]):
compressed.append(line)
return "\n".join(compressed[:5]) # 最多5行七、总结
| 概念 | 一句话总结 | 面试关键词 |
|---|---|---|
| Reflexion | 基于语言反馈的自我反思学习框架 | 无需微调、迭代改进 |
| Actor | 执行者，生成动作序列和答案 | 执行、生成 |
| Evaluator | 评估者，判断结果质量 | 评估、反馈 |
| Self-Reflector | 反思器，分析失败原因 | 反思、改进建议 |
| 核心创新 | 语言反馈替代标量奖励 | 信息丰富、可操作 |
| 适用场景 | 有明确评估标准的任务 | 代码生成、决策任务 |
一句话总结：Reflexion 通过"执行-评估-反思-改进"的闭环，让 Agent 从失败中学习，无需微调即可提升表现，是构建可靠 Agent 的关键技术。
最后更新：2026年3月18日