ReAct、Plan-and-Execute、Reflection 三种范式有什么核心区别？实际项目怎么选型？

// === Maven 依赖 ===
// <dependency>
//     <groupId>dev.langchain4j</groupId>
//     <artifactId>langchain4j</artifactId>
//     <version>1.0.0</version>
// </dependency>
// <dependency>
//     <groupId>dev.langchain4j</groupId>
//     <artifactId>langchain4j-open-ai</artifactId>
//     <version>1.0.0</version>
// </dependency>

import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

public class ReActAgentDemo {

    // 1. 定义工具（LangChain4j 通过 @Tool 注解自动识别）
    public static class WeatherTools {

        @Tool("查询某个城市的实时天气")
        public String getWeather(String city) {
            // 实际项目里这里调外部天气 API
            return city + " 今天晴，气温 26℃";
        }

        @Tool("查询某个城市的景点推荐")
        public String getAttractions(String city) {
            return city + " 推荐景点：故宫、颐和园、天坛";
        }
    }

    // 2. 定义 Agent 接口
    interface TravelAssistant {
        String chat(String userMessage);
    }

    public static void main(String[] args) {
        // 配置 LLM（这里用 OpenAI，生产可换成通义千问、DeepSeek 等）
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o")
                .build();

        // 3. 构建 Agent —— LangChain4j 底层自动走 ReAct 循环
        TravelAssistant agent = AiServices.builder(TravelAssistant.class)
                .chatLanguageModel(model)
                .chatMemory(MessageWindowChatMemory.withMaxMessages(20))
                .tools(new WeatherTools())  // 注册工具
                .build();

        // 4. 测试：模型会自动 Thought → Action → Observation 多轮循环
        String answer = agent.chat("我想去北京旅游，先帮我看看天气，再推荐几个景点");
        System.out.println(answer);
    }
}

// === Maven 依赖 ===
// <dependency>
//     <groupId>dev.langchain4j</groupId>
//     <artifactId>langchain4j-agentic</artifactId>
//     <version>1.0.0</version>
// </dependency>

import dev.langchain4j.agentic.*;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class PlanAndExecuteDemo {

    // 1. 定义各个执行步骤（每个方法对应 Plan 中的一个步骤）
    public static class ResearchWorkflow {

        @AgentTask(description = "第一步：根据用户问题收集背景资料")
        public String research(String topic) {
            // 实际项目里这里可以调用搜索工具 / RAG 检索
            return "已收集到关于 " + topic + " 的核心资料：...";
        }

        @AgentTask(description = "第二步：基于资料撰写大纲")
        public String outline(String researchResult) {
            return "大纲：\n1. 背景\n2. 核心分析\n3. 结论";
        }

        @AgentTask(description = "第三步：根据大纲完成正文")
        public String writeContent(String outline) {
            return "正文：基于上述大纲展开的完整文章...";
        }
    }

    public static void main(String[] args) {
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o")
                .build();

        // 2. 用 AgenticOrchestrator 串成工作流 —— 规划 + 执行一体化
        //    底层逻辑：Planner LLM 决定调用顺序，Executor 逐步执行
        var workflow = AiServices.builder(ResearchWorkflow.class)
                .chatLanguageModel(model)
                .build();

        // 3. 触发执行
        String result = workflow.research("AI Agent 范式选型");
        System.out.println(result);
    }
}

// === Maven 依赖 ===
// <dependency>
//     <groupId>org.springframework.ai</groupId>
//     <artifactId>spring-ai-starter-model-openai</artifactId>
// </dependency>

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.stereotype.Service;

@Service
public class ReflectionAgent {

    private final ChatClient executorClient;   // 执行器：生成答案
    private final ChatClient reflectorClient;  // 反思器：批判答案

    private static final int MAX_ITERATIONS = 3;

    public ReflectionAgent(ChatModel chatModel) {
        this.executorClient = ChatClient.builder(chatModel)
                .defaultSystem("你是一个严谨的技术答主，请根据问题生成高质量回答。")
                .build();

        // 反思器用不同的 system prompt，扮演 "面试官" 角色
        this.reflectorClient = ChatClient.builder(chatModel)
                .defaultSystem("""
                    你是一个严格的技术面试官，请批判性地评估下面的回答。
                    如果回答存在事实错误、逻辑漏洞、遗漏关键点，请明确指出并给出改进建议。
                    如果回答已经足够好，请回复 "PASS"。
                    """)
                .build();
    }

    public String answerWithReflection(String question) {
        // 1. 初次生成
        String currentAnswer = executorClient.prompt()
                .user(question)
                .call()
                .content();

        // 2. 反思 + 迭代
        for (int i = 0; i < MAX_ITERATIONS; i++) {
            String reflection = reflectorClient.prompt()
                    .user("问题：" + question + "\n\n当前回答：" + currentAnswer)
                    .call()
                    .content();

            // 反思器认为合格，提前退出
            if (reflection.contains("PASS")) {
                break;
            }

            // 带着反思建议重新生成
            currentAnswer = executorClient.prompt()
                    .user("""
                        问题：%s
                        上一版回答：%s
                        反思建议：%s
                        请根据反思建议，重新生成更好的回答。
                        """.formatted(question, currentAnswer, reflection))
                    .call()
                    .content();
        }

        return currentAnswer;
    }
}