Spring AI Alibaba 在多 Agent 场景下的实践

目录

  • 第一部分:四种主流的智能体开发范式
  • [第二部分:用 Spring AI Alibaba 框架快速开发智能体](#第二部分:用 Spring AI Alibaba 框架快速开发智能体)
    • 框架架构图
    • [单智能体:React Agent](#单智能体:React Agent)
    • [Agent 类型抽象](#Agent 类型抽象)
    • [示例一:串行流程(Sequential Agent)](#示例一:串行流程(Sequential Agent))
    • [示例二:并行流程(Parallel Agent)](#示例二:并行流程(Parallel Agent))
    • 示例三:路由模式(Routing)
    • [Graph 引擎:所有模式的内核](#Graph 引擎:所有模式的内核)
    • [Graph 引擎在编排之外提供的能力](#Graph 引擎在编排之外提供的能力)
  • [第三部分:基于 A2A 的分布式 Agent 架构](#第三部分:基于 A2A 的分布式 Agent 架构)

大家好,接下来由我给大家分享"阿里巴巴如何开发智能体"。今天的分享内容从四个方面展开:

  1. 主流的智能体开发范式:今年算是 AI 元年,AI 迎来大爆发,在 AI 开发里有哪些主流的开发范式;
  2. 用 Spring AI Alibaba 快速开发智能体:在这些开发范式的指导下,Java 开发人员如何用阿里巴巴推出的 Agent 开发框架快速开发 Agent;
  3. 基于 A2A 的分布式 Agent 架构:Agent 就像我们以前做的普通应用服务一样,当应用变复杂、Agent 链路变长以后,无论是因为企业组织架构还是整体性能要求,如何做拆分,形成基于 A2A 的分布式 Agent 架构;
  4. Studio 平台:关于我们最近发布的 Studio 平台,我们定位它是一个从开发、调试到评估、部署的一整套平台。

第一部分:四种主流的智能体开发范式

过去一年我汇总了一下,大概有四种 Agent 开发范式,它们呈现出从简单到复杂的递进关系。

直接调用模型 API。大模型刚出来的时候,我们看到市面上有很多聊天界面,基本都利用了模型的内容生产能力,交互方式就是调用模型的 Chat Completion API 完成内容生产。但由于模型本身的特点和局限性------比如它是预训练的、调不了工具等等------后来就引出了 Agent 的概念。

单智能体(模型增强)

Agent 的概念,就是在模型调用能力之上进行增强:比如给它 RAG 的数据上下文,给它工具调用能力,把这些整合在一起,就形成了单智能体架构。

这是一个比较理想的模式,它解决了模型受限的多种问题,也能调用工具、和业务系统很好地结合。但在当前的模型能力下,如果把一个复杂业务交给一个模型、给它挂很多工具,我们最终测下来,效果是受限的。为了解决这个问题,又引出了工作流(Workflow)和 Multi-Agent 架构。

总的来说,这两种架构都是把单个 Agent 里复杂的流程拆分成许多子 Agent:

  • 工作流:相对是非常固化的流程,非常可控,提前把所有分支都枚举出来,再把多个 Agent 串联起来;
  • Multi-Agent :模型在路由与分支中的成分更高。++基于模型决策的关键环节++,不可控性相对更高,但同时也带来更灵活的链路。

接下来把后面这三种模式稍微展开一下。

单智能体架构

这个架构图是非常典型的所谓"单智能体"架构,最核心的一点是中间要接入大模型。单智能体本身也是一种"模型增强"范式,我们要增强的是三个关键组件:

  1. Retrieval(RAG 上下文,检索):企业内或私域的数据;
  2. Tools:定义若干工具,提供给模型调用;
  3. Memory:加上多轮对话的能力。

这三个关键组件加在一起,就形成了单智能体架构。

据我和社区、一些企业用户沟通下来的直观体感,这样的架构可能覆盖当前智能体落地 60% 甚至 70% 以上的应用场景------并不是所有人的智能体应用,都要搞复杂的工作流或 MCP。

之所以要演进到工作流,本质上还是当前模型能力受限。如果哪天模型能力发展到足够强,我们只需要把这三个组件都扔上去,效果就能满足要求,其实没必要做接下来的工作流提升。工作流只是我们基于当前模型能力、为了实现效果的一种妥协。

为什么要做这个事情?这一页列了一些限制、举了几个例子,深度做过智能体落地、尤其关注效果的同学,多少都遇到过其中一些问题:

  • 如果一个 agent 包含有太多的可用 tools,模型会在决策工具选择时无所适从,效果变差
  • 多轮执行下来,消息上下文会变得很大。消耗大量的 token 且影响模型当前专注度
  • 模型上下文窗口有限
  • 对于很多复杂的任务,不止需要很多个步骤,通常在某些环节还需要专业领域技能支持,比如科学计算、深入研究、写代码、绘画、任务规划等。
  • 单 Agent 在复杂任务场景下的可维护性会变差

这些都是典型的单智能体(Single Agent)在落地复杂任务时的典型痛点,也是行业内从单Agent方案转向多智能体(Multi-Agent)协作架构的核心动因

工作流架构

为了解决这些问题,这里给出工作流部分的架构。工作流可以画得很复杂,我这里列出几个典型架构:

  • 串联架构:最典型的架构,把多个节点连成一条链路------模型调用一、模型调用二、模型调用三,无论是业务逻辑节点还是前面开发的单智能体节点,把它们串联起来,组成串联关系来解决问题;
  • 路由架构:也是比较简单的架构。前置的 Router Agent(或节点)基于模型决策或预定义的条件,在后续的多个任务节点中选择一个执行。

Multi-Agent 架构

和工作流架构非常像的就是 Multi-Agent 架构。Multi-Agent 和工作流有什么本质区别呢?其实业界对这块也没有一个明确的界限和定义,大家讨论得挺多。

从图上的样例也可以看出来,Multi-Agent 也是比较典型的、有流程的架构,和工作流一样。我个人认为它们中间最大的区别在于流程当中的节点:

  • 工作流当中的节点也可以挂入大模型,挂入模型以后,模型也有一定的决策能力,但是相对比较弱。比如在工作流里,++我用模型更多的是做内容生成++,生成以后就转向下一个节点;也可能在这个节点用模型做分类------给它一个输入,只需要三个分类,模型就帮我做这三个分类:分类一走第一个分支,分类二走第二个分支;
  • Multi-Agent 在节点上就不只是简单的内容生成或问题分类了,它能做的相对更灵活。比如中间这个节点有可能走向下面的三个节点,但它在什么时候走、走几轮、基于什么条件走,相对是由++模型有更多的控制能力++的。

这就是我认为 Multi-Agent 和工作流的核心区别,也体现了 Multi-Agent 所谓的灵活性或者说不可预测性。


第二部分:用 Spring AI Alibaba 框架快速开发智能体

了解了这几种典型模式之后,我们来看一下 Java 开发者如何用 Spring AI Alibaba 框架快速开发这几种模式。

Spring AI Alibaba 是阿里云推出的开源AI应用开发框架,它延续了Spring生态的经典编程模型,让熟悉Java/Spring体系的开发者可以极低的学习成本快速上手AI智能体开发,无需从零搭建底层能力,就能快速把大模型能力集成到现有Spring业务系统中。

它的核心优势在于完全对齐Spring AI官方标准,同时深度适配通义千问等国内主流大模型,还内置了大量开箱即用的智能体工具链、记忆管理、向量检索等能力,大幅降低了企业级AI Agent项目的落地门槛。

框架架构图

在讲怎么开发以前,先给出一个架构图,分为绿色和蓝色两部分:

  • 绿色部分(下层):是调用模型、开发模型增强型应用(Agent 应用)的一些原子能力的抽象。比如怎么适配各个模型厂商的 API、怎么做 Prompt 的声明管理、怎么做 Tool 定义、怎么做文档检索等等原子 API 和能力。这是 Spring AI 或者 Python 体系的 LangChain 这类抽象替我们做的事情;
  • 蓝色部分(上层):是我们重点在做的部分。要构建前面说的单智能体、工作流或者 Multi-Agent,需要一套框架来支撑,这就是 Spring AI Alibaba 干的事情。

比如我们有一套运行时,它本身是一个引擎:你构建了前面说的工作流或 Multi-Agent 之后,这个引擎负责识别你的流程,并确保流程能够完整地运转。

运转过程中举个例子,Human in the Loop(人类介入):我是不是可以在某个节点暂停下来?比如这个节点模型决策要调工具,如果不能暂停,工具就自动执行下去了。但有些节点为了保证准确性需要暂停,暂停后我要拿到信息:当前它要调哪个工具、给我的输入输出是什么。第一,我需要验证它选的工具对不对、给的参数对不对;第二,我可以给它纠正,或者补充一些额外的上下文。把这些信息都给到它,然后我再 approve(批准)让它去调,这时候流程再流转下去。

类似的还有 Streaming(流式输出):整个流程都需要流式输出。框架就是解决这些事情,让大家在整个 Agent 模式的实现和流转过程中,不需要关心这些底层的事情。这就是整个 Spring AI Alibaba 框架的架构图。

单智能体:

接下来讲前面几个模式怎么定义。首先是一个非常简单的 API------四种模式当中的单智能体,在 Spring AI Alibaba 框架里用几行代码就能实现。

java 复制代码
        ReactAgent reactAgent = ReactAgent.builder()
                .name("单智能体结构")
                .model(chatModel)
                .description("一个简单的智能体")
                .instruction("你是一个乐于助人的智能体,请简洁、准确地回答用户问题。用户问题:{input}")
                .build();
        AssistantMessage response = reactAgent.call(query);
        Map<String, Object> outputs = new LinkedHashMap<>();
        outputs.put("answer", response == null ? "(无输出)" : response.getText());
        return outputs;

其中有三个关键属性:

  1. name:智能体的名称。我们要求智能体名称是唯一的------不只是在多智能体场景下要求唯一,即使你只有一个智能体,或者只有两个互相孤立的智能体,我们也要求唯一,并且是必填的;
  2. model:关于模型调用,即要调哪个模型。并且基于 model 这个抽象,它是厂商无关的,只需要按照接口声明 model 就可以了;
  3. description :++关于智能体能力的描述,即这个智能体是干什么的++。这个描述在多智能体场景下是必填的,在单智能体场景下是可选的。也就是说,我可能只指定 name 和 model,这个时候智能体就开发完成了,就能工作了。

还可以给智能体做更多的配置,即图中的 instruction 、tools 和 chat options,这几项都是可选的:为Agent设置指令,工具,更多参数配置

java 复制代码
        ReactAgent reactAgent = ReactAgent.builder()
                .name("单智能体结构")
                .model(chatModel)
                .description("一个简单的智能体")
                .instruction("你是一个乐于助人的智能体,请简洁、准确地回答用户问题。用户问题:{input}")
                .tools(DemoTools.getTools())
                // 可选:覆盖本次调用的模型参数(不设置则用 ChatModelFactory 里创建的默认值)
                .chatOptions(OpenAiChatOptions.builder()
                        .model("deepseek-chat")
                        .temperature(0.3)
                        .build())
                .build();
  • instruction:其实可以理解为 Prompt,用来告诉智能体它的目标和任务、角色、行为,应该依次按照什么步骤做事情,在什么场景下可以使用什么工具。它可以是一串相对复杂的文本串;
  • tools:前面讲过,Spring AI 作为底层框架替我们定义了怎么定义工具,我们只需要把定义好的 Tool 给到这个 Agent,它就会根据 Instruction 的指示或者模型的决策,来决定什么时候调用;
  • chat options:用来控制模型的一些行为,比如 temperature、topK 这类参数。如果调模型的时候想指定额外的 header------一个典型场景是:我调模型时不是直接调到 OpenAI 或者千问,中间走了一个网关。为什么要挂网关?很有可能是要做权重、做鉴权等事情,这时候就要加一些网关认识的 header。在 Chat Options 里其实是可以把这个 header 加上去的。

同样的一个问题:你是谁;temperature参数不同(分别是0.3,2.0),模型输出的结果不一样。

基本上这一页展示的 React Agent 的 API 和接口方法,就能满足前面提到的 60% 甚至 70% 的业务场景------比如简单的答疑助手、客服助手:它能调工具,也能给它上下文,只需要这几行代码。更复杂的场景,就需要工作流和多智能体了。

Agent 类型抽象

在进入更复杂的场景以前,先看一下当前 Spring AI Alibaba Graph 总共支持哪些 Agent 类型,也就是 Agent 架构的抽象:

  • 最上面是 Agent 基类,是对整个 Agent 的核心总抽象;
  • 最左边是前面讲的 React Agent,属于单 Agent;
  • 除 React Agent 以外,还支持工作流 Agent,有一个子类叫 Flow Agent。在 Flow 下我们预制了很多工作流程,比如前面讲的串行流程、并行流程、回环流程,以及一些需要流程编排的场景(比如 Supervisor 模式),当然大家也可以自己去扩展。基于这些预制的流程,一方面大家可以非常容易地直接拿来用,定义一个工作流流程;或者把它们编排在一起,形成一个更复杂的流程,也是没问题的;
  • 最后一种 Agent 模式是基于 A2A 协议的分布式 Agent :当智能体需要分布式部署的时候,比如一个串行流程里,其中一个节点要调用远端部署的 Agent,怎么办?把这个节点声明成 A2A Remote Agent ,这时候它就能够发起远端调用。

针对这三种类型的 Agent 场景,这里列了一个适用场景的小表格,方便大家做横向比较:

  • React Agent:就是前面讲的单智能体场景,推理、生成、工具调用都有,比较简单;
  • Flow Agent:就是刚才讲的串行、并行场景,有预先定义好的工作流程,并且流程是比较确定的(串行、并行等);
  • 最后一种(Multi-Agent 模式):基于刚才的架构图也是可以支持的,后面会讲到。它也有流程,但在流程的某个环节,模型有更强的自主决策能力,比如我们内置了一个叫 LLM Routing 的 Agent 模式。

示例一:串行流程(Sequential Agent)

接下来举个例子,讲一下用框架开发 API 时,这几个流程的代码要怎么写,其实也是比较简单的。

java 复制代码
 /**
     * 串行智能体(多个 ReactAgent 对象模式,outputKey 键名数据流):
     * 手动创建 3 个 ReactAgent,Agent 之间通过「约定键名」传递数据,不再手动拼接字符串。
     *
     * 数据流:query ──> [大纲Agent] ─outline─> [成文Agent] ─article─> [润色Agent] ─polished_article─> 终稿
     *
     * 机制说明(1.1.2.3 源码):
     * 1. .outputKey("xxx") 是当前 Agent 的「出口」:最终 AssistantMessage 写入图状态的 "xxx" 键
     *    (AgentLlmNode:257),call() 的返回值也从该键提取(ReactAgent.extractAssistantMessage:277)。
     * 2. 接收上一步出参的「入口」是 call(Map):除保留键 input/messages 外,Map 里的其他键
     *    会原样进入图状态,模型调用前框架用状态数据渲染 instruction 里的 {键名} 占位符
     *    (AgentLlmNode.renderTemplatedUserMessage:176)。
     * 3. 所以「上一个 Agent 的 outputKey == 下一个 Agent call(Map) 传入的键名 == instruction 占位符」
     *    三者对齐,即可实现与 SequentialAgent 框架版相同的键名数据流,只是接线由我们手动完成。
     */
    public Map<String, Object> runSequential(String query) {
        log.debug("[串行-多ReactAgent] 输入: {}", query);
        try {
            // ===== 第 1 个 ReactAgent:生成大纲,出参键名约定为 outline =====
            ReactAgent outlineAgent = ReactAgent.builder()
                    .name("outline_agent")
                    .model(chatModel)
                    .description("根据主题生成文章大纲")
                    .instruction("""
                            你是一名资深编辑。请为下面的主题拟一份文章大纲,包含 3~5 个要点,每个要点用一句话说明。
                            只输出大纲本身,不要输出其他内容。
                            主题:{input}
                            """)
                    .outputKey("outline") // 出参写入状态 "outline" 键,call() 也从该键提取返回
                    .build();
            String outline = outlineAgent.call(query).getText();

            // ===== 第 2 个 ReactAgent:通过 "outline" 键接收上一步出参,自己的出参键名为 article =====
            ReactAgent writerAgent = ReactAgent.builder()
                    .name("writer_agent")
                    .model(chatModel)
                    .description("根据大纲撰写完整文章")
                    .instruction("""
                            你是一名知名作家。请严格依据下面的大纲,围绕主题撰写一篇 300 字左右的完整短文。
                            只输出文章正文,不要输出大纲或任何解释。
                            主题:{input}
                            大纲:{outline}
                            """)
                    .outputKey("article") // 出参键名,同时供下一个 Agent 以 "article" 键引用
                    .build();
            // call(Map):"outline" 不是保留键,原样进入状态 → instruction 里的 {outline} 被自动填充
            String article = writerAgent.call(Map.of("input", query, "outline", outline)).getText();

            // ===== 第 3 个 ReactAgent:通过 "article" 键接收上一步出参 =====
            ReactAgent polishAgent = ReactAgent.builder()
                    .name("polish_agent")
                    .model(chatModel)
                    .description("对文章进行润色")
                    .instruction("""
                            你是一名专业校对。请对下面的文章进行润色:修正语病、优化措辞,保持原意和篇幅基本不变。
                            只输出润色后的文章,不要包含任何评论或说明。
                            待润色文章:{article}
                            """)
                    .outputKey("polished_article")
                    .build();
            String polished = polishAgent.call(Map.of("article", article)).getText();

            Map<String, Object> outputs = new LinkedHashMap<>();
            outputs.put("outline", outline);
            outputs.put("article", article);
            outputs.put("polished_article", polished);
            return result(query, outputs);
        } catch (Exception e) {
            throw new IllegalStateException("串行智能体调用失败: " + e.getMessage(), e);
        }
    }

比如这里的例子是要搞一个串行的流程,串行流程里有两个 Agent:输入给到第一个 Agent,它的输出再给到第二个 Agent,最终给到我,最终的输出,每个 Agent 都会去调模型。这时候就要先声明这两个 Agent,声明方式和前面讲的单 Agent 一模一样。

这里的业务示例是写一篇文章:

  • 第一个(上游)Agent 可以理解为一个小说作家 Agent,它的作用是写文章;
  • 第二个 Agent 相当于一个校验者、评论员,需要把第一个 Agent 生成的文章进行校验。如果说不符合要求------这里列了一个示例场景:对于散文类的文章,必须加上西湖风景的描述(特定场景的要求)。

这里有一个信息大家要先注意一下:第一个写作 Agent 的输出,我指定输出到 output key(article)。因为在整个流程当中------待会会讲到------需要有一个上下文的概念:Agent 之间通过什么协作呢?就是通过共享的上下文。我把输出写到 article 这个 Key 里,下面的 Review Agent 就能从这个 Key 里拿到你的文章。这是我们的一个核心设计理念。

java 复制代码
    /**
     * 串行智能体(SequentialAgent 编排模式):
     * 方法内先创建 3 个 ReactAgent(各自用 outputKey 约定出参键名),
     * 再把它们编织成一个 SequentialAgent,一次 invoke() 完成整条流水线。
     *
     * 数据流(框架自动传递,三个子 Agent 共享同一份 OverAllState):
     * query ──> [outline_agent] ─写"outline"─> [writer_agent] ─写"article"─> [polish_agent] ─写"polished_article"
     *
     * 与手动逐个 call() 串联的区别:
     * 1. 不需要自己把上一步结果通过 call(Map) 传给下一个 Agent------
     *    SequentialAgent 把子 Agent 编成一张状态图,按声明顺序依次执行;
     * 2. 前一个子 Agent 结束时 outputKey 自动把结果写入共享状态,
     *    下一个子 Agent 的 instruction {占位符} 在模型调用前从共享状态自动解析填充;
     * 3. invoke() 返回最终共享状态,从里面按键名提取各阶段产物即可。
     */
    public Map<String, Object> runSequential(String query) {
        log.debug("[串行-SequentialAgent] 输入: {}", query);
        try {
            // ===== 子 Agent 1:生成大纲,出参写入共享状态的 "outline" 键 =====
            ReactAgent outlineAgent = ReactAgent.builder()
                    .name("outline_agent")
                    .model(chatModel)
                    .description("根据主题生成文章大纲")
                    .instruction("""
                            你是一名资深编辑。请为下面的主题拟一份文章大纲,包含 3~5 个要点,每个要点用一句话说明。
                            只输出大纲本身,不要输出其他内容。
                            主题:{input}
                            """)
                    .outputKey("outline")
                    .build();

            // ===== 子 Agent 2:{outline} 由框架从共享状态解析,出参写入 "article" 键 =====
            ReactAgent writerAgent = ReactAgent.builder()
                    .name("writer_agent")
                    .model(chatModel)
                    .description("根据大纲撰写完整文章")
                    .instruction("""
                            你是一名知名作家。请严格依据下面的大纲,围绕主题撰写一篇 300 字左右的完整短文。
                            只输出文章正文,不要输出大纲或任何解释。
                            主题:{input}
                            大纲:{outline}
                            """)
                    .outputKey("article")
                    .build();

            // ===== 子 Agent 3:{article} 由框架从共享状态解析,出参写入 "polished_article" 键 =====
            ReactAgent polishAgent = ReactAgent.builder()
                    .name("polish_agent")
                    .model(chatModel)
                    .description("对文章进行润色")
                    .instruction("""
                            你是一名专业校对。请对下面的文章进行润色:修正语病、优化措辞,保持原意和篇幅基本不变。
                            只输出润色后的文章,不要包含任何评论或说明。
                            待润色文章:{article}
                            """)
                    .outputKey("polished_article")
                    .build();

            // ===== 编织成 SequentialAgent:subAgents 声明顺序即执行顺序 =====
            SequentialAgent sequentialAgent = SequentialAgent.builder()
                    .name("article_sequential_agent_inline")
                    .description("串行流水线:大纲 -> 成文 -> 润色")
                    .subAgents(List.of(outlineAgent, writerAgent, polishAgent))
                    .build();

            // 一次 invoke:框架按序执行三个子 Agent,数据经共享状态自动流转
            OverAllState state = sequentialAgent.invoke(query)
                    .orElseThrow(() -> new IllegalStateException("串行智能体未返回状态"));

            // 从最终共享状态中按 outputKey 键名提取各阶段产物
            Map<String, Object> outputs = extract(state, "outline", "article", "polished_article");
            return result(query, outputs);
        } catch (IllegalStateException e) {
            throw e;
        } catch (Exception e) {
            throw new IllegalStateException("串行智能体调用失败: " + e.getMessage(), e);
        }
    }

定义好写作和评论这两个 Agent 以后,需要把上面架构图中的串联关系串起来,用的就是我们内置的 Sequential Agent ------专门做串联关系的 Agent。可以看到其他属性都是一样的,没有太大区别。最重要的一点是它有一个 subAgents 接口,能够接受上面的子 Agent:先写作,然后再评论,这就有了串联关系。

同时,这个 Agent 我们叫它 Root Agent(根 Agent),所有的调用都要从这里发起。这里发起了一个调用,这是一个调用示例:"写一个 100 字左右的散文",它就会依次调过去,大概是这么一个流程。

在这个 Root Agent 里有一个关键点,就是前面提到的全局上下文共享,我们叫 State。State 的定义包含了刚才说的 article 和 review 这两个字段。回到上面的示例:作家 Agent 就是在往全局 State 的某个字段里写内容。这个 State 是被流程当中所有子 Agent 都可以看到的,它们通过这个 State 来共享上下文,这个时候大家的状态都可以看得到。

示例二:并行流程(Parallel Agent)

这里还有一个例子,是一个并行的例子。我讲得稍微快一点,因为从上面的串行示例,大家大面上应该能理解它的工作模式。

同样,这个示例也要定义子 Agent。这里是一个检索的场景,有两个检索 Agent:

  • 第一个检索 AI 相关的趋势;
  • 第二个检索微服务相关的趋势。

都定义好以后,这里用的就不是 Sequence Agent 了,而是 Parallel Agent。Parallel Agent 能实现:当你调到它的时候,它把收到的任务同时转发给这两个子 Agent,让它们并行地运行。

运行完了以后(实际示例比图上更复杂),每个子 Agent 都有自己的 output,我需要把它们聚合起来。为了聚合,又定义了一个 Merge Agent,它的职责就是接收上面两个子 Agent 的结果、进行聚合。

怎么把 Merge 放在后面呢?需要再定义一个 Sequential Agent(串行 Agent):

  • 第一个节点放 Research Agent(即这个 Parallel Agent),它会分发到两个子 Agent;
  • 第二个节点放 Merge Agent,两个子 Agent 完成以后,来到结果合并的 Agent。

也就是说这里面有一个嵌套的 Parallel Agent,这样就组成了一个较复杂的工作流,工作流的每个节点都是 Sequential 的。

这也解释了一点:React Agent 可以作为 Sequential Agent 的子 Agent;同时 Sequential 和 Parallel 之间也可以互相作为子 Agent,它们之间没有谁必须做谁子 Agent 的限制。

示例三:路由模式(Routing)

这个模式应该也是比较常用的。在这个阶段、这个节点,我们叫路由模式(Routing 节点),这个节点就是一个 Routing Agent。

它和前面的模式不太一样的点在于:Routing Agent 是要调模型的。不是像以前一样,到了这个节点就一定串联下去、就一定并行下去;而是这个节点要调路由------后面有 Agent 1、2、3,我要根据收到的任务,让模型替我决策该调哪个。

这里给出了 Routing Agent 的内部实现------我们现在开源了一些内置实现。它里面实现的路由逻辑,因为是靠模型,把它的 Prompt 简化以后大概长这样:它会看到后面的 Agent 1、2、3 的名字是什么、可以做什么事情;收到任务的时候,选择一个名字,然后流转下去。

代码写起来就像这样:左边是子 Agent 的定义,这个没啥好说的------一个 Agent 可以写散文,一个 Agent 可以写现代诗;然后用一个 Routing Agent 把它们组织起来。这时候当我给这个 Agent 输入:"我要你写散文",它就路由到写散文的 Agent;"我要你写现代诗",就路由到写现代诗的 Agent。这就是一个基于模型做路由的 Agent 模式。

Graph 引擎:所有模式的内核

上面这几个就是我们提到的典型模式,都是预制的。所有的这些模式都是有流程、有流程编排的,它们是怎么工作的呢?在这套 API 下面,我们有一个叫做 Graph 的引擎,它是支撑上面所有编排模式的一个非常重要的内核。

Graph 是又往下抽了一层、更抽象的一个层次。通过这个图:无论是前面定义的 Agent,还是我们面对的一些 Tool,都会被解析和表达成 Node,根据你用 Agent 编排的结构建成一个工作流的流程图,流程图之间会有边来连接。

这里有三个概念,解释一下:

  1. Node(节点):代表图中蓝色的节点,可能是你写的业务逻辑,可能是要调模型的,或者是你自己的其他逻辑、调工具的,都是一个 Node;
  2. Edge(边):Node 之间通过边来连接。边可以是无条件的------就像前面说的串联的时候,就是要往下走;也可以是带条件的------条件可以是你定义的逻辑,也可以是基于模型决策的;
  3. State(上下文):在图的流转过程中,Node 之间都是要有输入输出的。比如后面的 Node 5 可能需要 Node 2 或者 Node 1 的输出,这时候输出的协调就是通过 State------大家通过共享 State 做到这件事情。

简单来讲,这就是整个 Agent 模式下的内核引擎。

基于 Graph 这套内核,这里列了一个更复杂的代码示例:Graph 这套 API 其实也可以直接用。上面对 Agent 的抽象,是面向更一般的业务场景,可以定义自己的业务 Agent;如果你觉得预制的流程在某些场景下不满足需求,需要更可控的流程编排、愿意写更多的代码,也可以直接用 Graph 自己编写,这是完全没问题的。你可以把自己的 Node、要写的逻辑都写在这里,想怎么定义都没问题。它有一套完整的 API,就和 LangGraph 那套有点像了。

Graph 引擎在编排之外提供的能力

Graph 引擎其实不只是做了流程编排这个事情。除了前面提到的 State(流程流转需要全局上下文)以外,其实还有很多其他的事情------Graph 和 Agent 框架替我们的业务开发解决了很多问题。这里举三个例子:

1. Streaming(流式输出)

流程在流转的过程当中,包括与模型的交互,现在也是典型的流式生产。流程流转过程中,到了某个节点,这个节点的一些输出需要实时地、流式地返回给前端的 UI 交互;或者这个 Node 调用了模型,需要流式输入。整个 Graph 框架确保你在流程流转过程当中,Node 节点的输出情况和模型 Token 的输出都能够流式地给到前端。

2. Human in the Loop(人类介入)

流程流转过程中到某个节点,要调工具了,或者要做其他动作,框架可以把 State 的信息返回给你,前端 UI 就可以接触到这个 State。State 里可能包含当前选哪个 Tool、参数是什么等等,你可以对它进行校验然后批准,或者修改以后再批准让它运行下去。

3. Memory / Context(上下文工程)

这就是最近概念比较火的 Context Engineering(上下文工程),也是框架处理的一部分:

  • 短期记忆:通常指在一个会话周期内。比如我编排了一个 Agent(刚才的 Workflow Agent),可以和它进行多轮对话,这多轮对话当中的所有历史消息,这些数据叫做短期记忆;
  • 长期记忆:指在多个会话之间,我能看到之前会话的状态。比如用户在上一次会话的时候,我了解到了他喜欢吃的水果是苹果;过了一段时间进行下一次交互时,我要记住"这个用户喜欢吃苹果"这个事实,在下一次的多轮对话当中能够知道这个点。这就是长期记忆(了解历史用户偏好和信息)。

总的来说,基于阿里巴巴整个开源的体系,我们能定义单智能体或者多智能体,并且把它们串联起来。


第三部分:基于 A2A 的分布式 Agent 架构

第三部分讲一种特殊的 Agent 类型。前面讲的都有一个默认的设定:我们都是在单个应用或者单个进程内讲多 Agent 或工作流的。还有一个场景是:++Agent 可能需要分布式部署,那就有远程通信的需求++。

在远程通信的背景下,谷歌提出了一个叫做 ++A2A(Agent to Agent) 的协议++ ,这个大家应该都知道了。它和 MCP 是不太一样的:MCP 是连接工具的,而 A2A 的重点是解决 Agent 之间的通信。

在我们的框架当中,也提供了基于 A2A 的远程 Agent 场景的支持。它的声明方式和之前的 React Agent(单 Agent)都是差不多的,有一个特定的类型叫做 Remote Agent ,只不过它里面有一个特定的属性,叫做 Agent Card。

AgentCard 是 A2A 协议里的一个概念。基本上就是说,Remote Agent 本身是没有本地实现的定义的,它需要++通过 AgentCard 来识别到一个远端的、分布式的 Agent++。比如这里是一个范例:我指定了远端 Agent 的 URL。在这个编排里------因为还是一个写作的范例,和以前一样,也是用一个串行 Agent 把作家和评论员串联在一起------但和之前不同的是,这个作家 Agent 在本地是没有实现的,它要通过 Agent Card 调到一个远端的 Agent,是不部署在本地的。

对于分布式的远端 Agent,我们还可以再进一步:把它的架构,包括 Agent 的自动注册发现,都自动化掉。因为前面我们声明 Remote Agent 的时候,要指明 Agent Card,还需要在编码侧把它的地址(这里写得比较简单)、描述信息、它能干什么,所有这些信息都人工编写在这里。当我的 Agent 或者企业的部署架构变复杂以后,如果这些都需要开发者人工来写,可扩展性就是非常弱的。

那我们能不能像微服务一样,借助一个中心化的 A2A 注册中心来做这个事情:

  • Remote Agent 起来的时候,把自己的 Agent Card 自动注册到注册中心,把自己暴露出来;
  • 消费端的 Agent 作为 Client,就可以通过注册中心自动发现 Agent Card。

也就是说这个地方甚至不需要写 AgentCard 了,可能只要给一个 A2A 注册中心的地址就够了------就能够自动发现,并且自动做容错、负载均衡,更具有扩展性。

为什么像 Dify 或者扣子(Coze)这类开源低代码平台,在我们调研当中用户比例还挺高的?因为它们的用户群体更广------现在这个 AI 时代,不只是程序员,业务方也想把自己的业务接入智能化。如何通过不写代码的形式,把我的 Agent 搭建起来?


我们整个体系的核心,还是 Spring AI Alibaba 这套 Java 框架。我们定义了一套 Agent 的范式,会围绕整个框架的易用性和能力,简化 Agent 的开发------包括前面提到的框架、低代码、零代码这几个不同的开发入口,其实就是简化整个开发和调试的过程。


1,Spring AI Alibaba 智能体开发需要jdk版本多少

‌Spring AI Alibaba 智能体开发需要 JDK 17 或以上版本‌。这是硬性要求,因为框架基于 Spring Boot 3.x 构建,而 Spring Boot 3.x 最低要求 JDK 17。‌‌

2,ReactAgent中‌instruction参数的作用是什么?

‌instruction() 在 ReactAgent 中用于设置系统级指令,定义 Agent 的角色、任务和行为约束‌,是构建 Agent 时最核心的配置项之一。‌‌

它和 systemPrompt() 的区别在于:systemPrompt 更侧重定义 Agent 的"人设"------个性、语气和基础行为规则;而 instruction 更侧重‌任务导向的行为描述‌,告诉 Agent"具体要做什么、怎么执行"。‌‌

3,ReactAgent中AssistantMessage类的作用:‌AssistantMessage 是 Spring AI 中表示大模型响应内容的消息类型‌,在 ReactAgent 里承担"模型输出"的核心角色。‌‌

它封装了模型生成的所有内容,包括纯文本回复、工具调用请求和结构化输出等

4,ReactAgent中tools()参数的含义

‌ReactAgent 中 tools() 参数用于注册智能体可调用的外部工具集合‌,让大模型在推理过程中能按需调用函数、API 或代码执行器,扩展能力边界。‌‌

🛠️ 核心作用

‌工具清单‌:tools() 接收一个工具列表,每个工具包含名称、功能描述和参数定义,相当于给模型一份"可操作手册"。

‌决策依据‌:模型根据工具描述判断"何时用、怎么用",工具描述写得越清晰,调用准确率越高。

‌执行边界‌:模型不直接执行代码,只返回工具调用请求;实际执行由 Agent 后端完成,结果回传给模型继续推理。‌‌

📋 两种注册方式

‌methodTools‌:通过 @Tool 注解标记方法,自动扫描注册,适合快速声明。

‌tools‌:显式传入 ToolCallback 或工具对象,更灵活,支持手动构建。‌‌

5,ReactAgent中.chatOptions()参数的含义

.chatOptions() 用于给 ReactAgent 指定模型调用参数,覆盖 ChatModel 上的默认设置。‌ 传进去的对象即 ChatOptions 实现类,如 DashScopeChatOptions、ZhiPuAiChatOptions,控制每次模型请求的温度、Token 上限、采样策略等。‌‌

🎛️ 常用参数

‌model‌:模型标识,如 qwen-plus、claude-sonnet-4-20250514,决定走哪个模型。

‌temperature‌:采样温度,0--2 之间。越高越有创造性,越低越确定。确定性场景(代码、金融数据)建议调低,如 0.1。

‌maxTokens / max_tokens‌:单次响应最大 Token 数,防止模型输出过长或费用失控。

‌topP‌:核采样参数,控制候选词范围的多样性,与 temperature 配合使用。‌‌

⚠️ 需要注意

‌优先级‌:.chatOptions() 只覆盖该 Agent 的模型调用参数,不改变 Agent 本身的循环、工具、记忆等配置,那些走 builder 的其他方法(如 .maxTurns()、.tools())。

‌作用范围‌:一次 Agent 调用里可能触发多轮模型请求(思考→工具→观察→再思考),每轮都会带上这份 chatOptions。

‌与模型绑定‌:不同框架的 ChatModel 有对应的 Options 类,如 DashScope 用 DashScopeChatOptions,智谱用 ZhiPuAiChatOptions,别混用。‌‌

相关推荐
瓶瓶持续学习中1 小时前
物理AI与具身智能的技术架构区别:从空间建模到机器人动作执行
人工智能·机器人
吃我一窝jio1 小时前
Docker+Jenkins+K8s全流程部署
java·开发语言·笔记·python
羲云网络1 小时前
GPT Image 2.6 精准编辑前,先排查参考图的访问权限与输入交接
图像处理·人工智能·aigc
snakeshe10101 小时前
ChatGLM行业垂直领域微调实战:从需求分析到数据集加载完整流程
人工智能
Resean02234 小时前
Spring 源码分析(六)循环依赖与三级缓存
java·spring·缓存
在爪洼山玩泥巴4 小时前
fastjson2 JSONPath 取不存在路径,为什么会抛 “not support”?
java·开发语言·jsonpath·fastjson
智联视频超融合平台5 小时前
视频 AI 的误报之战,正在从调参数卷到改架构
人工智能·大模型·边缘计算·视频监控·安防
水如烟5 小时前
孤能子视角:智能的边界不在算法强弱,在可形式化性——从概率法到因果推理,选择池的边界一直在那里
人工智能