Spring AI Alibaba构建自我反思的Reflection Agent

在AI应用开发中，如何让AI像人类一样具备自我反思和持续改进的能力？ 文将深入解析Reflection Agent的核心原理

使用Spring AI Alibaba Graph框架，构建一个能够自我评估、迭代优化的智能Agent

什么是Reflection Agent？

核心工作原理

想象一下，当你写完一篇文章后，你会怎么做？

1. 初稿创作：根据主题写出第一版内容
2. 自我审视：重新阅读，发现问题和不足
3. 反思改进：基于发现的问题进行修改
4. 迭代优化：重复这个过程直到满意

这正是Reflection Agent的工作方式！它通过生成-反思-改进的循环，让AI具备了自我评估和持续优化的能力。

Reflection模式的核心价值

为什么Reflection Agent如此重要？

• 质量保证：通过多轮迭代确保输出质量
• 自我优化：具备自我发现问题和改进的能力
• 持续提升：每次迭代都在前一版本基础上改进
• 复杂任务处理：适合需要深度思考和精细化处理的任务

理论背景

Reflection Agent基于心理学中的元认知理论（Flavell, 1976），让AI具备"对思维的思维"能力。近期研究如Reflexion (Shinn et al., 2023)提出了Actor-Evaluator-Self-Reflection架构，通过生成→评估→改进的循环显著提升AI输出质量。

传统AI的局限性

传统的AI系统通常是"一次性生成"：

• 缺乏自省：生成内容后无法自我评估质量
• 无法改进：即使输出有明显问题也不会主动修正
• 质量不稳定：无法保证每次输出都达到最佳水平

Reflection Agent的突破

基于前述学术研究，Reflection Agent将元认知理论成功应用到AI系统中，让AI具备了：

• 自我审视：能够客观评估自己的输出质量（元认知知识）
• 问题发现：主动识别内容中的不足和改进空间
• 迭代优化：基于自我评估结果持续改进输出（元认知调节）
• 质量保证：通过多轮反思确保达到预期标准

这种能力让AI从"工具"进化为"智能助手"，具备了真正的自主学习和改进能力

Spring AI：代码审查Reflection Agent

核心架构

Reflection Agent采用生成→评估→改进的双节点协作模式：

ReflectAgent核心类解析

在深入了解节点实现之前，我们先来理解Reflection Agent的核心控制类——ReflectAgent。这个类是整个反思机制的"大脑"，负责协调生成节点和评判节点之间的交互。

核心架构设计

public class ReflectAgent {

    // 核心常量定义
    public static final String MESSAGES="messages";           // 消息状态键
    public static final String ITERATION_NUM="iteration_num"; // 迭代计数键

    // 节点标识
    private final String REFLECTION_NODE_ID="reflection";     // 反思节点ID
    private final String GRAPH_NODE_ID="graph";              // 生成节点ID

    // 核心组件
    privateint maxIterations;          // 最大迭代次数
    private NodeAction graph;           // 内容生成节点
    private NodeAction reflection;      // 质量评判节点
    private StateGraph stateGraph;      // 状态图
    private CompiledGraph compiledGraph; // 编译后的图
}

反思图构建机制

ReflectAgent的核心是createReflectionGraph方法，它构建了一个复杂的状态图来实现反思循环：

public StateGraph createReflectionGraph(NodeAction graph, NodeAction reflection, int maxIterations)
        throws GraphStateException {

    StateGraphstateGraph=newStateGraph(() -> {
        HashMap<String, KeyStrategy> keyStrategyHashMap = newHashMap<>();
        keyStrategyHashMap.put(MESSAGES, newReplaceStrategy());      // 消息替换策略
        keyStrategyHashMap.put(ITERATION_NUM, newReplaceStrategy()); // 迭代计数替换策略
        return keyStrategyHashMap;
    })
    .addNode(GRAPH_NODE_ID, node_async(graph))           // 添加生成节点
    .addNode(REFLECTION_NODE_ID, node_async(reflection)) // 添加反思节点
    .addEdge(START, GRAPH_NODE_ID)                       // 从开始到生成节点

    // 关键：条件边控制流程
    .addConditionalEdges(GRAPH_NODE_ID, edge_async(this::graphCount),
        Map.of(REFLECTION_NODE_ID, REFLECTION_NODE_ID, END, END))
    .addConditionalEdges(REFLECTION_NODE_ID, edge_async(this::apply),
        Map.of(GRAPH_NODE_ID, GRAPH_NODE_ID, END, END));

    return stateGraph;
}

智能流程控制

1. 迭代计数控制 (graphCount方法)

public String graphCount(OverAllState state)throws Exception {
    Optional<Object> iterationNumOptional = state.value(ITERATION_NUM);

    if (!iterationNumOptional.isPresent()) {
        // 初始化迭代计数器
        state.updateState(Map.of(ITERATION_NUM, 1));
    } else {
        IntegeriterationNum= (Integer) iterationNumOptional.get();

        // 检查是否达到最大迭代次数
        if (iterationNum >= maxIterations) {
            logger.info("达到迭代限制，停止反思循环");
            return END;  // 结束流程
        }

        // 增加迭代计数
        state.updateState(Map.of(ITERATION_NUM, iterationNum + 1));
    }

    return REFLECTION_NODE_ID;  // 继续到反思节点
}

2. 消息类型判断 (apply方法)

public String apply(OverAllState state)throws Exception {
    List<Message> messages = (List<Message>) state.value(MESSAGES).get();

    if (messages.isEmpty()) {
        return END;  // 没有消息，结束流程
    }

    // 关键判断：如果最后一条消息是Assistant消息，说明生成完成
    if (messages.get(messages.size() - 1).getMessageType().equals(MessageType.ASSISTANT)) {
        return END;  // 结束反思循环
    }

    // 如果最后一条是User消息（来自反思节点的建议），继续生成
    return GRAPH_NODE_ID;
}

执行流程图解

核心优势

1. 智能流程控制：通过条件边实现复杂的流程控制逻辑
2. 状态管理：统一管理消息状态和迭代计数
3. 灵活配置：Builder模式支持多种配置选项
4. 异步执行：所有节点都支持异步执行，提高性能
5. 日志追踪：完整的日志记录，便于调试和监控

ReflectAgent类是整个反思机制的核心，它将复杂的反思逻辑封装成简单易用的API，让开发者可以专注于业务逻辑的实现。

Spring AI 构建代码审查 ReflectAgent

下面我们通过一个具体的代码审查场景来展示如何实现ReflectAgent

/**
 * 代码生成节点 - 负责生成和改进代码
 */
public static class CodeGeneratorNode implements NodeAction {

    private final LlmNode llmNode;

    // 代码生成提示词
    private static final String CODE_PROMPT="""
        你是一位资深的软件工程师，专注于编写高质量、可维护的代码。
        请根据需求生成清晰、规范的代码。
        如果收到代码审查意见，请基于建议改进代码。
        关注代码的可读性、性能、安全性和错误处理。
        只返回代码和必要的注释。
    """;

    public CodeGeneratorNode(ChatClient chatClient) {
        this.llmNode = LlmNode.builder()
            .systemPromptTemplate(new SystemPromptTemplate(CODE_PROMPT).render())
            .chatClient(chatClient)
            .messagesKey("messages")
            .build();
    }

    @Override
    public Map<String, Object> apply(OverAllState state)throws Exception {
        List<Message> messages = (List<Message>) state.value("messages").get();

        StateGraph subGraph= new StateGraph(() -> Map.of("messages", new AppendStrategy()))
            .addNode("generate", node_async(llmNode))
            .addEdge(START, "generate").addEdge("generate", END);

        return Map.of("messages", subGraph.compile().invoke(Map.of("messages", messages))
            .get().value("messages").orElseThrow());
    }
}

代码审查节点

接下来我们实现JudgeGraphNode来完成代码审查功能。这个节点基于源代码的JudgeGraphNode架构，但将评判标准从论文评估改为代码质量审查：

/**
 * 代码审查节点 - 负责评估代码质量并提供改进建议
 */
public static class CodeReviewerNode implements NodeAction {

    private final LlmNode llmNode;

    // 代码审查提示词
    private static final String REVIEW_PROMPT="""
        你是一位资深的代码审查专家，负责评估代码质量。
        请从以下方面进行评估：
        - 代码可读性和命名规范
        - 性能优化和算法效率
        - 安全性和错误处理
        - 设计模式和最佳实践

        请提供具体的改进建议，用中文回答。
    """;

    public CodeReviewerNode(ChatClient chatClient) {
        this.llmNode = LlmNode.builder()
            .systemPromptTemplate(newSystemPromptTemplate(REVIEW_PROMPT).render())
            .chatClient(chatClient)
            .messagesKey("messages")
            .build();
    }

    @Override
    public Map<String, Object> apply(OverAllState state)throws Exception {
        List<Message> messages = (List<Message>) state.value("messages").get();

        StateGraph subGraph= new StateGraph(() -> Map.of("messages", newAppendStrategy()))
            .addNode("review", node_async(llmNode))
            .addEdge(START, "review").addEdge("review", END);

        List<Message> result = (List<Message>) subGraph.compile()
            .invoke(Map.of("messages", messages)).get().value("messages").orElseThrow();

        int size= result.size();
        if (size > 0) result.set(size - 1, newUserMessage(result.get(size - 1).getText()));

        return Map.of("messages", result);
    }
}

配置和控制器

最后，我们将两个节点组装成完整的Reflection Agent

/**
 * 🔄 代码审查Reflection Agent配置
 */
@Configuration
public class CodeReviewConfiguration {

    @Bean
    public CompiledGraph codeReviewGraph(ChatModel chatModel)throws GraphStateException {
        ChatClientchatClient= ChatClient.builder(chatModel)
            .defaultAdvisors(newSimpleLoggerAdvisor()).build();

        ReflectAgentagent= ReflectAgent.builder()
            .graph(newCodeGeneratorNode(chatClient))    // 代码生成节点
            .reflection(newCodeReviewerNode(chatClient)) // 代码审查节点
            .maxIterations(3)                            // 最大迭代次数
            .build();

        return agent.getAndCompileGraph();
    }
}

@RestController
@RequestMapping("/code-review")
public class CodeReviewController {
    private final CompiledGraph compiledGraph;

    @PostMapping("/generate")
    public String generateCode(@RequestBody Map<String, String> request)throws GraphRunnerException {
        Stringrequirement= request.get("requirement");
        return compiledGraph.invoke(Map.of("messages", List.of(newUserMessage(requirement))))
            .get().<List<Message>>value("messages").orElseThrow()
            .stream().filter(msg -> msg.getMessageType() == MessageType.ASSISTANT)
            .reduce((first, second) -> second).map(Message::getText).orElseThrow();
    }
}

控制器实现：ReflectionController

/**
 * 🔄 Reflection Agent控制器 - 提供反思式内容生成API
 */
@RestController
@RequestMapping("/reflection")
public class ReflectionController {

    private final CompiledGraph compiledGraph;

    public ReflectionController(@Qualifier("reflectGraph") CompiledGraph compiledGraph) {
        this.compiledGraph = compiledGraph;
    }


    @GetMapping("/chat")
    public String simpleChat(String query)throws GraphRunnerException {
        return compiledGraph.invoke(Map.of(ReflectAgent.MESSAGES, List.of(newUserMessage(query))))
            .get()
            .<List<Message>>value(ReflectAgent.MESSAGES)
            .orElseThrow()
            .stream()
            .filter(msg -> msg.getMessageType() == MessageType.ASSISTANT)
            .reduce((first, second) -> second)  // 获取最终版本
            .map(Message::getText)
            .orElseThrow();
    }
}

总结

技术突破的本质

Reflection Agent不仅仅是一个技术实现，它代表了AI应用开发的一个重要转折点。传统的AI系统是"一次性生成"的黑盒，而Reflection Agent引入了元认知能力，让AI具备了类似人类专家的自我审视和持续改进能力。

引用链接