讲讲 Agent 的反思机制？为什么要用反思？具体怎么实现？

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class ReflexionAgent {

    private final ChatClient chatClient;

    // 最大反思重试次数，防止死循环烧 Token
    private static final int MAX_ITERATIONS = 3;

    public ReflexionAgent(ChatModel chatModel) {
        this.chatClient = ChatClient.builder(chatModel).build();
    }

    /**
     * 执行带反思机制的任务
     * 循环：生成 -> 执行/验证 -> 反思 -> 携带记忆重试
     */
    public String executeWithReflection(String task, List<Message> context) {
        // 反思记忆，跨轮次保留
        StringBuilder reflectionMemory = new StringBuilder();
        String lastResult = "";

        for (int i = 0; i < MAX_ITERATIONS; i++) {
            // 第 1 步：Actor 执行任务（带上历史反思记忆）
            String result = generate(task, reflectionMemory.toString(), context);
            lastResult = result;

            // 第 2 步：Evaluator 评估结果是否合格
            // 这里可以换成真正的工具执行结果，比如跑 SQL、执行代码
            EvaluationResult eval = evaluate(task, result);

            if (eval.isPassed()) {
                return result; // 通过评估，直接返回
            }

            // 第 3 步：Self-Reflection 生成反思
            String reflection = selfReflect(task, result, eval.getFeedback());
            reflectionMemory.append("【第 ").append(i + 1).append(" 轮反思】")
                           .append(reflection).append("\n\n");

            // 第 4 步：带着反思记忆进入下一轮重试
        }
        return lastResult; // 重试次数用尽，返回最后一次结果
    }

    /**
     * Actor：生成结果，带上反思记忆避免重复犯错
     */
    private String generate(String task, String reflectionMemory, List<Message> context) {
        String systemPrompt = """
            你是一个任务执行 Agent。
            请基于以下要求完成任务。
            %s
            """.formatted(
                reflectionMemory.isBlank() ? "" :
                "【历史反思，请避免重复犯错】\n" + reflectionMemory
            );

        return chatClient.prompt()
                .system(systemPrompt)
                .user(task)
                .messages(context)
                .call()
                .content();
    }

    /**
     * Evaluator：评估结果质量
     * 实际项目中建议换成可执行验证（如编译、单测、SQL 执行）
     */
    private EvaluationResult evaluate(String task, String result) {
        String evalPrompt = """
            你是一个严格的评审专家。
            任务：%s
            待评审结果：%s
            请判断结果是否合格，返回 JSON：
            {"passed": true/false, "feedback": "具体问题说明"}
            """.formatted(task, result);

        String evalResult = chatClient.prompt()
                .user(evalPrompt)
                .call()
                .content();
        // 实际项目用 StructuredOutputConverter 解析 JSON
        return parseEvaluation(evalResult);
    }

    /**
     * Self-Reflection：生成结构化反思
     * 关键：不是 "错了"，而是 "错在哪、为什么、下次怎么改"
     */
    private String selfReflect(String task, String result, String feedback) {
        String reflectPrompt = """
            你刚才执行的任务失败了，请认真反思。
            任务：%s
            你的输出：%s
            环境反馈：%s
            请用一段话总结：错在哪里、为什么会错、下次应该怎么做才能避免。
            """.formatted(task, result, feedback);

        return chatClient.prompt()
                .user(reflectPrompt)
                .call()
                .content();
    }

    private EvaluationResult parseEvaluation(String json) {
        // 简化实现，实际用 JSON 库解析
        boolean passed = json.contains("\"passed\": true");
        return new EvaluationResult(passed, json);
    }

    record EvaluationResult(boolean isPassed, String getFeedback) {}
}

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.V;
import dev.langchain4j.model.ollama.OllamaChatModel;
import dev.langchain4j.service.AiServices;

public class SelfRefineDemo {

    interface Generator {
        @SystemMessage("你是一个专业的文案撰写助手，根据要求生成内容。")
        String generate(@V("task") String task, @V("reflection") String reflection);
    }

    interface Critic {
        @SystemMessage("""
            你是一个严格的文案评审。
            指出以下文案的问题，给出具体修改建议。
            如果没有明显问题，返回 "PASS"。
            """)
        String critique(@V("content") String content);
    }

    public String refine(String task) {
        Generator generator = AiServices.builder(Generator.class)
                .chatLanguageModel(OllamaChatModel.builder().build())
                .build();
        Critic critic = AiServices.builder(Critic.class)
                .chatLanguageModel(OllamaChatModel.builder().build())
                .build();

        String content = generator.generate(task, "");
        for (int i = 0; i < 3; i++) {
            String feedback = critic.critique(content);
            if ("PASS".equals(feedback)) {
                break;
            }
            content = generator.generate(task, "上一版问题：" + feedback);
        }
        return content;
    }
}