---

Spring AI 框架简介：拥抱AI时代的Java开发

引言：AI浪潮下的Java何去何从？

当前，人工智能（AI）技术正以前所未有的速度发展，深刻地改变着各行各业。从智能客服到代码生成，从数据分析到内容创作，AI模型的强大能力正在被广泛应用。作为企业级应用开发的主流语言，Java凭借其成熟的生态、强大的性能和广泛的应用场景，始终在技术领域占据重要地位。然而，面对AI的浪潮，许多Java开发者和企业不禁思考：如何在现有的Java应用中有效集成AI能力？如何利用AI提升业务价值？

直接调用各类AI模型的API固然可行，但这带来了诸多挑战：

1. 多样化的API接口： 不同的AI模型提供商（如OpenAI, Azure OpenAI, Google AI, Hugging Face, Stability AI等）拥有各自独立的API接口和数据格式，集成多个模型意味着需要学习和适配多套SDK。
2. 复杂的生命周期管理： API密钥的管理、调用频率限制、错误处理、异步调用等都需要开发者自行处理，增加了集成复杂度。
3. 模型切换成本高： 如果需要从一个模型切换到另一个（出于成本、性能或功能考虑），可能需要重写大部分集成代码。
4. 缺乏统一的抽象： 对于文本生成、 embeddings生成、图像生成等不同的AI任务，缺乏一套统一的抽象接口，导致代码结构分散。
5. 与现有Spring生态的割裂： 如何将AI能力无缝融入Spring Boot的依赖注入、配置管理、可观测性等体系中，是实际开发中需要解决的问题。
6. 新兴技术集成： 诸如向量数据库（Vector Databases）、检索增强生成（RAG – Retrieval Augmented Generation）、函数调用（Function Calling）等AI领域的新兴且重要的技术，也需要简洁高效的集成方式。

正是为了解决这些痛点，Spring AI 框架应运而生。它旨在将复杂的AI模型集成工作变得更加Spring化，让Java开发者能够以熟悉的方式，更便捷、更高效地拥抱AI时代。

什么是Spring AI？

Spring AI 是一个开源项目，它提供了一套抽象和工具，旨在简化将AI模型集成到基于Spring的Java应用程序中的过程。它的核心理念是将不同供应商的AI模型（如大型语言模型 LLMs、文本嵌入模型 Text Embedding Models、文本转图像模型 Text-to-Image Models 等）通过一套统一的、易于使用的接口进行封装。

简单来说，Spring AI 的目标是成为Java应用与AI模型之间的”翻译官”和”连接器”，让开发者可以专注于业务逻辑，而不是底层的AI API细节。

Spring AI 的核心优势

1. 统一的API抽象： Spring AI 为不同类型的AI任务定义了统一的Java接口，例如 ChatClient 用于文本对话，EmbeddingClient 用于生成文本嵌入。这意味着无论底层使用的是OpenAI、Azure、Google还是Hugging Face模型，开发者调用的都是同一套Spring AI接口。
2. 供应商多样性与可切换性： Spring AI 提供了对多种AI模型供应商的内置支持，包括但不限于：
   • OpenAI
   • Microsoft Azure OpenAI
   • Google AI (Gemini)
   • Hugging Face
   • Amazon Bedrock (Claude, Llama, Titan等)
   • Stability AI (文本转图像)
   • Ollama (本地运行模型)
   • …以及更多。
     通过简单的配置更改，就可以在不同供应商或同一供应商的不同模型之间进行切换，极大地降低了供应商锁定的风险。
3. 与Spring生态的深度集成： Spring AI 天然与Spring Boot、Spring Framework等生态系统无缝集成。你可以利用Spring Boot的自动配置、依赖注入、属性配置等特性来管理和使用AI组件。这使得将AI能力添加到现有的Spring应用中变得非常自然。
4. 简化Prompt Engineering： 提供灵活的方式来构建和管理Prompt（给AI模型的指令），包括使用模板、变量等，使得Prompt Engineering更加结构化和易于维护。
5. 内置常见AI应用模式支持： Spring AI 提供对一些核心AI应用模式的抽象和支持，如：
   • 检索增强生成 (RAG): 与向量数据库集成，通过外部知识库增强LLM的回答能力。
   • 函数调用 (Function Calling): 允许LLM调用外部Java函数来获取信息或执行操作。
   • 结构化输出解析： 帮助开发者轻松地将AI模型的非结构化文本输出解析成Java对象。
6. 易于测试和维护： 统一的接口和与SpringTest的结合，使得针对AI功能的单元测试和集成测试更加方便。

Spring AI 的核心概念与组件

理解Spring AI，需要掌握其几个核心概念：

1. AI Client 抽象:

   • ChatClient: 这是最常用的接口，用于进行文本对话或基于文本的生成任务。你可以发送一个或多个 Prompt，接收AI模型的 ChatResponse。
   • EmbeddingClient: 用于将文本转换为数值向量（ embeddings）。这些向量可以用于文本相似度搜索、聚类等任务，是构建RAG等应用的基础。
   • ImageClient: 用于根据文本Prompt生成图像（例如集成Stability AI的API）。
   • GenAIClient (Experimental): 一个更通用的接口，旨在覆盖更广泛的生成式AI任务。

2. Prompt:

   • Prompt: 表示发送给AI模型的指令或输入。它可以包含一个或多个 Message。
   • Message: 表示对话中的一条消息，可以是用户的输入 (UserMessage)、系统的指令 (SystemMessage)，或者AI模型的回复 (AssistantMessage)。通过传递一个 Message 列表，可以实现多轮对话。
   • PromptTemplate: 提供一种基于模板的方式来构建Prompt，可以在运行时填充变量，非常适合动态生成指令。

3. Response:

   • ChatResponse: ChatClient 返回的结果，包含一个或多个 Generation。
   • Generation: 表示AI模型生成的一次回复。它包含生成的文本内容 (text) 以及一些元数据 (generationMetadata)，如模型ID、使用token数等。
   • EmbeddingResponse: EmbeddingClient 返回的结果，包含文本对应的数值向量列表。
   • ImageResponse: ImageClient 返回的结果，包含生成的图像URL或base64编码。

4. Model Connectors (实现):

   • Spring AI 提供了针对各个AI供应商的 ChatClient、EmbeddingClient 等接口的具体实现。例如，OpenAiChatClient、AzureOpenAiChatClient、GoogleGeminiChatClient、HuggingfaceChatClient 等。
   • 通过在 application.properties 或 application.yml 中配置相应的属性（如 spring.ai.openai.api-key），Spring Boot的自动配置会实例化相应的Client实现，并将其注册为Spring Bean，供你的应用注入使用。

5. Output Parsing:

   • Spring AI 提供工具来帮助你将AI模型的文本输出（通常是JSON格式的字符串）自动解析成Java对象。这通过在 PromptTemplate 中包含指导模型输出特定格式的指令，并在接收到响应后使用相应的解析器实现。

6. Data Integration (Vector Databases):

   • Spring AI 不直接是向量数据库，但它提供了与多种向量数据库（如Pinecone, Weaviate, Chroma, PGVector, Redis Stack, Milvus, Azure AI Search, Qdrant等）集成的抽象和支持。
   • VectorStore: Spring AI 定义的向量存储抽象接口，用于存储和检索文本及其对应的 embeddings。这是实现RAG的关键组件。
   • 通过 VectorStore，你可以方便地将文档分块、生成 embeddings 并存储，然后在需要时根据用户查询检索最相关的文档块，并将这些文档块添加到发送给LLM的Prompt中。

快速上手：第一个Spring AI 应用

让我们通过一个简单的Spring Boot应用来展示如何使用Spring AI。

假设我们使用OpenAI作为AI模型提供商。

步骤 1: 创建Spring Boot项目

使用Spring Initializr (start.spring.io) 创建一个Spring Boot项目。
* Project Type: Maven or Gradle
* Language: Java
* Spring Boot Version: 选择一个当前稳定的版本
* Dependencies: Spring Web (用于构建简单的REST接口演示), Lombok (可选, 用于简化代码)

步骤 2: 添加Spring AI 依赖

编辑 pom.xml (Maven) 或 build.gradle (Gradle) 文件，添加Spring AI Starter 和 OpenAI Connector 的依赖。

• Maven (pom.xml):

  “`xml
  
  org.springframework.ai
  spring-ai-openai-spring-boot-starter
  0.8.1
  

  
  
  org.springframework.boot
  spring-boot-starter-web
  
  “`

  注意: 你还需要在 <properties> 中添加 Spring AI 的版本管理：

  “`xml 17
  0.8.1

  
  
  
  org.springframework.ai
  spring-ai-bom
  ${spring-ai.version}
  pom
  import
  
  
  
  “`

• Gradle (build.gradle):

  “`gradle
  dependencies {
  implementation ‘org.springframework.ai:spring-ai-openai-spring-boot-starter’
  implementation ‘org.springframework.boot:spring-boot-starter-web’ // 如果步骤1未添加
  compileOnly ‘org.projectlombok:lombok’ // 如果使用Lombok
  annotationProcessor ‘org.projectlombok:lombok’ // 如果使用Lombok
  }

  dependencyManagement {
  imports {
  // 替换为当前最新的Spring AI版本
  mavenBom “org.springframework.ai:spring-ai-bom:0.8.1”
  }
  }
  “`

步骤 3: 配置API Key

在 src/main/resources/application.properties 或 application.yml 中配置你的OpenAI API Key。

• application.properties:

  “`properties
  spring.ai.openai.api-key=YOUR_OPENAI_API_KEY

  可选：配置使用的模型

  spring.ai.openai.chat.options.model=gpt-4o-mini

  “`

• application.yml:

  yaml
spring:
ai:
openai:
api-key: YOUR_OPENAI_API_KEY
chat:
options:
model: gpt-4o-mini # 可选：配置使用的模型
  重要提示: 永远不要将你的API Key直接提交到版本控制系统！在生产环境中，建议使用环境变量或其他安全的配置管理方式。

步骤 4: 创建一个使用ChatClient的Service

创建一个简单的Spring Service，注入 ChatClient 并使用它来生成文本。

“`java
package com.example.aiapp.service;

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.Generation;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AIService {

private final ChatClient chatClient;

@Autowired
public AIService(ChatClient chatClient) {
    this.chatClient = chatClient;
}

public String generateResponse(String message) {
    // 构建Prompt，直接发送用户消息
    Prompt prompt = new Prompt(message);

    // 调用ChatClient发送请求
    ChatResponse response = chatClient.call(prompt);

    // 获取生成的文本内容
    if (response != null && !response.getResults().isEmpty()) {
        Generation generation = response.getResults().get(0);
        return generation.getOutput().getContent();
    }
    return "Failed to get response from AI.";
}

public String generateResponseWithTemplate(String topic) {
    // 使用PromptTemplate构建更灵活的Prompt
    String template = "请用中文写一篇关于'{topic}'的简短介绍，大约100字。";
    PromptTemplate promptTemplate = new PromptTemplate(template);
    Prompt prompt = promptTemplate.create(java.util.Map.of("topic", topic));

    ChatResponse response = chatClient.call(prompt);

    if (response != null && !response.getResults().isEmpty()) {
        Generation generation = response.getResults().get(0);
        return generation.getOutput().getContent();
    }
    return "Failed to get response from AI.";
}

}
“`

步骤 5: 创建一个REST Controller来调用Service

“`java
package com.example.aiapp.controller;

import com.example.aiapp.service.AIService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AIController {

private final AIService aiService;

@Autowired
public AIController(AIService aiService) {
    this.aiService = aiService;
}

@GetMapping("/generate")
public String generateText(@RequestParam(value = "message", defaultValue = "你好，AI！") String message) {
    return aiService.generateResponse(message);
}

@GetMapping("/introduce")
public String introduceTopic(@RequestParam(value = "topic", defaultValue = "Spring AI") String topic) {
    return aiService.generateResponseWithTemplate(topic);
}

}
“`

步骤 6: 运行应用并测试

运行你的Spring Boot主应用类。应用启动后，打开浏览器或使用curl等工具访问以下URL进行测试：

• http://localhost:8080/generate?message=用中文介绍一下Spring Framework
• http://localhost:8080/introduce?topic=人工智能

你应该会收到AI模型生成的中文回复。

这个简单的例子展示了Spring AI如何通过 ChatClient 抽象隐藏底层API细节，让你能够以Spring Style的方式调用AI模型。

深入Spring AI 的更多功能

上面的例子只是冰山一角，Spring AI 支持许多更高级的功能和模式。

1. 使用 EmbeddingClient 进行文本嵌入

Embedding是将文本转换为数值向量的过程，这些向量捕捉了文本的语义信息。相似的文本会有相似的向量。这在信息检索、相似度搜索、聚类等场景中非常有用。

Spring AI 提供了 EmbeddingClient 接口：

“`java
import org.springframework.ai.embedding.EmbeddingClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class EmbeddingService {

private final EmbeddingClient embeddingClient;

@Autowired
public EmbeddingService(EmbeddingClient embeddingClient) {
    this.embeddingClient = embeddingClient;
}

public List<Double> getEmbedding(String text) {
    // 调用EmbeddingClient生成文本的嵌入向量
    return embeddingClient.embed(text);
}

public List<List<Double>> getEmbeddings(List<String> texts) {
    // 调用EmbeddingClient生成多个文本的嵌入向量
    return embeddingClient.embed(texts);
}

}
“`

使用时，同样需要在配置文件中指定使用的Embedding模型提供商和模型（例如，OpenAI 的 text-embedding-ada-002 或 text-embedding-3-small）。

“`properties
spring.ai.openai.embedding.enabled=true

spring.ai.openai.embedding.options.model=text-embedding-3-small

“`

2. 集成向量数据库与 RAG

RAG（Retrieval Augmented Generation）是一种提高大型语言模型回答准确性和时效性的技术。它通过检索外部知识库（通常存储在向量数据库中）中与用户查询最相关的文档，然后将这些文档作为上下文信息添加到发送给LLM的Prompt中，从而使LLM能够基于这些具体的、最新的信息进行回答。

Spring AI 提供了 VectorStore 抽象，并为多种向量数据库提供了实现。集成步骤大致如下：

a. 添加向量数据库依赖： 添加你选择的向量数据库的Spring AI Connector依赖。例如，使用PGVector（PostgreSQL的向量扩展）：
xml
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId>
<version>${spring-ai.version}</version>
</dependency>
以及相关的数据库连接依赖（如 spring-boot-starter-data-jpa 或 spring-boot-starter-jdbc 和 PostgreSQL 驱动）。

b. 配置向量数据库连接： 在 application.properties 中配置数据库连接信息和向量库相关的属性。

c. 索引文档： 使用 VectorStore 接口的 add(List<Document>) 方法将你的文档（Document 对象包含文本内容和元数据）分块并存储到向量数据库中。这个过程会调用 EmbeddingClient 生成每个文档块的 embedding，然后将文本和 embedding 一起存入向量库。

```java
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class IndexingService {

    private final VectorStore vectorStore;

    @Autowired
    public IndexingService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    public void indexDocuments(List<Document> documents) {
        // 将文档添加到向量库，该过程会自动生成embeddings
        vectorStore.add(documents);
    }
}
```

d. 执行RAG查询： 当用户提出问题时，使用 VectorStore 的 similaritySearch(String query) 方法根据用户查询找到最相关的文档块。然后，将用户查询和检索到的文档块内容一起构建成一个新的Prompt发送给 ChatClient。

```java
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.SearchRequest; // 推荐使用SearchRequest
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class RAGService {

    private final ChatClient chatClient;
    private final VectorStore vectorStore;

    @Autowired
    public RAGService(ChatClient chatClient, VectorStore vectorStore) {
        this.chatClient = chatClient;
        this.vectorStore = vectorStore;
    }

    public String askQuestion(String question) {
        // 1. 根据用户问题进行相似度搜索，检索相关文档
        // SearchRequest允许设置返回文档数量等选项
        List<Document> relevantDocuments = vectorStore.similaritySearch(SearchRequest.query(question).withTopK(5));

        // 2. 将检索到的文档内容整合成一个字符串作为上下文
        String context = relevantDocuments.stream()
                .map(Document::getContent)
                .collect(Collectors.joining("\n\n"));

        // 3. 构建包含上下文和用户问题的Prompt
        String promptTemplate = """
                你是一个问答助手，请根据提供的上下文回答问题。
                如果上下文没有包含足够的信息，请说明你不知道答案。
                上下文：
                {context}
                问题：{question}
                回答：
                """;
        PromptTemplate ragPromptTemplate = new PromptTemplate(promptTemplate);
        org.springframework.ai.chat.prompt.Prompt prompt = ragPromptTemplate.create(Map.of("context", context, "question", question));

        // 4. 将Prompt发送给ChatClient并获取回复
        return chatClient.call(prompt).getResult().getOutput().getContent();
    }
}
```
通过RAG，你可以让AI模型利用你的私有数据、实时数据或领域特定知识进行回答，极大地提升了AI应用的实用性。

3. 函数调用 (Function Calling)

函数调用允许LLM与外部工具或系统交互。例如，LLM可以调用一个函数来获取实时天气信息，执行一个数据库查询，或者触发一个业务流程。

Spring AI 对 Function Calling 提供了抽象支持。你需要定义一个Java方法，并使用Spring AI提供的注解或配置将其注册为AI可调用的函数。AI模型在生成回复时，如果判断需要外部信息来回答用户问题，它可以“调用”这个函数，将函数名和参数返回给你的应用。你的应用负责执行这个Java方法，并将结果返回给AI模型，AI模型再利用这个结果生成最终回复。

“`java
import org.springframework.ai.model.function.FunctionCallback;
import org.springframework.ai.model.function.FunctionCallbackContext;
import org.springframework.ai.model.function.FunctionCallingOptions;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import java.util.function.Function;

@Configuration
public class FunctionConfig {

// 假设这是一个获取天气信息的函数
@Bean
public Function<String, String> weatherFunction() {
    return location -> {
        // 模拟调用外部天气服务
        System.out.println("Calling weather service for location: " + location);
        if ("北京".equals(location)) {
            return "{\"location\":\"北京\",\"temperature\":\"25C\",\"description\":\"晴\"}";
        } else if ("上海".equals(location)) {
            return "{\"location\":\"上海\",\"temperature\":\"28C\",\"description\":\"多云\"}";
        } else {
            return "{\"error\":\"未知地点\"}";
        }
    };
}

}
“`

在使用 ChatClient 时，你需要启用函数调用选项并传入函数上下文：

“`java
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.model.function.FunctionCallbackContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Map;

@Service
public class FunctionCallingService {

private final ChatClient chatClient;
private final FunctionCallbackContext functionCallbackContext; // 注入函数上下文

@Autowired
public FunctionCallingService(ChatClient chatClient, FunctionCallbackContext functionCallbackContext) {
    this.chatClient = chatClient;
    this.functionCallbackContext = functionCallbackContext;
}

public String askQuestionWithFunction(String question) {
    // 构建Prompt
    String promptText = question + " 请在回答中包含实时天气信息。"; // 提示AI需要天气信息

    PromptTemplate promptTemplate = new PromptTemplate(promptText);
    Prompt prompt = promptTemplate.create();

    // 调用ChatClient，传入函数上下文，AI模型会根据prompt决定是否调用函数
    return chatClient.call(prompt, functionCallbackContext).getResult().getOutput().getContent();
}

}
``
当用户问“北京天气怎么样？”时，LLM会识别出需要调用weatherFunction并提供参数“北京”。你的应用执行weatherFunction` 获取天气数据，然后将数据返回给LLM，LLM再生成“北京的天气是晴，温度25C”这样的回答。

4. 结构化输出解析 (Output Parsing)

AI模型通常返回自由格式的文本。但在很多场景下，我们需要结构化的数据，例如将人物信息解析为Person对象，或者将一段文本总结为带有特定属性的JSON对象。Spring AI 提供了 OutputParser 抽象来简化这个过程。

你可以在Prompt中明确指示AI模型按照某种格式（如JSON）输出，然后使用 BeanOutputParser 将JSON字符串解析成对应的Java Bean。

“`java
import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.output.BeanOutputParser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Map;

@Service
public class OutputParsingService {

private final ChatClient chatClient;

@Autowired
public OutputParsingService(ChatClient chatClient) {
    this.chatClient = chatClient;
}

// 定义一个Java Bean用于接收解析结果
public static class Person {
    @JsonPropertyDescription("人物的完整名称")
    public String name;
    @JsonPropertyDescription("人物的年龄")
    public int age;
    @JsonPropertyDescription("人物的职业")
    public String occupation;
}

public Person extractPersonInfo(String text) {
    // 创建BeanOutputParser，指定要解析的目标Bean类型
    BeanOutputParser<Person> parser = new BeanOutputParser<>(Person.class);

    // 构建PromptTemplate，包含对模型输出格式的严格要求
    // getFormat() 方法会根据Person Bean的结构生成JSON Schema或其他格式指令
    String promptText = """
            从下面的文本中提取人物信息，并按照指定的JSON格式输出：
            {format}

            文本: {text}
            """;
    PromptTemplate promptTemplate = new PromptTemplate(promptText,
            Map.of("text", text, "format", parser.getFormat())); // 将格式指令加入Prompt

    // 调用ChatClient
    Prompt prompt = promptTemplate.create();
    String result = chatClient.call(prompt).getResult().getOutput().getContent();

    // 使用parser解析AI模型的输出
    return parser.parse(result);
}

}
“`

通过 BeanOutputParser，Spring AI 自动化了提示AI按照特定格式输出以及解析输出的过程，让获取结构化数据变得简单。

5. 多模型供应商支持

切换不同的AI模型供应商在Spring AI中非常简单，通常只需要修改配置文件。例如，从OpenAI切换到Google Gemini：

1. 添加Google Gemini Starter依赖：
   xml
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-google-vertexai-spring-boot-starter</artifactId> <!-- 或者 google-vertexai-spring-boot-starter -->
<version>${spring-ai.version}</version>
</dependency>
   或Hugging Face：
   xml
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-huggingface-spring-boot-starter</artifactId>
<version>${spring-ai.version}</version>
</dependency>

2. 配置新的API Key和启用对应的服务：
   “`properties
   # 禁用OpenAI
   spring.ai.openai.enabled=false

   启用Google Vertex AI或Google AI

   spring.ai.google.vertexai.enabled=true
   spring.ai.google.vertexai.project-id=YOUR_PROJECT_ID
   spring.ai.google.vertexai.location=YOUR_LOCATION

   spring.ai.google.vertexai.chat.options.model=gemini-1.5-flash-preview-0514

   spring.ai.google.vertexai.embedding.options.model=textembedding-gecko@003

   或者Hugging Face：properties

   禁用OpenAI

   spring.ai.openai.enabled=false

   启用Hugging Face

   spring.ai.huggingface.enabled=true
   spring.ai.huggingface.api-key=YOUR_HF_API_KEY

   spring.ai.huggingface.chat.options.model=mistralai/Mistral-7B-Instruct-v0.2

   spring.ai.huggingface.embedding.options.model=sentence-transformers/all-mpnet-base-v2

   “`

Spring Boot的自动配置会根据 enabled 标志和依赖情况，自动实例化并注册相应的 ChatClient 和 EmbeddingClient Bean，你的业务代码无需修改，依然调用统一的Spring AI接口。

总结与展望

Spring AI 框架为Java开发者提供了一条拥抱AI时代的便捷之路。它通过统一的API抽象、丰富的供应商支持、与Spring生态的深度融合以及对常见AI应用模式的内置支持，极大地降低了在Java应用中集成AI模型的门槛和复杂度。

无论你是想为现有应用增加智能问答、内容生成、数据分析能力，还是构建全新的AI驱动服务，Spring AI都能助你一臂之力。它让你能够专注于实现富有创意的AI应用逻辑，而不是耗费精力处理底层API的差异和基础设施问题。

Spring AI 项目目前正处于快速发展阶段，不断有新的功能和供应商被加入。作为Java社区的一部分，积极参与其中，学习并应用Spring AI，将使你在日益重要的AI应用开发领域保持竞争力。

AI的浪潮已经到来，Java开发者不必成为旁观者。借助Spring AI，你可以以熟悉的方式，轻松地将AI的强大能力融入到你的下一个项目中，开启Java开发的智能新篇章！

---