Spring AI 2.0 深度拆解：当 Java 企业级框架学会「AI 原生思维」——从 ChatClient 流式 API、MCP 工具调用到 Advisors 可组合架构的工程全貌

前言：为什么 2026 年的 Java 开发者必须关注 Spring AI

2026 年 6 月，Spring AI 2.0 GA 正式发布。这个版本不是一次普通的版本号跃迁——它把 Spring AI 从「一个调用 LLM API 的工具包」彻底升级为「企业级 AI 工程的全栈框架」。

在此之前，Java 生态的 AI 集成经历了三个阶段：

• 第一阶段（2023-2024）：手写 HTTP 调用，拼 prompt，自己处理流式响应。每个项目写一堆工具类，代码到处都是。
• 第二阶段（2024-2025）：Spring AI 1.x 出现，有了 ChatClient、模板化 prompt、向量存储抽象。但工具调用（Function Calling）硬编码在模型配置里，没有拦截器链，没有生产级的可观测性。
• 第三阶段（2026+）：Spring AI 2.0 GA。强制 Java 21、Spring Boot 4.0、Spring Framework 7.0。带来了可组合的 Advisors API、声明式 Tool Calling、ChatClient 流式 API、MCP 协议原生支持、指标埋点自动集成。

这篇文章从底层架构到生产实战，完整拆解 Spring AI 2.0 的每一个核心模块。

一、架构总览：Spring AI 2.0 的六层设计

┌─────────────────────────────────────────────────┐
│                  Application                      │
├─────────────────────────────────────────────────┤
│       ChatClient (Fluent API)                    │
├─────────────────────────────────────────────────┤
│  Advisors Chain (可组合拦截器)                   │
├─────────────────────────────────────────────────┤
│  ChatModel / EmbeddingModel / ImageModel         │
│  (统一抽象层, SPI 多提供商)                      │
├─────────────────────────────────────────────────┤
│  Tool Registry / Function Callback (MCP支持)     │
├─────────────────────────────────────────────────┤
│  VectorStore / Document ETL Pipeline             │
├─────────────────────────────────────────────────┤
│  Observability (Micrometer + Micrometer Tracing) │
└─────────────────────────────────────────────────┘

每一层都解决了 1.x 时代的一个痛点：

二、ChatClient：统一 Fluent API 的工程哲学

Spring AI 2.0 最核心的 API 就是 ChatClient。它长得像 WebClient、RestClient，用起来也像。

2.1 基础用法

@Bean
CommandLineRunner demo(ChatClient.Builder builder) {
    return args -> {
        ChatClient client = builder.build();
        String response = client.prompt("用一句话解释什么是CAP定理")
            .call()
            .content();
        System.out.println(response);
    };
}

这是最基础的调用。但它的设计精妙之处在于 Fluent API 的分层结构——

2.2 Fluent API 分层

ChatClient 的 API 分两个阶段：

第一阶段：PromptRequest（prompt() 返回）

• prompt(String userText)：最简单的用户消息
• prompt(Prompt prompt)：完整的 Prompt 对象，可包含 SystemMessage、UserMessage、Tool 配置
• prompt()：返回 PromptBuilder，可以逐步构造

第二阶段：PromptResponse（call() / stream() 返回）

• call().content()：同步调用，拿 String
• call().entity(MyClass.class)：同步调用，结果自动映射为 POJO（Structured Output）
• stream().content()：流式调用，返回 Flux
• stream().entity(MyClass.class)：流式调用，映射为 Flux 的 POJO

2.3 Structured Output：AI 输出自动转 POJO

这是生产中最常用的功能之一。以前你得自己拼 prompt「请以 JSON 格式返回」，再手动解析。现在：

public record ArticleRecommendation(String title, String summary, int estimatedReadMinutes) {}

ArticleRecommendation rec = chatClient.prompt()
    .user("推荐3篇关于Kubernetes的最佳实践文章")
    .call()
    .entity(ArticleRecommendation.class);

System.out.println(rec.title());       // "K8s 生产环境网络配置实战"
System.out.println(rec.summary());     // "本文深入探讨..."

底层原理是：Spring AI 根据目标 POJO 的字段名和类型，自动生成 JSON Schema 传给模型（通过 response_format 参数），然后解析模型的 JSON 输出映射为 POJO。支持嵌套对象、List、Optional。

对于复杂场景，还可以自定义 StructuredOutputConverter：

BeanOutputConverter<List<ArticleRecommendation>> converter =
    new BeanOutputConverter<>(new ParameterizedTypeReference<>() {});

String jsonSchema = converter.getJsonSchema();
// 把 jsonSchema 传给 prompt 做格式化约束
Prompt prompt = new Prompt(
    new UserMessage("推荐3篇K8s文章"),
    new GenerationOptions(jsonSchema)
);

2.4 多轮对话与 Chat Memory

ChatClient chatClient = builder
    .defaultSystem("你是一个K8s运维专家，回答要简洁")
    .build();

// 第一轮
String first = chatClient.prompt()
    .user("什么是Pod的QoS等级？")
    .call()
    .content();

// 第二轮（携带历史）
String second = chatClient.prompt()
    .user("Guaranteed和Burstable的区别是什么？")
    .advisors(a -> a.bean(new MessageChatMemoryChatMemoryAdvisor(
        new InMemoryChatMemory(), "default", 10)))
    .call()
    .content();

MessageChatMemoryChatMemoryAdvisor 会自动从历史会话中提取最近 10 条消息，拼入请求。还有 VectorStoreChatMemoryAdvisor 可以把历史存到向量数据库，支持超长会话。

三、Advisors 架构：可组合拦截器链的设计革命

这是 Spring AI 2.0 最有工程价值的设计。如果你写过 Spring WebFlux 的 WebFilter，那理解 Advisors 毫无难度。

3.1 什么是 Advisor？

Advisor 是一个拦截器，在发送给 LLM 的请求之前（before）和 LLM 返回响应之后（after）做处理：

public interface CallAroundAdvisor {
    AdvisorResponse aroundCall(AdvisorRequest request, CallAroundAdvisorChain chain);
}

每个 Advisor 可以：

1. 改写请求：往 prompt 里注入上下文（比如当前时间、用户信息、RAG 文档片段）
2. 改写响应：对 LLM 返回做后处理（过滤敏感词、格式化输出）
3. 短路跳过：如果前置条件不满足，直接返回兜底响应，不调 LLM

3.2 内置 Advisors

Spring AI 2.0 内置了十几个 Advisor：

// 1. Prompt 层面
new PromptChatMemoryAdvisor(memory, "default", 20)  // 注入聊天历史
new VectorStoreChatMemoryAdvisor(vectorStore)         // 向量化存储历史

// 2. RAG 层面
new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults())  // 检索增强

// 3. 安全层面
new SafeGuardAdvisor(patterns)  // 内容安全过滤

// 4. 日志层面
new SimpleLoggerAdvisor()       // 打印请求/响应日志

3.3 自定义 Advisor：实战一个「请求审计 Advisor」

假设我们需要记录每一次 LLM 调用的用户 ID、token 消耗和延迟：

@Component
public class AuditLogAdvisor implements CallAroundAdvisor {

    private final AuditLogRepository repository;

    public AuditLogAdvisor(AuditLogRepository repository) {
        this.repository = repository;
    }

    @Override
    public String getName() {
        return "AuditLogAdvisor";
    }

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public AdvisorResponse aroundCall(AdvisorRequest request, CallAroundAdvisorChain chain) {
        long start = System.nanoTime();
        String userId = extractUserId(request);
        
        try {
            AdvisorResponse response = chain.nextAroundCall(request);
            long elapsed = (System.nanoTime() - start) / 1_000_000;
            
            repository.save(new AuditLog(
                userId,
                request.userText(),
                response.response().getMetadata().getUsage().getTotalTokens(),
                elapsed
            ));
            return response;
        } catch (Exception e) {
            repository.save(new AuditLog(userId, request.userText(), -1, -1, e.getMessage()));
            throw e;
        }
    }
    
    private String extractUserId(AdvisorRequest request) {
        // 从 request 的上下文里取用户标识
        return request.adviseContext().getOrDefault("userId", "anonymous").toString();
    }
}

// 使用
chatClient.prompt()
    .user("帮我分析这段日志中的错误")
    .advisors(a -> a
        .param("userId", "user-12345")
        .bean(new AuditLogAdvisor(repository))
        .bean(new SafeGuardAdvisor(blockPatterns))
    )
    .call()
    .content();

3.4 Advisors 的排序与组合

多个 Advisor 形成一个洋葱链：

Request → AuditLogAdvisor → SafeGuardAdvisor → ChatModel → Response
         ←               ←                  ←

排序规则：

1. @Order 注解或 getOrder() 方法，值越小越靠近外层
2. 外层先执行 before，后执行 after

典型生产配置：

@Bean
ChatClient.Builder chatClientBuilder(
        VectorStore vectorStore,
        AuditLogRepository logRepo,
        SensitiveWordFilter filter) {
    return ChatClient.builder()
        .defaultAdvisors(
            new SimpleLoggerAdvisor(),           // 日志：最外层
            new AuditLogAdvisor(logRepo),         // 审计
            new SafeGuardAdvisor(filter),         // 安全过滤
            new QuestionAnswerAdvisor(vectorStore) // RAG：最内层
        );
}

四、Tool Calling 2.0：从硬编码到声明式函数注册

Spring AI 1.x 的工具调用需要手动配置 JSON Schema 和函数映射。2.0 引入了 @Tool 注解，彻底简化。

4.1 @Tool 注解：最简单的函数注册

@Component
public class WeatherTools {

    @Tool(name = "get_weather", description = "获取指定城市的天气信息")
    public String getWeather(
            @ToolParam(description = "城市名称, 如北京、上海") String city) {
        WeatherClient client = new WeatherClient();
        WeatherData data = client.query(city);
        return String.format("城市: %s, 温度: %.1f°C, 湿度: %d%%",
            data.city(), data.temperature(), data.humidity());
    }
}

注册到 ChatClient：

ChatClient client = ChatClient.builder(chatModel)
    .defaultTools("getWeather")  // 按 Bean 名称或方法名引用
    .build();

String response = client.prompt()
    .user("北京今天天气怎么样？穿什么衣服合适？")
    .call()
    .content();
// 模型会自动判断需要调用 getWeather("北京"), 获取结果后生成回答

4.2 底层原理：ToolSpecification 的自动推导

@Tool 注解的魔法在于 ToolSpecification 的自动解析。Spring AI 2.0 在启动时扫描所有 @Tool 方法，生成 OpenAI/Anthropic 兼容的 JSON Schema。

对于上面的 getWeather 方法，生成的 Schema 等价于：

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "获取指定城市的天气信息",
    "parameters": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string",
          "description": "城市名称, 如北京、上海"
        }
      },
      "required": ["city"]
    }
  }
}

支持的参数类型：String、int/long、double/float、boolean、enum、List，以及 @ToolParam(required = false) 可选参数。

4.3 编程式 Tool Callback：更灵活的场景

对于需要动态注册工具的场合，使用 ToolCallback 接口：

ToolCallback orderQueryCallback = ToolCallbacks.from(
    "query_order",
    "查询订单信息，参数为订单号",
    (String orderId) -> {
        Order order = orderService.findByOrderId(orderId);
        return """
            订单号: %s
            状态: %s
            金额: %.2f
            下单时间: %s
            """.formatted(order.id(), order.status(), order.amount(), order.createdAt());
    }
);

ChatClient client = ChatClient.builder(chatModel)
    .defaultTools(orderQueryCallback)
    .build();

4.4 多工具决策：模型如何选择？

当一个 prompt 同时激活多个工具时，模型会自行判断调用哪个。Spring AI 2.0 支持三种模式：

spring:
  ai:
    chat:
      client:
        tool-choice: auto          # 默认，模型自行决定
        # tool-choice: none        # 强制不调工具
        # tool-choice: required    # 强制至少调一个工具
        # tool-choice: my_function # 强制调特定工具

生产建议：对于需要工具调用的场景，使用 tool-choice: auto，但通过 System Prompt 做引导。

4.5 MCP 协议支持：工具生态的开放化

Spring AI 2.0 原生支持 MCP（Model Context Protocol），可以动态接入 MCP Server 提供的工具：

// 配置一个 MCP 客户端
@Bean
McpClient mcpFileSystemClient() {
    return McpClient.using(new StdioMcpTransport.Builder()
        .command("npx", "-y", "@modelcontextprotocol/server-filesystem", "/data")
        .build());
}

// 把 MCP 工具注册到 ChatClient
ChatClient client = ChatClient.builder(chatModel)
    .defaultTools(
        ToolCallbacks.from("get_weather", ...),
        new McpToolCallback(mcpFileSystemClient, "read_file")
    )
    .build();

这意味着你可以用 MCP 协议一键接入文件系统、数据库查询、GitHub API 等数百个社区 MCP Server 提供的工具。

五、RAG 实战：企业级知识库从 0 到 1

5.1 完整的 ETL Pipeline

Spring AI 2.0 重新设计了 Document ETL 管线，把 RAG 数据准备变成了声明式 Pipeline：

@Component
public class KnowledgePipeline {

    private final DocumentReadService reader;
    private final DocumentTransformService transformer;
    private final DocumentWriteService writer;

    public KnowledgePipeline(
            DocumentReadService reader,
            DocumentTransformService transformer,
            DocumentWriteService writer) {
        this.reader = reader;
        this.transformer = transformer;
        this.writer = writer;
    }

    @PostConstruct
    public void run() {
        var pipeline = new DocumentPipeline(reader, transformer, writer);
        pipeline.execute(); // 自动执行：读取→拆分→写入向量库
    }
}

读取阶段支持多种文档类型：

spring:
  ai:
    etl:
      reader:
        json: classpath:/knowledge/*.json
        text: classpath:/knowledge/*.txt
        pdf: classpath:/knowledge/*.pdf
      transformer:
        token-text-splitter:
          max-tokens: 500
          chunk-overlap: 50
      writer:
        vector-store: pgvector

Document Transformers 链（洋葱模型）：

DocumentTransformer chain = DocumentTransformers.builder()
    .tokenTextSplitter(500, 50)
    .keywordMetadataEnricher()   // 自动提取关键词加入元数据
    .summaryMetadataEnricher(chatModel)  // 自动生成摘要
    .build();

5.2 Advisor 驱动的 RAG 查询

RAG 查询通过 QuestionAnswerAdvisor 实现。它是最典型的生产级用法：

ChatClient client = ChatClient.builder(chatModel)
    .defaultAdvisors(
        new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()
            .withTopK(5)
            .withSimilarityThreshold(0.75))
    )
    .build();

String answer = client.prompt()
    .user("我们的订单系统在生产环境遇到了哪些已知问题？")
    .call()
    .content();

QuestionAnswerAdvisor 做的事情：

1. 接收 user prompt
2. 用 EmbeddingModel 将 prompt 向量化
3. 向量检索 topK 文档片段
4. 把文档片段注入到 SystemPrompt 中
5. 调用 LLM 生成回答
6. 附上引用来源

5.3 高级 RAG：重新排序与混合检索

// 混合检索：向量 + 关键词 BM25
SearchRequest request = SearchRequest.builder()
    .query("订单超时问题排查")
    .topK(20)
    .similarityThreshold(0.6)
    .searchType(SearchType.HYBRID)  // 开启混合检索
    .rerankTopK(5)                   // 重排序后取前5
    .build();

Advisor ragAdvisor = new QuestionAnswerAdvisor(vectorStore, request);

// 多源 RAG：先查知识库，再查工单系统
Advisor multiSourceRag = new SequentialAdvisorChain(
    new QuestionAnswerAdvisor(knowledgeBase, request),
    new FunctionCallingAdvisor(ticketSystemTool)
);

六、多提供商抽象：一套代码对接 17 家大模型

Spring AI 2.0 的模型抽象层可以让你在一个配置里切换多个提供商。

6.1 配置多个模型

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-5-mini
          temperature: 0.7
    anthropic:
      api-key: ${ANTHROPIC_API_KEY}
      chat:
        options:
          model: claude-sonnet-4-20260514
    ollama:
      chat:
        options:
          model: qwen3.5:72b

6.2 根据场景动态选择模型

@Component
public class SmartModelRouter {

    private final ChatModel openaiModel;
    private final ChatModel claudeModel;
    private final ChatModel localModel;

    public SmartModelRouter(
            @Qualifier("openAiChatModel") ChatModel openai,
            @Qualifier("anthropicChatModel") ChatModel claude,
            @Qualifier("ollamaChatModel") ChatModel local) {
        this.openaiModel = openai;
        this.claudeModel = claude;
        this.localModel = local;
    }

    public ChatClient forTask(TaskType task) {
        ChatModel model = switch (task) {
            case CODE_GENERATION -> claudeModel;    // Claude 代码能力强
            case QUICK_CHAT -> openaiModel;          // GPT 速度快、成本低
            case PRIVATE_DATA -> localModel;         // 内部数据用本地模型
        };
        return ChatClient.builder(model).build();
    }
}

6.3 Token 计费追踪

@Bean
ChatClient.Builder monitoredBuilder(List<ChatModel> models) {
    return ChatClient.builder(models.get(0))
        .defaultAdvisors(new CallbackAroundAdvisor(
            (request, chain) -> {
                Usage usage = request.getUsage();
                log.info("模型={}, 输入token={}, 输出token={}",
                    request.getModel(), usage.getPromptTokens(), usage.getCompletionTokens());
                return chain.next(request);
            }
        ));
}

七、生产级可观测性

7.1 自动指标收集

Spring AI 2.0 集成了 Micrometer，开箱即出 AI 指标：

结合 Grafana 面板，你可以直观看到模型的 token 消耗趋势、P99 延迟、错误率。

7.2 分布式追踪

spring:
  ai:
    tracing:
      enabled: true
      export:
        endpoint: http://jaeger:4318/v1/traces

每次 LLM 调用都会产生一个 Span，包含：

• 模型名称
• 输入/输出 token 数
• 工具调用链
• 延迟

配合 Micrometer Tracing，可以跟应用的 HTTP 请求串联起端到端的追踪链路：

HTTP /api/ask → Service Layer → ChatModel (LLM call) → Tool: query_order → Database
   [trace]        [span]          [span: 2.3s]         [span: 150ms]     [span: 45ms]

7.3 生产告警规则

# PrometheusRule
groups:
  - name: spring-ai
    rules:
      - alert: HighLLMLatency
        expr: spring_ai_chat_duration_seconds_p99 > 10
        for: 5m
        annotations:
          summary: "LLM P99 延迟超过 10 秒"

      - alert: HighTokenUsage
        expr: rate(spring_ai_chat_tokens_total[5m]) > 100000
        annotations:
          summary: "5 分钟 token 消耗超过 10 万"

      - alert: HighErrorRate
        expr: rate(spring_ai_chat_errors_total[5m]) / rate(spring_ai_chat_requests_total[5m]) > 0.05
        for: 5m
        annotations:
          summary: "LLM 调用错误率超过 5%"

八、从 Spring AI 1.x 迁移到 2.0：关键变更

8.1 包结构变动

8.2 配置变化

# 1.x
spring.ai.openai.api-key: sk-xxx

# 2.0 (保持不变，但增加了更多细粒度控制)
spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-5-mini
          temperature: 0.7
          max-tokens: 4096

8.3 代码迁移

// 1.x: 需要自己处理流式
ChatClient client = new ChatClient(model);
String response = client.generate("Hello");

// 2.0: Fluent API
ChatClient client = ChatClient.builder(model).build();
String response = client.prompt("Hello").call().content();

// 流式
Flux<String> stream = client.prompt("Hello").stream().content();

8.4 主要废弃内容

• AiClient 接口 → 用 ChatClient
• ChatCompletionRequest 直接构造 → 用 Fluent API
• 函数硬编码在 ChatOptions 中 → 用 @Tool / ToolCallback
• 无拦截器 → 用 Advisors

九、实战：构建一个「智能工单助手」

9.1 项目结构

src/main/java/com/example/ticketbot/
├── config/
│   └── AiConfig.java           # ChatClient 配置
├── tool/
│   ├── TicketQueryTool.java    # @Tool 查询工单
│   └── CustomerLookupTool.java # @Tool 查询客户
├── advisor/
│   ├── AuditLogAdvisor.java    # 审计日志
│   └── KnowledgeBaseAdvisor.java # RAG
├── service/
│   └── TicketBotService.java   # 业务逻辑
└── TicketBotApplication.java

9.2 核心代码

// AiConfig.java
@Configuration
public class AiConfig {

    @Bean
    ChatClient.Builder chatClientBuilder(
            ChatModel chatModel,
            VectorStore vectorStore,
            List<ToolCallback> tools) {
        return ChatClient.builder(chatModel)
            .defaultSystem("""
                你是一个工单系统AI助手。你的职责是：
                1. 根据用户描述理解问题
                2. 查询相关工单和知识库
                3. 提供准确的解决方案
                - 如果涉及敏感信息(密码、API Key)请勿输出
                - 如果没有把握，请说"需要人工介入"
                """)
            .defaultTools(tools.toArray(new ToolCallback[0]))
            .defaultAdvisors(
                new SimpleLoggerAdvisor(),
                new QuestionAnswerAdvisor(vectorStore, SearchRequest.defaults()
                    .withTopK(3)
                    .withSimilarityThreshold(0.7))
            );
    }
}

// TicketQueryTool.java
@Component
public class TicketQueryTool {

    @Tool(name = "query_ticket", description = "根据工单号或关键词查询工单状态和解决方案")
    public String queryTicket(
            @ToolParam(description = "工单号，如 TCK-2026-001") String ticketId) {
        // 模拟查询
        return """
            工单号: %s
            状态: 已解决
            创建时间: 2026-07-15 10:30
            问题描述: 订单支付后状态未更新
            解决方案: 刷新订单状态缓存后恢复正常
            处理人: 张三
            """.formatted(ticketId);
    }
}

// TicketBotService.java
@Service
public class TicketBotService {
    
    private final ChatClient chatClient;

    public TicketBotService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    public String ask(String question, String userId) {
        return chatClient.prompt()
            .user(question)
            .advisors(a -> a.param("userId", userId))
            .call()
            .content();
    }
}

9.3 测试

curl -X POST http://localhost:8080/api/ask \
  -H "Content-Type: application/json" \
  -d '{"question": "我的工单 TCK-2026-001 还没解决，能帮我看看吗？", "userId": "user-001"}'

# 响应
{
  "answer": "我查询了工单 TCK-2026-001，状态是"已解决"。创建时间是 7月15日 10:30，问题是订单支付后状态未更新。解决方案是刷新订单状态缓存后恢复正常。如果问题仍然存在，建议刷新应用缓存或联系处理人张三进一步排查。",
  "sources": [
    {"title": "工单系统", "content": "TCK-2026-001 工单详情"},
    {"title": "知识库", "content": "支付状态缓存刷新最佳实践"}
  ],
  "tokens": {
    "prompt": 1250,
    "completion": 180,
    "total": 1430
  }
}

9.4 效果数据

在生产环境（Java 21 + Spring Boot 4.0 + PostgreSQL pgvector）实测：

十、Spring AI 2.0 vs 竞品框架对比

Spring AI 最大的优势在于 生态整合——如果你已经在用 Spring Boot，引入 Spring AI 就是加一个 starter 的事。自动配置、指标埋点、声明式事务，全都不用操心。

十一、总结与展望

Spring AI 2.0 GA 标志着 Java 生态的 AI 集成正式进入「工程化」阶段：

1. ChatClient Fluent API 让 LLM 调用像调 REST 接口一样自然
2. Advisors 可组合架构 把 prompt 工程变成了可复用的拦截器链
3. @Tool 声明式注册 让工具调用脱离了模型配置的绑定
4. MCP 协议支持 打开了工具生态的无限可能
5. Micrometer 原生集成 让 AI 调用不再是运维黑盒

接下来值得关注的方向：

• AI Agent 编排：Spring AI 2.x 正在实验 Agent 执行器，支持多步推理和工具链组合
• 多模态支持：图像理解、音频输入正在路上
• 更智能的 RAG：Agentic RAG（自适应检索策略）是实验性功能

对于 Java 开发者来说，现在是最好的上车时机。Spring AI 2.0 把门槛降到了最低——不需要懂 LLM 底层原理，不需要手拼 JSON Schema，只需要写你熟悉的 Spring 代码。

参考资源

• Spring AI 官方文档
• Spring AI GitHub
• Spring Initializr (创建项目时勾选 Spring AI)
• MCP 协议规范