Java AI 框架怎么选：Spring AI、Spring AI Alibaba 与 LangChain4j 实战对比

白小纯2025
0 阅读28分钟

Java AI 框架怎么选：Spring AI、Spring AI Alibaba 与 LangChain4j 实战对比

版本基准（审校更新：2026 年 6 月 17 日）

  • Spring AI: 2.0.0 GA（官方文档稳定版；GitHub Release 发布于 2026 年 6 月 12 日）
  • Spring AI Alibaba: 1.1.x 活跃版本线（对齐 Spring AI 1.1.x；具体版本以官方 BOM / Maven Central 为准）
  • Spring Boot: 4.x（Spring AI 2.0 线对齐 Boot 4.x；具体小版本以 BOM 为准）
  • LangChain4j: 1.16.2（GitHub Release 最新稳定版，发布于 2026 年 6 月 10 日）
  • Java: 示例统一按 Java 21 编写；实际项目请以所选框架、运行时和集成模块的最低要求为准

AI 框架迭代很快，本文的版本号用于统一示例和判断口径。落地前请再核对 BOM、Release Notes 和 Breaking Changes。

快速决策

你的情况推荐方案理由
Spring Boot 微服务体系 + 企业级治理需求Spring AI 2.0配置驱动、Micrometer 原生监控、Spring Security 集成
主用通义千问 + 需复杂多智能体编排Spring AI Alibaba官方 DashScope 集成、Graph 工作流、Nacos 治理
非 Spring 项目（Quarkus / Micronaut / 纯 Java）LangChain4j零框架依赖，官方 Quarkus 扩展
快速原型验证 / PoCLangChain4j无容器启动，5 行代码跑通
已有 Spring Boot 但追求低耦合LangChain4j社区 starter 可用，AI 层可独立演进
大型组织多团队协作混合方案核心服务用 Spring AI，独立服务用 LangChain4j

一句话总结：如果你的系统、配置、监控和安全都已经在 Spring 里，优先看 Spring AI；如果主用通义千问，并且需要 Graph / 多智能体编排，优先看 Spring AI Alibaba；如果更看重框架独立性、轻量接入和快速验证，优先看 LangChain4j。

01-comparison-quick-decision-v2.png

目录

  1. 核心定位差异
  2. 技术栈对比矩阵
  3. 性能与资源开销
  4. 选型决策树
  5. Spring AI 2.0 实战教程
  6. Spring AI Alibaba：国产生态增强版
  7. LangChain4j 实战教程
  8. 高级特性对比
  9. 混合架构方案
  10. 迁移指南
  11. 生产上线检查清单
  12. 故障排查手册
  13. 常见问题与误区

1. 核心定位差异

Spring AI 2.0（Spring 生态原生）

设计哲学：把 AI 能力作为 Spring 生态的“一等公民”，深度集成 Spring Boot 配置、自动装配、监控和安全体系。

核心优势：

  • ✅ 与 Spring Boot 4.x、Spring Security、Actuator 深度集成
  • ✅ 配置驱动（application.yml 统一管理，支持配置中心）
  • ✅ Chat Memory 与 Advisor 链路支持（可接入持久化记忆与上下文裁剪）
  • ✅ Micrometer 可观测性原生支持（指标 + 链路追踪）
  • ✅ 云原生友好（Spring Cloud 集成）
  • ✅ 企业级安全（Spring Security 权限控制）

适合场景：

  • 已有 Spring Boot 微服务体系
  • 强配置治理要求（多环境、多租户、配置中心）
  • 企业级可观测性要求（Prometheus + Grafana）
  • 团队熟悉 Spring 生态
  • 需要与 Spring Security / Spring Cloud 深度集成

不适合场景：

  • 非 Spring 项目（会引入整个 Spring 容器）
  • 追求极致启动速度（Spring 容器启动有开销）
  • 需要框架无关性（强依赖 Spring）

LangChain4j（Java 原生 AI 库）

设计哲学：为 JVM / Java 应用从零设计 AI 编排库，不绑定特定 Web 或 DI 框架。

核心优势：

  • ✅ 声明式 AI Services（接口 + 注解，类似 Spring Data）
  • ✅ 框架无关（可用于 Spring Boot、Quarkus、纯 Java）
  • ✅ 编程模型简洁（AiServices.create() 一行创建）
  • ✅ MCP 原生支持（Model Context Protocol）
  • ✅ 多模型提供商统一 API（OpenAI / Anthropic / Ollama 等）
  • ✅ 启动速度快（无容器开销）

适合场景：

  • 非 Spring 项目（Quarkus、Micronaut、纯 Java）
  • 需要框架灵活性（AI 层可独立演进）
  • 快速原型验证（5 行代码跑通）
  • 团队不熟悉 Spring 或不想引入 Spring 依赖
  • 追求极致启动速度（Serverless / FaaS）

不适合场景：

  • 需要 Spring 配置中心统一管理（需自行实现）
  • 需要 Micrometer 原生监控（需手动集成）
  • 团队已深度依赖 Spring 生态（不如用 Spring AI）

02-framework-core-positioning.png

2. 技术栈对比矩阵

维度Spring AI 2.0LangChain4j
基础要求Java 21+, Spring Boot 4.x示例按 Java 21；无框架硬绑定
依赖管理Spring AI BOMLangChain4j BOM
配置方式application.yml（配置驱动）代码配置（Builder 模式）
核心 APIChatClient, Advisor, ChatMemoryAiServices, ChatLanguageModel
编程风格Spring 依赖注入 + 配置声明式接口 + 注解
RAG 实现QuestionAnswerAdvisorContentRetriever + @SystemMessage
会话记忆Chat Memory + AdvisorChatMemory + MessageWindowChatMemory
工具调用@Tool + MCP Client@Tool + ToolExecutor + MCP
流式输出Flux<String>（Reactor）TokenStream（回调模式）
MCP 支持MCP Client + Server Boot StartersMCP Client + Server
多模态原生支持（Image / Audio / Video）原生支持（Image / Audio）
可观测性Micrometer（原生集成）需自行集成（提供 Listener 扩展点）
Spring Boot 集成原生（官方 starter）社区 starter（langchain4j-spring-boot-starter）
Quarkus 集成无官方支持（langchain4j-quarkus）
学习曲线Spring 团队低，非 Spring 团队高Java 开发者普遍低
框架耦合度高（强依赖 Spring）低（可独立使用）
社区活跃度Spring 官方维护，更新稳定社区驱动，迭代快速
模型支持数量覆盖主流模型与向量库，随 2.0 线持续扩展官方文档标注 20+ LLM 提供商、30+ 向量库

3. 性能与资源开销：怎么看才不误判

下面的数据适合当作“量级参考”，不适合直接当作采购或架构决策依据。LLM 应用的真实延迟通常主要由模型服务、网络、检索链路、工具调用和上下文长度决定，框架本身的差异更多体现在冷启动、依赖规模和运行时内存。

指标Spring AI 2.0LangChain4j说明
冷启动时间~3.5s~0.8sSpring 容器初始化开销
首次请求延迟~2.1s~1.8s含模型连接建立
稳态请求延迟~1.2s~1.2s模型推理为主要瓶颈，框架差异可忽略
内存占用（空载）~180MB~60MBSpring 容器 + 自动装配
内存占用（RAG）~350MB~200MB含向量库连接池
依赖 JAR 数量~120+~30+Spring 传递依赖多
GraalVM Native支持（实验性）支持（社区验证）原生镜像可大幅降低启动时间

关键结论：

  • 稳态请求差异通常不大：只要调用同一模型、同一向量库、同一检索策略，主要瓶颈往往不在 Java 框架层。
  • 冷启动和基础内存要单独看：Spring AI 会继承 Spring Boot 容器、自动装配和监控体系的成本；LangChain4j 裸用时更轻。
  • 生产压测必须用自己的链路做：是否启用 RAG、工具调用、流式输出、日志采样、重试和限流，都会显著改变结果。

03-infographic-performance-governance.png

4. 选型决策树

开始
  │
  ├─ 项目已使用 Spring Boot？
  │   ├─ 是 → 主用通义千问且需多智能体/Graph 编排？
  │   │        ├─ 是 → ✅ Spring AI Alibaba（DashScope 官方集成 + Graph 工作流）
  │   │        └─ 否 → 需要 Spring 配置体系（多环境、配置中心）？
  │   │                 ├─ 是 → ✅ Spring AI 2.0（配置驱动，治理友好）
  │   │                 └─ 否 → 需要框架灵活性（AI 层独立演进）？
  │   │                          ├─ 是 → ✅ LangChain4j（低耦合，可替换）
  │   │                          └─ 否 → ✅ Spring AI 2.0（生态一致性）
  │   └─ 否 → 使用 Quarkus / Micronaut？
  │            ├─ 是 → ✅ LangChain4j（官方 Quarkus 扩展）
  │            └─ 否 → 纯 Java / Serverless？
  │                     └─ 是 → ✅ LangChain4j（无框架依赖，启动快）
  │
  └─ 特殊场景
       ├─ 需要 Spring Cloud 集成 → ✅ Spring AI 2.0
       ├─ 需要 Micrometer 原生监控 → ✅ Spring AI 2.0
       ├─ 需要 MCP Server 能力 → ✅ Spring AI 2.0 或 LangChain4j
       ├─ 需要多框架兼容性 → ✅ LangChain4j
       ├─ 需要 Nacos 治理 Prompt/MCP → ✅ Spring AI Alibaba
       └─ 快速原型验证 → ✅ LangChain4j（启动更快）

4.1 选型决策分析

决策树能帮你快速排除明显不合适的方案，但真正的技术选型不应该只问“哪个框架功能更多”。更稳妥的做法，是把选择拆成五个维度：组织现状、运行环境、模型策略、编排复杂度和生产治理。

第一优先级：先看团队和系统已经站在哪里。

如果你的核心系统已经是 Spring Boot 微服务，配置中心、鉴权、审计、监控、链路追踪都围绕 Spring 体系建设，那么 Spring AI 2.0 的价值不只是“能调模型”，而是能把 AI 调用纳入现有工程治理。它适合把 AI 能力变成长期维护的企业服务，例如客服知识库、内部助手、工单分析、代码审查辅助、合同问答等。

如果你的系统不是 Spring，或者你希望 AI 层尽量不绑定业务框架，LangChain4j 的工程阻力更小。它可以作为一个普通 Java 库嵌入 Quarkus、Micronaut、命令行工具、批处理任务和轻量服务中。对 PoC、独立 Agent 服务、Serverless 任务来说，这种低耦合通常比“生态完整”更重要。

第二优先级：再看模型和供应商策略。

如果你主要使用 OpenAI、Anthropic、Ollama、Google、Azure OpenAI 等多家模型，并且希望随时切换，Spring AI 和 LangChain4j 都可以胜任。差异在于：Spring AI 更适合被 Spring Boot 配置体系托管；LangChain4j 更适合在代码层用 Builder 和接口组合出灵活结构。

如果你的主要模型是通义千问 / 百炼 DashScope，并且还希望接入 Nacos、ARMS、Spring Cloud Alibaba 或企业内部治理体系，Spring AI Alibaba 的优先级会上升。它不是替代 Spring AI 的另一套抽象，而是在 Spring AI 之上补齐国产模型、Graph 工作流、多智能体和分布式治理能力。

第三优先级：区分“简单 AI 调用”和“复杂智能体系统”。

如果需求只是普通聊天、RAG 问答、工具调用、结构化输出和流式响应，不要过早引入复杂工作流。Spring AI 2.0 或 LangChain4j 都能做，优先选与你现有技术栈摩擦最小的。

如果需求开始出现多阶段推理、条件分支、循环修正、人工审批、状态恢复、多 Agent 协作、执行过程可视化等特征，就要认真评估编排层。Spring AI Alibaba 的 Graph 更适合把流程显式建模；LangChain4j 则更适合用接口、服务对象和 Agentic 能力做轻量组合。前者偏“流程平台化”，后者偏“代码组合式”。

第四优先级：生产治理比 Demo 体验更重要。

AI Demo 往往只需要一个 API Key 和几行代码，但生产系统要处理更多问题：密钥托管、租户隔离、权限过滤、Token 成本、模型降级、超时重试、Prompt 版本、日志脱敏、评测集、灰度发布和审计追踪。

如果这些治理能力已经在 Spring 体系里，Spring AI 2.0 会减少很多重复建设。如果你选择 LangChain4j，也不是不能做生产治理，只是需要自己把配置、监控、限流、审计和发布流程补齐。这个成本在小项目里不明显，在多团队协作时会迅速放大。

第五优先级：避免把框架选择变成单选题。

大型组织完全可以混用：核心业务服务用 Spring AI 2.0 或 Spring AI Alibaba，把配置、监控、安全和审批流程管起来；独立 AI 实验服务、工具型服务、Quarkus 服务用 LangChain4j，保持快速迭代。关键是统一对外 API、日志规范、模型配置和评测标准，而不是强行让所有团队使用同一个库。

可以用下面这张判断表做最后确认：

决策问题更偏向 Spring AI 2.0更偏向 Spring AI Alibaba更偏向 LangChain4j
主系统是否已经是 Spring Boot？是是，且在 Spring Cloud Alibaba 体系内否，或只是轻量接入
是否强依赖配置中心、Actuator、Micrometer、Security？强依赖强依赖，并需要 Nacos / ARMS不强依赖，可自行集成
主要模型策略是什么？多厂商中立通义千问 / 百炼优先多厂商中立，代码侧灵活切换
是否需要复杂工作流和多 Agent？中等复杂度，应用层组合高复杂度，Graph / Workflow 显式建模中等复杂度，接口和 Agentic 组合
是否追求快速 PoC 和低启动成本？一般一般强
是否需要跨 Quarkus / Micronaut / 纯 Java？不适合不适合适合

最终建议：不要问“哪个框架最好”，而要问“哪个框架让我的团队少造轮子、少迁移、少背治理债”。如果答案是现有 Spring 体系能托住 AI 服务，选 Spring AI 2.0；如果答案是通义千问和多智能体编排是核心，选 Spring AI Alibaba；如果答案是轻量、独立、跨框架和快速验证，选 LangChain4j。

04-flowchart-selection-analysis.png

5. Spring AI 2.0 实战教程

5.1 Maven 依赖

<properties>
    <java.version>21</java.version>
    <spring-ai.version>2.0.0</spring-ai.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>${spring-ai.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- 模型提供商（按需选择一个） -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-model-openai</artifactId>
    </dependency>
    <!-- 向量库（按需选择） -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-vector-store-pgvector</artifactId>
    </dependency>
</dependencies>

<!-- Spring AI 2.0.0 GA 已发布到正式仓库；一般不再需要 spring-milestones。 -->

5.2 配置文件（配置驱动）

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4o
          temperature: 0.3
          max-tokens: 2048
    vectorstore:
      pgvector:
        index-type: HNSW
        distance-type: COSINE_DISTANCE
        dimensions: 1536
    # 可观测性（自动集成 Micrometer）
    observation:
      include-prompt: true
      include-completion: true

5.3 基础对话（ChatClient）

package com.example.ai.service;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;

@Service
@RequiredArgsConstructor
public class ChatService {

    private final ChatClient.Builder chatClientBuilder;

    public String chat(String userMessage) {
        return chatClientBuilder
                .build()
                .prompt()
                .system("你是企业 AI 助手，回答要专业、简洁。")
                .user(userMessage)
                .call()
                .content();
    }
}

5.4 RAG 问答（QuestionAnswerAdvisor）

package com.example.ai.service;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.QuestionAnswerAdvisor;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;

@Service
@RequiredArgsConstructor
public class RagService {

    private final ChatClient.Builder chatClientBuilder;
    private final VectorStore vectorStore;

    public String ask(String question) {
        SearchRequest searchRequest = SearchRequest.builder()
                .query(question)
                .topK(5)
                .similarityThreshold(0.7)
                .build();

        return chatClientBuilder
                .defaultAdvisors(
                    QuestionAnswerAdvisor.builder(vectorStore)
                        .searchRequest(searchRequest)
                        .userTextAdvise("基于以下上下文回答问题，如果上下文不包含答案，明确说明'无法从知识库中找到相关信息'。")
                        .build()
                )
                .build()
                .prompt()
                .user(question)
                .call()
                .content();
    }
}

5.5 流式输出（Flux）

package com.example.ai.service;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
import reactor.core.publisher.Flux;

@Service
@RequiredArgsConstructor
public class StreamService {

    private final ChatClient.Builder chatClientBuilder;

    public Flux<String> streamChat(String userMessage) {
        return chatClientBuilder
                .build()
                .prompt()
                .system("你是企业 AI 助手。")
                .user(userMessage)
                .stream()
                .content();
    }
}

对应 Controller：

@RestController
@RequiredArgsConstructor
public class ChatController {

    private final StreamService streamService;

    @GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> streamChat(@RequestParam String message) {
        return streamService.streamChat(message);
    }
}

5.6 会话记忆（Chat Memory）

Spring AI 2.0 提供 Chat Memory 相关抽象，可以通过 Advisor 把会话历史注入到 ChatClient 调用链中。生产环境通常会把内存实现替换为 Redis、数据库或自定义存储，并配合窗口裁剪、摘要压缩或权限隔离策略使用。

package com.example.ai.service;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.InMemoryChatMemory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MemoryConfig {

    @Bean
    public ChatMemory chatMemory() {
        return new InMemoryChatMemory();
    }
}

使用会话记忆的 Service：

@Service
@RequiredArgsConstructor
public class ConversationService {

    private final ChatClient.Builder chatClientBuilder;
    private final ChatMemory chatMemory;

    public String chat(String sessionId, String userMessage) {
        return chatClientBuilder
                .defaultAdvisors(
                    MessageChatMemoryAdvisor.builder(chatMemory)
                        .sessionId(sessionId)
                        .chatMemoryRetrieveSize(20)
                        .build()
                )
                .build()
                .prompt()
                .user(userMessage)
                .call()
                .content();
    }
}

5.7 工具调用（Function Calling）

package com.example.ai.tools;

import org.springframework.ai.tool.annotation.Tool;
import org.springframework.stereotype.Component;

@Component
public class EnterpriseTools {

    @Tool(description = "查询员工信息，输入员工 ID")
    public String getEmployeeInfo(String employeeId) {
        // 实际项目中调用 HR 系统 API
        return "员工 " + employeeId + "：张三，部门：研发，职级：P7";
    }

    @Tool(description = "查询差旅报销标准，输入城市名称")
    public String getTravelPolicy(String city) {
        // 实际项目中查询政策数据库
        return city + " 住宿上限 800 元/晚，餐饮补贴 150 元/天";
    }
}

6. Spring AI Alibaba：国产生态增强版

重要说明：Spring AI Alibaba 不是 Spring AI 的竞品，而是基于 Spring AI 构建的扩展框架。它复用 Spring AI 的核心抽象（ChatClient、ChatModel、Tool、MCP 等），在此之上叠加通义千问官方集成、Graph 工作流编排、多智能体框架和 Nacos 分布式治理能力。

6.1 核心定位

设计理念：面向国产模型生态（通义千问 / 百炼 DashScope）与企业级多智能体应用的 Spring AI 增强版。

与 Spring AI 的关系：

  • ✅ API 向后兼容：ChatClient 用法与 Spring AI 完全一致，代码可在不同模型间无缝迁移
  • ✅ 架构继承：复用 Spring AI 的 ChatModel、Advisor、VectorStore、MCP Client 等核心接口
  • ✅ 能力叠加：增加 Graph 有状态工作流、多智能体编排、Nacos 治理、ARMS 可观测等企业级能力

核心优势：

  • ✅ 通义千问官方一方集成（DashScopeChatModel，多模态、语音支持最完整）
  • ✅ Spring AI Alibaba Graph（对标 LangGraph 的 Java 实现，有状态、可循环、可中断恢复）
  • ✅ 多智能体编排（SequentialAgent、ParallelAgent、RoutingAgent、LoopAgent）
  • ✅ Nacos 集成（Prompt 模板分布式管理、MCP 注册发现、A2A 跨服务协同）
  • ✅ 阿里云生态整合（ARMS 可观测、OceanBase/AnalyticDB 向量库、SAA Sandbox 沙箱）

适合场景：

  • 主用通义千问 / 百炼 DashScope 模型
  • 需要复杂多智能体编排、有状态工作流（类似 LangGraph 但留在 Java 生态）
  • 已在 Spring Cloud Alibaba 体系内，需要 Nacos 统一治理
  • 需要 A2A（Agent-to-Agent）分布式协同
  • 企业级可观测（ARMS）与安全隔离（Sandbox）需求

6.2 版本与依赖

版本说明：Spring AI Alibaba 当前活跃版本线为 1.1.x（对齐 Spring AI 1.1.x）与 1.0.0.x（对齐 Spring AI 1.0.0 GA）。由于官方各渠道版本号存在不一致，建议以 Maven Central BOM 页 实时查询为准，不要写死版本号。

基线要求：

  • Java: 17+（基于 Spring Boot 3.x）
  • Spring Boot: 3.x
  • Spring AI: 与自身版本联动（1.0.0.x 线对齐 Spring AI 1.0.0；1.1.x 线对齐 Spring AI 1.1.x）

Maven 依赖示例：

<properties>
    <!-- 请以 Maven Central 实时版本为准，此处为占位示例 -->
    <spring-ai-alibaba.version>1.1.2.x</spring-ai-alibaba.version>
</properties>

<dependencyManagement>
    <dependencies>
        <!-- Spring AI Alibaba BOM（统一版本管理） -->
        <dependency>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-bom</artifactId>
            <version>${spring-ai-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- 通义千问模型接入（含 ChatModel/ChatClient 自动装配） -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
    </dependency>
    
    <!-- 可选：Graph 工作流编排 -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-graph-core</artifactId>
    </dependency>
    
    <!-- 可选：Nacos Prompt 模板管理 -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-nacos-prompt</artifactId>
    </dependency>
</dependencies>

重要提醒：groupId 是 com.alibaba.cloud.ai（注意不是 com.alibaba.cloud），容易与 Spring Cloud Alibaba 混淆。

6.3 基础对话（与 Spring AI 完全一致）

# application.yml
spring:
  ai:
    dashscope:
      api-key: ${AI_DASHSCOPE_API_KEY}  # 通义千问 API Key
      chat:
        options:
          model: qwen-plus
          temperature: 0.3

package com.example.ai.service;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;

@Service
@RequiredArgsConstructor
public class DashScopeChatService {

    // starter 自动装配出 DashScopeChatModel（实现 Spring AI 的 ChatModel 接口）
    private final ChatClient.Builder chatClientBuilder;

    public String chat(String userMessage) {
        // 用法与 Spring AI 原生 ChatClient 完全一致
        return chatClientBuilder
                .build()
                .prompt()
                .system("你是企业 AI 助手，回答要专业、简洁。")
                .user(userMessage)
                .call()
                .content();
    }
}

关键特性：常见 ChatClient 用法与 Spring AI 原生写法保持一致，模型切换主要发生在依赖、配置和模型能力适配层。

6.4 Graph 工作流编排（对标 LangGraph）

Spring AI Alibaba Graph 是 Java 生态中少数直接对标 LangGraph 的有状态工作流实现，支持：

  • ✅ 有状态图（StateGraph）：节点间传递结构化状态
  • ✅ 条件路由：根据状态动态决定下一个节点
  • ✅ 循环与中断：支持 interruptBefore 实现 human-in-the-loop
  • ✅ 状态持久化：checkpoint 机制，支持恢复执行
  • ✅ 可视化导出：PlantUML / Mermaid 图表

基本编程模型：

package com.example.ai.graph;

import com.alibaba.cloud.ai.graph.*;
import org.springframework.ai.chat.client.ChatClient;
import java.util.*;

public class QueryExpanderGraph {

    public CompiledGraph buildGraph(ChatClient.Builder chatClientBuilder) {
        // 1. 定义状态字段及其合并策略（ReplaceStrategy 表示覆盖写入）
        KeyStrategyFactory stateFactory = () -> {
            Map<String, KeyStrategy> strategies = new HashMap<>();
            strategies.put("query", new ReplaceStrategy());      // 用户查询
            strategies.put("expandedQuery", new ReplaceStrategy()); // 扩展后的查询
            strategies.put("content", new ReplaceStrategy());    // 最终回答
            return strategies;
        };

        // 2. 构建图：添加节点 + 定义边（START -> expander -> responder -> END）
        StateGraph graph = new StateGraph(stateFactory)
                // 添加查询扩展节点
                .addNode("expander", NodeAction.node_async(state -> {
                    String query = state.value("query", "");
                    ChatClient client = chatClientBuilder.build();
                    String expanded = client.prompt()
                            .user("将以下查询扩展为更详细的问题：" + query)
                            .call()
                            .content();
                    return Map.of("expandedQuery", expanded);
                }))
                // 添加回答节点
                .addNode("responder", NodeAction.node_async(state -> {
                    String expandedQuery = state.value("expandedQuery", "");
                    ChatClient client = chatClientBuilder.build();
                    String answer = client.prompt()
                            .user(expandedQuery)
                            .call()
                            .content();
                    return Map.of("content", answer);
                }))
                // 定义边（线性流程）
                .addEdge(StateGraph.START, "expander")
                .addEdge("expander", "responder")
                .addEdge("responder", StateGraph.END);

        // 3. 编译并返回
        return graph.compile();
    }

    public void execute(CompiledGraph compiled) {
        // 执行图（支持 threadId 做状态隔离）
        Optional<OverAllState> result = compiled.invoke(
                Map.of("query", "介绍一下 Spring AI"),
                RunnableConfig.builder().threadId("session-001").build()
        );
        
        if (result.isPresent()) {
            System.out.println("最终回答：" + result.get().value("content", ""));
        }
    }
}

条件路由示例（根据状态动态分支）：

// 添加条件边：根据意图路由到不同节点
graph.addConditionalEdges(
    "intentDetector",
    EdgeAction.edge_async(state -> {
        String intent = state.value("intent", "");
        return switch (intent) {
            case "query" -> "queryNode";
            case "execute" -> "executeNode";
            default -> StateGraph.END;
        };
    }),
    Map.of(
        "queryNode", "queryNode",
        "executeNode", "executeNode"
    )
);

流式输出：

AsyncGenerator<NodeOutput> stream = compiled.stream(
    Map.of("query", "你好"),
    RunnableConfig.builder().threadId("t1").build()
);

stream.forEach(output -> {
    System.out.println("节点 " + output.getNodeName() + " 输出：" + output.getState());
});

6.5 多智能体编排

内置多种编排模式：

// 顺序执行：Agent A -> Agent B -> Agent C
SequentialAgent sequential = new SequentialAgent(List.of(agentA, agentB, agentC));

// 并行执行：同时运行多个 Agent，收集结果
ParallelAgent parallel = new ParallelAgent(List.of(agentA, agentB, agentC));

// 路由 Agent：根据输入选择不同的子 Agent
RoutingAgent router = new RoutingAgent(Map.of(
    "intent1", agentA,
    "intent2", agentB
), intentClassifier);

// 循环 Agent：重复执行直到满足退出条件
LoopAgent loop = new LoopAgent(baseAgent, maxIterations);

6.6 Nacos 集成（分布式治理）

Prompt 模板分布式管理：

// 将 Prompt 模板存储在 Nacos 配置中心，支持动态更新
@Service
public class PromptService {
    
    @Autowired
    private NacosPromptTemplate nacosPromptTemplate;
    
    public String getSystemPrompt(String templateId) {
        // 从 Nacos 动态拉取 Prompt 模板
        return nacosPromptTemplate.get(templateId);
    }
}

MCP 注册与发现：

// MCP Server 自动注册到 Nacos，支持服务发现
@EnableNacosMcpServer
@SpringBootApplication
public class McpServerApplication {
    // MCP 工具自动注册到 Nacos，其他服务可动态发现调用
}

6.7 与 Spring AI / LangChain4j 的对比

维度Spring AI 2.0Spring AI AlibabaLangChain4j
通义千问集成需自行实现✅ 官方 starter社区支持
Graph 工作流❌ 无✅ 有状态 Graph（对标 LangGraph）❌ 无（需自行编排）
多智能体编排❌ 基础工具调用✅ Sequential/Parallel/Routing/Loop✅ 声明式 AiServices
Nacos 集成❌ 无✅ Prompt/MCP/A2A 治理❌ 无
ChatClient API✅ 原生✅ 完全兼容❌ 使用 AiServices
框架依赖Spring BootSpring Boot框架无关
适用模型多厂商中立主打通义千问多厂商中立

选型建议：

  • 如果主用通义千问且需要官方最完整支持（多模态、语音、最新模型） → Spring AI Alibaba
  • 如果需要复杂多智能体工作流（LangGraph 风格）但留在 Java 生态 → Spring AI Alibaba
  • 如果已在 Spring Cloud Alibaba + Nacos 体系内 → Spring AI Alibaba
  • 如果需要模型中立性、跨框架可移植 → Spring AI 或 LangChain4j

7. LangChain4j 实战教程

7.1 Maven 依赖

<properties>
    <langchain4j.version>1.16.2</langchain4j.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-bom</artifactId>
            <version>${langchain4j.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j</artifactId>
    </dependency>
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
    </dependency>
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-pgvector</artifactId>
    </dependency>
    <!-- Spring Boot 集成（可选） -->
    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-spring-boot-starter</artifactId>
    </dependency>
</dependencies>

7.2 声明式 AI Services（核心特色）

package com.example.ai;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;

public interface Assistant {

    @SystemMessage("你是企业知识助手，回答要专业、简洁。")
    String chat(@UserMessage String userMessage);
}

创建实例（代码配置）：

package com.example.ai.config;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

public class AiConfig {

    public static Assistant createAssistant() {
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o")
                .temperature(0.3)
                .maxTokens(2048)
                .build();

        return AiServices.builder(Assistant.class)
                .chatLanguageModel(model)
                .build();
    }
}

使用：

Assistant assistant = AiConfig.createAssistant();
String answer = assistant.chat("公司差旅报销标准是什么？");
System.out.println(answer);

7.3 RAG 问答（ContentRetriever）

package com.example.ai;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;

public interface RagAssistant {

    @SystemMessage("你是企业知识助手，基于检索到的上下文回答。如果上下文不包含答案，明确说明'无法从知识库中找到相关信息'。")
    String ask(@UserMessage String question);
}

配置 RAG：

package com.example.ai.config;

import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.rag.content.retriever.ContentRetriever;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.pgvector.PgVectorEmbeddingStore;

public class RagConfig {

    public static RagAssistant createRagAssistant() {
        EmbeddingStore<TextSegment> embeddingStore = PgVectorEmbeddingStore.builder()
                .host("localhost")
                .port(5432)
                .database("ai_db")
                .table("embeddings")
                .dimension(1536)
                .build();

        EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("text-embedding-3-small")
                .build();

        ContentRetriever retriever = EmbeddingStoreContentRetriever.builder()
                .embeddingStore(embeddingStore)
                .embeddingModel(embeddingModel)
                .maxResults(5)
                .minScore(0.7)
                .build();

        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o")
                .build();

        return AiServices.builder(RagAssistant.class)
                .chatLanguageModel(model)
                .contentRetriever(retriever)
                .build();
    }
}

7.4 会话记忆

package com.example.ai;

import dev.langchain4j.service.MemoryId;
import dev.langchain4j.service.UserMessage;

public interface ConversationAssistant {

    String chat(@MemoryId String sessionId, @UserMessage String message);
}

package com.example.ai.config;

import dev.langchain4j.memory.chat.ChatMemoryProvider;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

public class MemoryConfig {

    public static ConversationAssistant createWithMemory() {
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o")
                .build();

        // 每个 sessionId 独立的记忆窗口
        ChatMemoryProvider memoryProvider = sessionId ->
                MessageWindowChatMemory.withMaxMessages(20);

        return AiServices.builder(ConversationAssistant.class)
                .chatLanguageModel(model)
                .chatMemoryProvider(memoryProvider)
                .build();
    }
}

// 使用
ConversationAssistant assistant = MemoryConfig.createWithMemory();
assistant.chat("session-001", "我叫李四");
String reply = assistant.chat("session-001", "我叫什么名字？");
// 输出：你叫李四

7.5 工具调用

package com.example.ai.tools;

import dev.langchain4j.agent.tool.Tool;

public class EnterpriseTools {

    @Tool("查询员工信息，输入员工 ID")
    public String getEmployeeInfo(String employeeId) {
        return "员工 " + employeeId + "：张三，部门：研发，职级：P7";
    }

    @Tool("查询差旅报销标准，输入城市名称")
    public String getTravelPolicy(String city) {
        return city + " 住宿上限 800 元/晚，餐饮补贴 150 元/天";
    }
}

package com.example.ai;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;

public interface AgentAssistant {

    @SystemMessage("你是企业 AI 助手，可以调用工具查询信息。")
    String execute(@UserMessage String task);
}

package com.example.ai.config;

import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

public class AgentConfig {

    public static AgentAssistant createAgent() {
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4o")
                .build();

        EnterpriseTools tools = new EnterpriseTools();

        return AiServices.builder(AgentAssistant.class)
                .chatLanguageModel(model)
                .tools(tools)
                .build();
    }
}

7.6 流式输出

package com.example.ai;

import dev.langchain4j.service.TokenStream;
import dev.langchain4j.service.UserMessage;

public interface StreamingAssistant {

    TokenStream chat(@UserMessage String message);
}

StreamingAssistant assistant = AiServices.builder(StreamingAssistant.class)
        .streamingChatLanguageModel(streamingModel)
        .build();

assistant.chat("介绍一下 Java 21 的新特性")
        .onNext(System.out::print)
        .onComplete(response -> System.out.println("\n完成"))
        .onError(Throwable::printStackTrace)
        .start();

8. 高级特性对比

8.1 多模态支持

特性Spring AI 2.0LangChain4j
图片输入✅ 原生支持✅ 原生支持
音频输入✅ 原生支持✅ 原生支持
视频输入✅ 原生支持❌ 需自行实现
图片生成✅ 通过 ImageClient✅ 通过 ImageModel

Spring AI 示例：

var imageResource = new ClassPathResource("product.jpg");
var userMessage = new UserMessage(
    "这个产品有什么特点？",
    List.of(new Media(MimeTypeUtils.IMAGE_JPEG, imageResource))
);

LangChain4j 示例：

ImageContent imageContent = ImageContent.from("https://example.com/product.jpg");
UserMessage message = UserMessage.from(
    TextContent.from("这个产品有什么特点？"),
    imageContent
);

8.2 MCP（Model Context Protocol）支持

特性Spring AI 2.0LangChain4j
MCP Client✅ 连接外部 MCP Server✅ 连接外部 MCP Server
MCP Server✅ 可通过 MCP Server Boot Starters 暴露工具✅ 可作为 MCP Server 暴露工具

说明：如果只是“调用外部工具”，两者都能做 MCP Client；如果要把 Java 服务暴露成 MCP Server，Spring AI 2.0 已提供 Server Boot Starters，LangChain4j 也有对应 MCP 能力。选型重点不再是“有没有 MCP”，而是你更希望 MCP 服务纳入 Spring Boot 治理，还是保持轻量独立。

LangChain4j MCP Server 示例（伪代码，具体 API 以所用版本文档为准）：

// 将 Java 工具暴露为 MCP Server，供其他 AI 应用调用
McpServer server = McpServer.builder()
        .tools(new EnterpriseTools())
        .port(8080)
        .build();
server.start();

8.3 多智能体与工作流编排

特性Spring AI 2.0Spring AI AlibabaLangChain4j
有状态工作流（Graph）需基于业务代码组合✅ StateGraph（对标 LangGraph）需基于 Agentic / 业务代码组合
条件路由需自行组合✅ ConditionalEdges可组合实现
循环与中断恢复需自行组合✅ Loop + interruptBefore可组合实现
状态持久化需自行接入✅ Checkpoint 机制需自行接入
多智能体编排模式基础工具调用 + 业务编排✅ Sequential/Parallel/Routing/Loop✅ AiServices / Agentic 能力可组合
可视化导出❌ 无✅ PlantUML / Mermaid❌ 无

说明：

  • Spring AI Alibaba 的优势在于显式 Graph / Workflow 抽象，适合需要可视化、可恢复、可治理的复杂流程。
  • LangChain4j 的优势在于轻量和可组合，适合用 Java 接口、服务对象和 Agentic 模块逐步搭建智能体能力。
  • Spring AI 2.0 更偏底层抽象、模型接入、RAG、工具调用、观测和 Spring Boot 集成；复杂业务流程通常交给应用层或 Spring AI Alibaba 处理。

9. 混合架构方案

对于大型组织，可以在不同场景混用三者：

┌─────────────────────────────────────────────────────────┐
│  核心业务服务（Spring AI 2.0 / Spring AI Alibaba）        │
│  - Spring AI 2.0：模型中立、多厂商切换                    │
│  - Spring AI Alibaba：主用通义千问 + Graph 多智能体       │
│  - 配置治理（多环境、配置中心、Nacos）                     │
│  - 可观测性（Micrometer + ARMS + Prometheus）            │
│  - 安全审计（Spring Security + OAuth2）                  │
│  - 会话管理（Chat Memory + Redis / DB）                  │
└──────────────────┬──────────────────────────────────────┘
                   │ REST API / gRPC
┌──────────────────▼──────────────────────────────────────┐
│      独立 AI 服务（LangChain4j）                          │
│  - 快速原型验证（PoC / MVP）                              │
│  - 非 Spring 项目（Quarkus 微服务）                       │
│  - 轻量级 AI 能力（无需 Spring 依赖）                     │
│  - MCP Server（暴露工具给其他 AI 应用）                   │
└─────────────────────────────────────────────────────────┘

实施建议：

  1. 核心业务用 Spring AI 系（配置治理 + 可观测性）
    • 多厂商模型 → Spring AI 2.0
    • 主用通义千问 + 需 Graph 工作流 → Spring AI Alibaba
  2. 独立 AI 服务用 LangChain4j（低耦合 + 快速迭代）
  3. 通过 REST API / gRPC 统一对外暴露
  4. 共享向量库和模型提供商配置

特殊场景补充：

  • 如果团队同时有 Spring Boot 微服务（用 Spring AI）和 Quarkus 微服务（用 LangChain4j），通过 API Gateway 统一入口，后端各自选型。
  • 如果需要 A2A（Agent-to-Agent）跨服务协同，可用 Spring AI Alibaba 的 Nacos MCP 注册发现能力实现分布式 Agent 通信。

05-framework-hybrid-architecture-v2.png

10. 迁移指南

10.1 从 LangChain4j 迁移到 Spring AI

适用场景：团队决定深度拥抱 Spring 生态，需要配置中心和可观测性。

核心映射：

LangChain4jSpring AI 2.0
AiServices.builder()ChatClient.Builder
@SystemMessage.system()
@UserMessage.user()
ChatMemoryMessageChatMemoryAdvisor
ContentRetrieverQuestionAnswerAdvisor
@Tool@Tool（相同）

迁移步骤：

  1. 替换依赖（BOM 从 langchain4j 改为 spring-ai）
  2. 将代码配置迁移到 application.yml
  3. 将 AiServices 接口改为 ChatClient 调用
  4. 将 ChatMemory 改为 MessageChatMemoryAdvisor
  5. 添加 Micrometer 监控配置

10.2 从 Spring AI 迁移到 LangChain4j

适用场景：需要脱离 Spring 依赖，或迁移到 Quarkus。

迁移步骤：

  1. 替换依赖（BOM 从 spring-ai 改为 langchain4j）
  2. 将 application.yml 配置迁移到代码 Builder
  3. 将 ChatClient 调用改为 AiServices 接口
  4. 将 Advisor 改为 ContentRetriever
  5. 自行集成可观测性（Micrometer 或其他方案）

注意事项：

  • Spring AI 的配置驱动能力（多环境、配置中心）需要自行实现
  • Micrometer 监控需要手动集成
  • Chat Memory / Advisor 相关能力需要用 ChatMemoryProvider 或业务自定义记忆层替代

11. 生产上线检查清单

安全

检查项具体措施优先级
API Key 管理使用 Secret Manager（AWS / GCP / Vault），禁止硬编码P0
检索权限过滤RAG 检索前校验用户权限，防止越权访问P0
PII 脱敏Prompt 日志不记录个人身份信息，使用脱敏中间件P0
输入校验限制输入长度，过滤 Prompt 注入攻击P1
输出过滤检测并过滤敏感信息泄露P1

可靠性

检查项具体措施优先级
Token 限制设置单次请求 max-tokens 上限P0
熔断降级模型超时 / 不可用时返回兜底响应P0
无答案处理上下文不足时明确拒答，不编造P0
重试策略指数退避重试，避免雪崩P1
限流按用户 / 租户限制 QPSP1

可观测性

检查项具体措施优先级
指标监控请求延迟、Token 用量、错误率P0
链路追踪请求 → 检索 → 模型调用全链路P1
日志结构化日志，含 traceId、sessionIdP1
告警错误率 > 5%、延迟 > 10s 触发告警P1

质量

检查项具体措施优先级
评测集离线评测集 >= 50 条，覆盖核心场景P0
来源引用回答附带知识库来源引用P1
A/B 测试新 Prompt / 模型上线前做 A/B 对比P2

12. 故障排查手册

常见问题及解决方案

问题可能原因解决方案
Spring AI 启动报 Bean 找不到缺少 starter 依赖或版本不匹配检查 BOM 版本，确认 spring-ai-starter-model-xxx 已引入
LangChain4j 模型调用超时网络问题或模型提供商限流配置 timeout、添加重试逻辑、检查 API Key 配额
RAG 检索结果不相关向量维度不匹配或相似度阈值过低确认 embedding 模型维度与向量库一致，调高 similarityThreshold
会话记忆丢失使用了 InMemory 实现，重启后丢失生产环境使用 Redis / 数据库持久化
工具调用不触发工具描述不清晰，模型无法判断何时调用优化 @Tool 描述，使其更具体明确
流式输出中断网络不稳定或客户端断开添加错误处理和重连逻辑
Token 超限上下文过长（记忆 + 检索 + 用户输入）限制记忆窗口大小，控制检索结果数量
Spring AI 依赖拉取失败仓库配置、BOM 版本或镜像缓存异常优先确认使用 GA 版本；只有使用 M/RC 预发布版本时才需要配置 Spring Milestone 仓库

性能调优建议

  1. 减少冷启动时间：使用 Spring AOT / GraalVM Native Image
  2. 降低内存占用：按需引入依赖，避免引入不需要的 starter
  3. 优化 RAG 延迟：使用 HNSW 索引、预热向量库连接池
  4. 控制 Token 成本：设置 max-tokens、使用上下文压缩、选择合适的模型

13. 常见问题与误区

Q1: Spring AI 2.0 和 LangChain4j 能同时用吗？

可以。两者没有冲突，可以在同一个项目中共存。但建议明确分工：核心业务用一个，辅助功能用另一个，避免维护两套 AI 抽象层。

Q2: LangChain4j 不能用于 Spring Boot？

误区。可以用，社区有 langchain4j-spring-boot-starter，支持自动装配和配置注入。但集成深度不如 Spring AI 原生（缺少 Micrometer、Actuator 等自动集成）。

Q3: Spring AI 2.0 只能用于 Spring Boot？

理论上可以独立使用核心 API，但会失去配置驱动、自动装配、可观测性等核心优势。如果不用 Spring Boot，选 LangChain4j 更合理。

Q4: 两者的 RAG 实现有什么本质区别？

Spring AI：通过 Advisor 模式（QuestionAnswerAdvisor）在 ChatClient 调用链中插入检索逻辑，配置驱动。 LangChain4j：通过 ContentRetriever 在 AiServices 构建时注入检索器，代码驱动。

本质上都是"检索 → 拼接上下文 → 调用模型"，区别在于配置方式和扩展点。

Q5: 生产环境推荐哪个？

没有绝对答案。如果你的团队和基础设施已经是 Spring 生态，Spring AI 2.0 的治理能力（配置中心、监控、安全）会让你省很多事。如果你需要灵活性或不在 Spring 生态中，LangChain4j 是更好的选择。

Q6: 两者的版本稳定性如何？

截至 2026 年 6 月 17 日：

  • Spring AI 2.0.0 已发布 GA。它比 1.x 更适合新项目评估，但从 1.1.x 升级到 2.0.0 需要阅读官方升级说明。
  • LangChain4j 1.16.2 已是 1.x 稳定线的较新版本，迭代速度很快，部分模块仍可能在小版本中出现 Breaking Changes。

生产使用建议锁定版本号，关注 Release Notes 中的 Breaking Changes。

Q7: Spring AI Alibaba 与 Spring AI 是什么关系？

不是竞品，是增强版。Spring AI Alibaba 基于 Spring AI 构建，复用其 ChatClient、ChatModel、Tool、MCP 等核心抽象，在此之上叠加：

  • 通义千问官方集成（DashScope starter）
  • Graph 有状态工作流（对标 LangGraph）
  • 多智能体编排（Sequential/Parallel/Routing/Loop）
  • Nacos 分布式治理（Prompt/MCP/A2A）

API 迁移成本较低：常见 ChatClient 用法与 Spring AI 保持一致，但依赖、配置、模型能力和扩展模块仍需按版本核验。选择 Spring AI Alibaba 通常是因为主用通义千问或需要复杂多智能体编排。

Q8: 什么时候选 Spring AI Alibaba 而不是 Spring AI？

优先考虑 Spring AI Alibaba 的场景：

  • ✅ 主用通义千问 / 百炼 DashScope（官方一方集成，支持最完整）
  • ✅ 需要 LangGraph 风格的有状态工作流（StateGraph、条件路由、循环、中断恢复）
  • ✅ 需要多智能体编排框架（开箱即用的 Sequential/Parallel/Routing/Loop）
  • ✅ 已在 Spring Cloud Alibaba + Nacos 体系内（Prompt/MCP 统一治理、A2A 协同）

如果你需要模型中立性（频繁切换不同厂商模型）或不依赖阿里云生态，Spring AI 原生版更合适。

参考资料

avatar
文章
阅读
粉丝