Reflection智能体模式：自我反思迭代优化实践指南

深入掌握智能体 Reflection 模式：自我审查与迭代优化的实践手册

先给出几个判断基准：当前大模型落地过程中，如何稳定输出高质量结果始终是核心挑战。Reflection 模式提供了一套成熟的解决方案——它的逻辑本质上是将人类“做完作业再检查一遍”的行为机制，迁移到智能体工程框架中。

那么，这套模式如何实际运作？为什么能显著拉高输出质量？从架构设计到业务部署，我们逐一拆解。

一、什么是 Reflection 模式？

Reflection 模式是一种赋予 AI 智能体自我审查与持续优化能力的设计范式。其底层思维源自人类的问题解决策略：给出答案后，评估其准确性与完整性，针对缺陷进行修正，直至达到预期标准。

核心流程

Reflection 模式将这一过程抽象为三个阶段的循环：

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   Generate（生成）                                           │
│     ↓                                                        │
│   Reflect（审查）──→ 达标？──→ YES ──→ 输出最终交付件            │
│     ↓                                    │                   │
│   Refine（修正）                          NO                  │
│     ↓                                                        │
│     ←──────────────┘                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

这里定义了三个关键角色：

二、为什么需要 Reflection 模式？

单纯让 LLM 一次生成回答看似快捷，实际隐患不少。答案可能缺乏关键信息——模型容易遗漏上下文；逻辑存在断层——复杂推理链路中经常断裂；表达不够精炼——结构组织松散。更严重的是，模型本身缺乏纠错机制，即使知道自己错了也无法自动修正。

植入审查流程后，局面彻底改观。智能体能主动扫描输出，定位内容缺陷；可以进行针对性调优，避免盲目重启；通过设置达标阈值，输出质量完全可测量；再加上最大迭代次数的限制，防止无限循环。这套体系的核心价值归根结底就是四字：质量可控。

三、核心设计详解

逐个拆解三个核心角色的设计要点。

3.1 Generator（生成器）

生成器负责产出原始答案，需要明确的任务定位（问答专家、代码专家、写作专家），清晰的输出标准（准确、完整、结构化），以及合适的风格约束（简明或详尽）。

示例：

const GENERATOR_PROMPT = `你是一个专业的问题解答专家。请针对用户的问题给出高质量的答案。## 要求：- 答案要准确、清晰、完整- 结构要条理分明- 如果有多个要点，请分条列出- 语言要简洁有力，避免冗余## 输出格式：直接给出你的答案，不需要任何额外解释。请开始回答：`;

3.2 Reflector（审查者）

审查者是整个模式的核心环节，需要从多个维度评估答案质量。主要检查的维度涵盖：准确性（事实错误或逻辑漏洞？）、完整性（是否全面覆盖问题要点？）、清晰度（是否容易理解？）、结构（组织是否合理？层次是否递进？）、实用性（是否解决了用户的真实需求？）。

示例：

const REFLECTOR_PROMPT = `你是一个严格的答案审查专家。请审视给定的答案，找出其中的不足之处。## 审查维度：1. **准确性**：答案是否正确？有没有事实错误或逻辑漏洞？2. **完整性**：答案是否全面覆盖了问题？有没有遗漏的重要信息？3. **清晰度**：答案是否易于理解？表达是否清晰？4. **结构**：答案的组织是否合理？层次是否分明？5. **实用性**：答案是否解决了用户的实际需求？## 输出格式：如果答案已经非常优秀，输出：SATISFIED如果需要改进，输出：CRITIQUE: [具体的问题和不足]SUGGESTION: [具体的改进建议]`;

3.3 Refiner（优化者）

优化者根据审查意见进行定向修正。它需要针对审查中指出的问题逐一调优，同时保留答案中正确的部分，避免引入新的缺陷。最终输出的修正版答案应当更准确、更完整、更清晰。

const REFINE_PROMPT = `你是一个答案改进专家。请根据审查意见优化之前的答案。## 原始问题：{question}## 当前答案：{current_answer}## 审查意见：{critique}## 改进建议：{suggestion}## 要求：- 针对审查中指出的问题逐一改进- 保留答案中正确的部分- 不要引入新的问题- 改进后的答案要更加准确、完整、清晰请输出改进后的答案：`;

四、Node.js 完整实现

接下来是具体的代码实现。这部分我们围绕一个核心类来展开。

4.1 智能体类设计

class ReflectionAgent {
    /**
     * @param {Object} llm - LLM 客户端实例
     * @param {Object} options - 配置选项
     * @param {number} options.maxIterations - 最大审查轮数（默认3）
     * @param {string} options.taskType - 任务类型（qa/code/writing/math）
     */
    constructor(llm, options = {}) {
        this.llm = llm;
        this.maxIterations = options.maxIterations || 3;
        this.taskType = options.taskType || 'qa';
        // 根据任务类型定制提示词
        this.customizePrompts(this.taskType);
    }

    /**
     * 根据任务类型定制提示词
     */
    customizePrompts(taskType) {
        const taskConfigs = {
            'qa': {
                generatorExtra: '回答要准确、简洁，直击问题核心。',
                reflectorExtra: '重点检查答案的准确性、完整性和实用性。'
            },
            'code': {
                generatorExtra: '代码要清晰、高效，遵循最佳实践，包含必要的注释。',
                reflectorExtra: '重点检查：语法正确性、逻辑完整性、边界处理、性能优化、代码风格。'
            },
            'writing': {
                generatorExtra: '文章要结构清晰、语言流畅、观点明确。',
                reflectorExtra: '重点检查：逻辑连贯性、表达清晰度、论据充分性、文笔质量。'
            },
            'math': {
                generatorExtra: '解题步骤要清晰完整，每一步都要有依据。',
                reflectorExtra: '重点检查：计算正确性、步骤完整性、逻辑严密性。'
            }
        };

        const config = taskConfigs[taskType] || taskConfigs['qa'];
        this.generatorPrompt = GENERATOR_PROMPT + '\n' + config.generatorExtra;
        this.reflectorPrompt = REFLECTOR_PROMPT + '\n' + config.reflectorExtra;
    }
}

4.2 核心方法实现

先看生成方法：

/**
 * 生成初始答案
 */
async generate(question) {
    console.log(' ???? 正在生成答案...');
    const response = await this.llm.thinkSync([
        { role: 'system', content: this.generatorPrompt },
        { role: 'user', content: question }
    ]);
    return response;
}

然后是审查方法：

/**
 * 审查当前答案
 */
async reflect(question, answer) {
    console.log(' ???? 正在审查答案...');
    const reflectPrompt = `原始问题：${question}
当前答案：${answer}
请审查这个答案的质量。`;
    const response = await this.llm.thinkSync([
        { role: 'system', content: this.reflectorPrompt },
        { role: 'user', content: reflectPrompt }
    ]);

    // 解析审查结果
    if (response && response.includes('SATISFIED')) {
        return { satisfied: true, critique: null, suggestion: null };
    }

    // 提取缺陷和改进建议
    const critiqueMatch = response.match(/CRITIQUE:\s*(.*?)(?=SUGGESTION:|$)/s);
    const suggestionMatch = response.match(/SUGGESTION:\s*(.*?)$/s);

    return {
        satisfied: false,
        critique: critiqueMatch ? critiqueMatch[1].trim() : response,
        suggestion: suggestionMatch ? suggestionMatch[1].trim() : null
    };
}

优化方法：

/**
 * 根据审查结果优化答案
 */
async refine(question, currentAnswer, reflection) {
    console.log(' ✨ 正在优化答案...');
    const refinePrompt = REFINE_PROMPT
        .replace('{question}', question)
        .replace('{current_answer}', currentAnswer)
        .replace('{critique}', reflection.critique || '答案需要改进')
        .replace('{suggestion}', reflection.suggestion || '请优化答案的质量');

    const response = await this.llm.thinkSync([
        { role: 'system', content: this.generatorPrompt },
        { role: 'user', content: refinePrompt }
    ]);

    return response;
}

4.3 主运行循环

/**
 * 运行完整的 Reflection 循环
 */
async run(question) {
    console.log('\n' + '='.repeat(70));
    console.log('???? Reflection 模式智能体启动');
    console.log('='.repeat(70));
    console.log(`  任务类型: ${this.taskType}`);
    console.log(`  最大迭代轮数: ${this.maxIterations}`);
    console.log(`\n???? 用户问题: ${question}\n`);

    const history = [];
    let currentAnswer = null;
    let iteration = 0;

    // ========== Phase 1: 初始生成 ==========
    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
    console.log('???? Phase 1: Generate（初始生成）');
    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');

    currentAnswer = await this.generate(question);
    history.push({
        iteration: 0,
        phase: 'generate',
        answer: currentAnswer
    });
    console.log('\n ???? 初始答案:');
    this.printAnswer(currentAnswer);

    // ========== Phase 2-N: 审查-优化循环 ==========
    for (iteration = 1; iteration <= this.maxIterations; iteration++) {
        console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
        console.log(`???? Iteration ${iteration}: Reflect → Refine`);
        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');

        // Step 1: Reflect（审查）
        console.log('\n ???? Step 1: Reflect（审查）');
        const reflection = await this.reflect(question, currentAnswer);
        history.push({
            iteration,
            phase: 'reflect',
            ...reflection
        });

        if (reflection.satisfied) {
            console.log('\n ✅ 审查结果: 答案已达标，无需进一步优化！');
            break;
        }

        console.log('\n ⚠️发现问题:');
        console.log('    │ ???? Critique: ' + reflection.critique?.slice(0, 100));
        if (reflection.suggestion) {
            console.log('    │ ???? Suggestion: ' + reflection.suggestion?.slice(0, 100));
        }

        // Step 2: Refine（优化）
        console.log('\n ✨ Step 2: Refine（优化）');
        currentAnswer = await this.refine(question, currentAnswer, reflection);
        history.push({
            iteration,
            phase: 'refine',
            answer: currentAnswer
        });

        console.log('\n ✨ 优化后的答案:');
        this.printAnswer(currentAnswer);
    }

    // ========== 最终结果 ==========
    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
    console.log('???? 最终结果');
    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
    console.log(`  总迭代轮数: ${Math.min(iteration, this.maxIterations)}`);
    console.log('\n ???? 最终答案:');
    this.printAnswer(currentAnswer);

    return {
        question,
        finalAnswer: currentAnswer,
        iterations: Math.min(iteration, this.maxIterations),
        history,
        satisfied: iteration <= this.maxIterations
    };
}

五、运行效果展示

直接看两个实际运行的例子，效果非常直观。

示例一：问答任务（1轮迭代）

用户提问关于机器学习过拟合的问题。初始答案给出了概念解释和原因，共计528字。审查者审视后直接判定“达标”，循环仅一轮就结束。这说明对于结构清晰、定义明确的问题，LLM的单次输出质量已经足够高，Reflection模式在此充当“质量核验”的角色。

示例二：代码任务（3轮迭代）

这次要求写一个 JavaScript 的数据深拷贝函数。任务复杂度明显上升，第一轮审查发现问题——稀疏数组处理不当、缺少Symbol包装对象处理。优化后代码从856字扩展到1234字。第二轮审查又发现了Promise处理的严重逻辑问题和参数顺序设计的缺陷。后续两轮虽然因API调用失败未能进一步优化，但已经展示了关键价值：代码类任务往往需要更多迭代来打磨细节，Reflection模式能持续揪出工程师可能遗漏的边界情况。

六、支持的任务类型

Reflection 模式的可扩展性体现在，它能为不同任务类型定制差异化的审查维度。

问答类（qa）

审查重点：准确性、完整性、实用性。适用于知识问答、概念解释等场景。

代码类（code）

审查重点：语法正确性、逻辑完整性、边界处理、性能优化、代码风格。代码生成通常需要更多迭代，推荐设置较大的maxIterations值，比如5轮。

写作类（writing）

审查重点：逻辑连贯性、表达清晰度、论据充分性、文笔质量。

数学类（math）

审查重点：计算正确性、步骤完整性、逻辑严密性。

七、与其他智能体模式的对比

Reflection 模式的独特优势在于不依赖外部工具，完全依靠 LLM 自身进行质量提升。这意味着实现简单、无需额外 API 调用，同时适用于任何 LLM 支持的任务。成本也可控——迭代次数完全按需配置。

八、最佳实践建议

在实际落地中，有几条经验值得分享。

第一，迭代上限要合理。问答任务2-3轮通常足够，代码生成可能需要更多，复杂写作任务也可以适当放宽。关键是找到平衡点，在成本和质量之间做取舍。

第二，任务类型选对了效果翻倍。不同任务对应的审查维度差异很大，选择错误的类型可能导致审查方向偏离，反而浪费算力。

第三，监控审查历史很有价值。通过查看每次迭代的Critique内容和优化去向，可以判断迭代次数设置是否合理，也能帮助理解模型在哪些环节容易出问题。

第四，温度参数可以灵活调节。Generator端使用较低温度（如0）保证输出稳定，Reflector端用中等温度（如0.3）允许更丰富的审视角度，这是个实用的调优方向。

九、完整项目结构

项目结构非常简洁：

reflection-agent/
├── index.js         # 核心实现
├── package.json     # 项目配置
├── README.md        # 使用说明
├── .env.example     # 环境变量示例
└── .gitignore       # Git 忽略配置

十、总结

Reflection 模式的核心价值在于：它赋予了 AI“自我审查”的能力。通过 生成→审查→优化 的循环迭代，输出质量可以得到显著提升。质量可控、实现简单、过程透明、适用广泛，这四个关键词基本概括了它的核心优势。

适用场景也很明确：需要高质量输出的任务、单次生成效果不佳的场景、对答案准确性要求高的问题。条条大路通罗马，但Reflection模式是那条成本最低、效果最稳的路之一。