用Spring AI Alibaba把MultiAgent实现从5天压到5小时

/** * ReAct 智能体：推理(Reasoning) + 执行(Acting) 循环模式 */public abstract classAbstractReactAgentextendsAbstractAgent {    /**     * 主执行流程     */    @Override    public Result execute(Context context){        // 循环执行 ReAct 流程        for (int i = 0; i < maxRetryTimes; i++) {            currentLoop = i;                        // === 第一步：Reasoning（推理） ===            if (!reasoning(context)) {                continue;  // 推理失败，重试            }
            // === 第二步：Acting（执行） ===            Result result = act(context);                        // 如果任务完成，退出循环            if (result.isCompleted()) {                return result;            }        }                return finalResult;    }
    /**     * 推理阶段：让 LLM 思考并决策     */    private boolean reasoning(Context context){        // 1. 构建提示词（包含历史对话、可用工具等）        currentPrompt = buildPrompt(context);
        // 2. 调用 LLM        llmResponse = callLLM(currentPrompt, availableTools);
        // 3. 解析 LLM 响应        toolCalls = extractToolCalls(llmResponse);        textResponse = extractText(llmResponse);
        // 4. 判断是否有有效输出        return hasToolCalls || hasTextResponse;    }
    /**     * 执行阶段：调用工具并获取结果     */    private Result act(Context context){        // 情况1：没有工具调用，直接返回文本        if (toolCalls.isEmpty()) {            return Result.completed(textResponse);        }
        // 情况2：执行工具调用        try {            // 执行工具            toolResult = executeTools(toolCalls);
            // 更新记忆（将工具结果加入对话历史）            updateMemory(toolResult);
            // 检查是否可以终止            if (canTerminate(toolCalls)) {                return Result.completed(toolResult);            }
            // 继续下一轮循环            return Result.inProgress(toolResult);
        } catch (Exception e) {            return Result.error(e.getMessage());        }    }
    /**     * 构建提示词（由子类实现）     */    protected abstract Prompt buildPrompt(Context context);
    /**     * 更新记忆（由子类实现）     */    protected abstract voidupdateMemory(String toolResult);}

ReactAgent reactAgent = ReactAgent.builder()    .name(agentName)    //模型对象，spring-ai的ChatModel    .model(chatModel)    //系统提示词    .systemPrompt(systemPrompt)    //工具列表，spring-ai的ToolCallback    .tools(Lists.newArrayList(tool1, tool2,..))    //流程定制：interceptors    .interceptors(Lists.newArrayList(interceptor1,..))    //扩展机制：hooks    .hooks(Lists.newArrayList(hook1, hook2,..))    //短期记忆内存实现    .saver(new MemorySaver())    //输出格式化    .outputType(outputTypeClass)    .build();AssistantMessage response = reactAgentWrapper.call("今天苏州天气怎么样？");String textContent = response.getText();

SequentialAgent sequentialAgent = SequentialAgent.builder()  .name("sequentialAgent")  .description("")  .subAgents(List.of(agent1, agent2))  .build();Optional<OverAllState> result = sequentialAgent.invoke("");//可以根据outputKey获取对应Agent的结果

ParallelAgent parallelAgent = ParallelAgent.builder()  .name("parallelAgent")  .description("")  .mergeOutputKey("merged_results")  .subAgents(List.of(agent1, agent2, agent3))  .mergeStrategy(new ParallelAgent.DefaultMergeStrategy())  .build();Optional<OverAllState> result = parallelAgent.invoke("");Object mergedResults = state.value("merged_results").get();

/** * Plan-Execute 模式简化示例 * 核心思想：先规划（Plan），再执行（Act），最后总结（Summarize） */publicclassSimplifiedPlanningCoordinator {
    /**     * Plan-Execute 模式的主入口     *      * @param laiContext 上下文信息     * @return 完整的规划和执行结果     */    public Planning execute(Context context){        // 第一阶段：Planning - 生成执行计划        Planning planning = generatePlanning(context);                // 第二阶段：Acting - 按计划执行步骤        executeSteps(planning, context);                // 第三阶段：Summarizing - 汇总结果        summarize(planning, context);                return planning;    }
    /**     * 阶段一：生成执行计划     * 根据用户输入，由 AI 生成结构化的执行步骤     */    private Planning generatePlanning(Context context){        // 步骤1: 创建 Planning Agent        // 这个 Agent 的职责是分析用户需求并制定执行计划        ReactAgent planningAgent = reactAgentFactory.createReactAgent(            context,             "planning"  // Agent 名称        );                // 步骤2: 构建 Planning Prompt        // 提示词中包含：用户需求、可用的 Agent 列表、当前时间等信息        String planningPrompt = buildPlanningPrompt(context);                // 步骤3: 调用 Planning Agent        // Agent 会分析需求，然后主动调用 PlanningTool 来创建计划        UserMessage userMessage = new UserMessage(planningPrompt);        AssistantMessage response = planningAgent.call(userMessage);                // 步骤4: 获取生成的计划        // PlanningTool 已经将计划保存到上下文中了        Planning planning = getPlanningFromContext(context);                return planning;    }
    /**     * 阶段二：按计划执行各个步骤     * 这是 Act 阶段，每个步骤由特定的 Agent 负责执行     */    privatevoidexecuteSteps(Planning planning, Context context){        List<PlanningStep> steps = planning.getSteps();                // 顺序执行每个步骤        for (PlanningStep step : steps) {            // 1. 获取该步骤对应的 Agent            String agentName = step.getAgent();            ReactAgent agent = reactAgentFactory.createReactAgent(              context,               agentName  // Agent 名称            );                        // 2. 构造该步骤的执行提示词            UserMessage userMessage = buildStepPrompt(step, context);                        // 3. 调用 Agent 执行            AssistantMessage response = agent.call(userMessage);                        // 4. 保存执行结果            step.setResult(response.getText());            step.markAsCompleted();        }    }
    /**     * 阶段三：汇总所有步骤的执行结果     * 由专门的总结 Agent 将各步骤结果整合成最终答案     */    privatevoidsummarize(Planning planning, Context context){        // 1. 收集所有步骤的执行结果        String allStepsResults = collectAllResults(planning);                // 2. 构造总结提示词，包含所有步骤的执行结果        UserMessage summaryPrompt = buildSummaryPrompt(allStepsResults, context);                // 3. 调用总结 Agent 生成最终结果        ReactAgentWrapper summaryAgent = createSummaryAgent();        AssistantMessage finalResult = summaryAgent.call(summaryPrompt);                // 4. 保存最终结果        context.setFinalResult(finalResult.getText());    }
    /**     * 构建 Planning Prompt     * 这是让 AI 能够制定好计划的关键     */    private String buildPlanningPrompt(Context context){        // 1. 获取所有可用的 Agent 配置        List<AgentConfig> availableAgents = getAvailableAgents(context);                // 2. 构建 Agent 信息描述        StringBuilder agentsInfo = new StringBuilder("可用的 Agent 列表：\n");        for (AgentConfig agent : availableAgents) {            agentsInfo.append("- Agent 名称: ").append(agent.getName()).append("\n");            agentsInfo.append("  描述: ").append(agent.getDescription()).append("\n");            agentsInfo.append("  擅长: ").append(agent.getCapabilities()).append("\n\n");        }                // 3. 组装完整提示词        String prompt = String.format("""            你是一个任务规划专家。请根据用户的需求制定详细的执行计划。                        用户需求：            %s                        %s                        请使用 PlanningTool 创建执行计划。计划应该：            1. 将复杂任务分解为多个可执行的步骤            2. 为每个步骤分配最合适的 Agent            3. 确保步骤之间的依赖关系合理            4. 步骤描述要清晰具体                        """,            context.getUserInput(),            agentsInfo.toString()        );                return prompt;    }      // ... 辅助方法省略 ...    private UserMessage buildStepPrompt(PlanningStep step, Context context){         return null;     }        private String collectAllResults(Planning planning){         return null;     }        private UserMessage buildSummaryPrompt(String results, Context context){         return null;     }        private ReactAgent createSummaryAgent(){         return null;     }}
/** * Planning Tool 简化示例 * 这是一个供 AI 调用的工具，用于创建执行计划 */publicclassSimplifiedPlanningToolimplementsToolFunctionInterface<SimplifiedPlanningTool.PlanInput, String> {
    @Override    public String getDescription(){        return"用于创建和管理任务执行计划的工具";    }
    /**     * Tool 的核心逻辑     * 当 AI 决定使用这个工具时，会调用此方法     */    @Override    public String apply(PlanInput input, ToolContext context){        // 1. 根据 AI 生成的计划内容创建 Planning 对象        Planning planning = createPlanningFromInput(            context,             input.getTitle(),             input.getSteps()        );                // 2. 将计划保存到上下文中，供后续执行使用        savePlanningToContext(planning);                // 3. 返回结果给 AI（告知计划已创建）        return"执行计划已创建完成";    }
    /**     * Tool 的输入参数定义     * AI 会按照这个结构生成 JSON 参数     */    publicstaticclassPlanInput {        @ToolParam(description = "计划的标题")        private String title;
        @ToolParam(description = "计划步骤列表")        private List<StepInput> steps;                // getters and setters...    }
    /**     * 单个步骤的定义     */    publicstaticclassStepInput {        @ToolParam(description = "步骤的任务描述")        private String guide;
        @ToolParam(description = "执行该步骤的 Agent 名称")        private String agent;                // getters and setters...    }        // ... 辅助方法 ...}

__START__ → PlanningNode → ExecutionNode → SummaryNode → __END__

FlowAgent    ▲    │PlanActAgent ──uses──▶ PlanActGraphBuildingStrategy    │                          │    │                          ├──creates──▶ StateGraph    │                          │    │                          ├──adds──▶ PlanningNode (ReactAgent)    │                          ├──adds──▶ ExecutionNode (NodeAction)    │                          └──adds──▶ SummaryNode (ReactAgent)    │    └──uses──▶ PlanActTool (Function Calling)

publicclassPlanActAgentextendsFlowAgent {    privatefinal ChatModel chatModel;    privatefinal Map<String, ReactAgent> availableAgents;    privatefinal PlanActTool planningTool;    ...
    protectedPlanActAgent(PlanActAgentBuilder builder) throws GraphStateException {        super(builder.name, builder.description, builder.compileConfig, builder.subAgents);        this.chatModel = builder.chatModel;        this.availableAgents = builder.availableAgents;        this.planningTool = builder.planningTool;        ...    }
    publicstatic PlanActAgentBuilder builder(){        returnnew PlanActAgentBuilder();    }
    @Override    protected StateGraph buildSpecificGraph(FlowGraphBuilder.FlowGraphConfig config) throws GraphStateException {        config.setChatModel(this.chatModel);        config.customProperty("availableAgents", this.availableAgents);        config.customProperty("planningTool", this.planningTool);        ...                return FlowGraphBuilder.buildGraph(PlanActGraphBuildingStrategy.STRATEGY_TYPE, config);    }
    publicstaticclassPlanActAgentBuilderextendsFlowAgentBuilder<PlanActAgent, PlanActAgentBuilder> {        private ChatModel chatModel;        private Map<String, ReactAgent> availableAgents;        private PlanActTool planningTool;
        publicPlanActAgentBuilder(){        }
        public PlanActAgentBuilder chatModel(ChatModel chatModel){            this.chatModel = chatModel;            returnthis;        }
        public PlanActAgentBuilder availableAgents(Map<String, ReactAgent> availableAgents){            this.availableAgents = availableAgents;            returnthis;        }
        public PlanActAgentBuilder planningTool(PlanActTool planningTool){            this.planningTool = planningTool;            returnthis;        }
        @Override        protected PlanActAgentBuilder self(){            returnthis;        }
        @Override        protectedvoidvalidate(){            ...        }
        @Override        public PlanActAgent build() throws GraphStateException {            this.validate();            returnnew PlanActAgent(this);        }    }}

publicclassPlanActGraphBuildingStrategyimplementsFlowGraphBuildingStrategy {    publicstaticfinal String STRATEGY_TYPE = "PLAN_ACT";        privatestaticfinal String PLANNING_NODE = "planning";    privatestaticfinal String EXECUTION_NODE = "execution";    privatestaticfinal String SUMMARY_NODE = "summary";
    @Override    public StateGraph buildGraph(FlowGraphBuilder.FlowGraphConfig config) throws GraphStateException {        validateConfig(config);                StateGraph graph = new StateGraph(config.getName(), config.getKeyStrategyFactory());                ChatModel chatModel = config.getChatModel();        PlanActTool planActTool = (PlanActTool) config.getCustomProperty("planningTool");        Map<String, ReactAgent> availableAgents = (Map<String, ReactAgent>) config.getCustomProperty("availableAgents");
        // 将PlanActTool转换为ToolCallback        ToolCallback planningToolCallback = FunctionToolCallback                .builder(planActTool.getName(), planActTool)                .description(planActTool.getDescription())                .inputType(planActTool.getInputType())                .inputSchema(planActTool.getParameters())                .build();
        // 1. 创建Planning Agent - 负责制定执行计划        ReactAgent planningAgent = ReactAgent.builder()                .name(PLANNING_NODE)                .model(chatModel)                .systemPrompt(buildPlanningSystemPrompt(availableAgents))                .tools(planningToolCallback)                .build();                // 2. 创建Execution Node - 负责执行计划中的各个步骤        ExecutionNode executionNode = new ExecutionNode(EXECUTION_NODE, availableAgents);                // 3. 创建Summary Agent - 负责汇总执行结果        ReactAgent summaryAgent = ReactAgent.builder()                .name(SUMMARY_NODE)                .model(chatModel)                .systemPrompt(buildSummarySystemPrompt())                .build();                // 添加节点到图        FlowGraphBuildingStrategy.addSubAgentNode(planningAgent, graph);
        graph.addNode(EXECUTION_NODE, node_async(executionNode));
        FlowGraphBuildingStrategy.addSubAgentNode(summaryAgent, graph);                // 添加边：构建线性工作流        graph.addEdge("__START__", PLANNING_NODE);        graph.addEdge(PLANNING_NODE, EXECUTION_NODE);        graph.addEdge(EXECUTION_NODE, SUMMARY_NODE);        graph.addEdge(SUMMARY_NODE, "__END__");                return graph;    }
    @Override    public String getStrategyType(){        return STRATEGY_TYPE;    }
    @Override    publicvoidvalidateConfig(FlowGraphBuilder.FlowGraphConfig config){        ...    }
    /**     * 构建规划阶段的系统提示词     */    private String buildPlanningSystemPrompt(Map<String, ReactAgent> availableAgents){        StringBuilder prompt = new StringBuilder();        prompt.append("我是一个任务规划专家，基于用户输入，创建一个合理的计划，包含清晰的步骤来完成任务，");        prompt.append("每个步骤使用一个Agent来完成。\n\n");        prompt.append("可用的Agent信息如下：\n");                int index = 1;        for (Map.Entry<String, ReactAgent> entry : availableAgents.entrySet()) {            prompt.append("Agent").append(index).append("：");            prompt.append(entry.getKey()).append(" - ");            prompt.append(entry.getValue().description()).append("\n");            index++;        }                prompt.append("\n请使用PlanActTool工具创建执行计划。");                return prompt.toString();    }
    /**     * 构建总结阶段的系统提示词     */    private String buildSummarySystemPrompt(){        return"""               # 角色               你是一个能够回应用户请求的AI助手，你需要根据这个分步骤的执行计划的执行结果，               进行信息汇总、提取关键信息，给出总结性的结论。                """;    }}

publicclassExecutionNodeimplementsNodeAction {  privatefinal String nodeId;  privatefinal Map<String, ReactAgent> availableAgents;  publicExecutionNode(String nodeId, Map<String, ReactAgent> availableAgents){    this.nodeId = nodeId;    this.availableAgents = availableAgents;  }  @Override  public Map<String, Object> apply(OverAllState state) throws Exception {    // 从state中提取Planning对象    Planning planning = extractPlanningFromMessages(state);    // 异常校验    ...    // 用户原始输入    String userInput = extractUserInput(messages);    // 执行每个步骤    List<Map<String, String>> stepResults = new ArrayList<>();    StringBuilder accumulatedContext = new StringBuilder();    accumulatedContext.append("用户请求：").append(userInput).append("\n\n");    for (PlanningStep step : planning.getSteps()) {      String agentName = step.getAgentName();      ReactAgent agent = availableAgents.get(agentName);      if (agent == null) {        // Agent不存在，判断是否需要继续        ...      }      // 构建执行消息，包含步骤指引和之前的执行结果      messages = (List<Message>) state.value("messages").orElse(new ArrayList<>());      List<Message> contextMessages = new ArrayList<>(messages);      String stepPrompt = buildStepPrompt(step, accumulatedContext.toString());      UserMessage stepMessage = new UserMessage(stepPrompt);      contextMessages.add(stepMessage);      // 记录步骤执行结果      Map<String, String> stepResult = new HashMap<>();      stepResults.add(stepResult);      try {        // 执行Agent        AssistantMessage response = agent.call(contextMessages);        String result = response.getText();        //填充stepResult        ...      } catch (Exception e) {        // 执行出错，记录错误并继续        ...      }      //手动更新状态      ...      // 累积上下文      accumulatedContext.append("步骤 ").append(step.getStepIndex())        .append(" (").append(agentName).append(")：\n")        .append("任务：").append(step.getStepGuide()).append("\n")        .append("结果：").append(result).append("\n\n");    }    // 返回执行结果    Map<String, Object> result = new HashMap<>();    result.put("step_results", stepResults);    result.put("execution_summary", accumulatedContext.toString());    // 将执行摘要添加到消息列表，供Summary节点使用    List<Message> newMessages = new ArrayList<>(messages);    newMessages.add(new UserMessage("按照计划所有步骤的执行结果如下：\n" + accumulatedContext.toString()));    result.put("messages", newMessages);    return result;  }  /**     * 构建步骤执行提示词     */  private String buildStepPrompt(PlanningStep step, String context){    StringBuilder prompt = new StringBuilder();    prompt.append("请执行以下任务：\n");    prompt.append(step.getStepGuide()).append("\n\n");    if (!context.isEmpty()) {      prompt.append("背景信息：\n");      prompt.append(context);    }    return prompt.toString();  }}

publicclassPlanActAgentExample {  publicvoidusePlanActAgent(String userQuery){    // 1. 首先注册PlanAct策略    PlanActStrategyRegistrar.register();        // 2. 创建可用的Agent映射    Map<String, ReactAgent> availableAgents = new LinkedHashMap<>();        // 翻译专家Agent    ReactAgent translationAgent = ReactAgent.builder()            .name("翻译专家")            .model(chatModel)            .systemPrompt("你是一个专业的翻译专家，能够准确地在中英文之间进行翻译。")            .description("专业的翻译专家，能够准确地在中英文之间进行翻译。")            .build();    availableAgents.put("Agent1", translationAgent);        // 天气专家Agent    ReactAgent weatherAgent = ReactAgent.builder()            .name("天气专家")            .model(chatModel)            .systemPrompt("你是一个天气专家，能够提供天气相关的信息和建议。")            .description("天气专家，能够提供天气相关的信息和建议。")            //查询天气的工具            .tools(weatherTool)            .build();    availableAgents.put("Agent2", weatherAgent);      // 交通专家    ReactAgent trafficAgent = ReactAgent.builder()            .name("交通专家")            .model(chatModel)            .systemPrompt("你是一个交通专家，能够提供交通相关的信息和建议。")            .description("交通专家，能够提供交通相关的信息和建议。")            //查询交通的工具            .tools(trafficTool)            .build();    availableAgents.put("Agent3", trafficAgent);        // 3. 创建规划工具    PlanActTool planningTool = new PlanActTool();        // 4. 创建PlanActAgent    PlanActAgent planActgent = PlanActAgent.builder()            .name("plan_act_agent")            .description("一个使用Plan-Execute模式的智能代理")            .chatModel(chatModel)            .availableAgents(availableAgents)            .planningTool(planningTool)            .compileConfig(CompileConfig.builder().build())            .subAgents(availableAgents.values().stream().collect(Collectors.toList()))            .build();      AssistantMessage response = agent.invoke(userQuery);  }}