SpringAI+Deepseek大模型应用实战

Spring AI是一个AI工程领域的应用程序框架；
Spring AI 是 AI 工程的应用框架。其目标是将 Spring 生态系统设计原则（如可移植性和模块化设计）应用于 AI 领域，并促进使用 POJO 作为应用程序的构建块到 AI 领域。
它的目标是将Spring生态系统的设计原则应用于 AI 领域，比如Spring生态系统的可移植性和模块化设计，并促进使用 POJO 作为应用程序的构建块到 AI 领域；
Spring AI 的核心是提供了开发 AI 大模型应用所需的基本抽象模型，这些抽象拥有多种实现方式，使得开发者可以用很少的代码改动就能实现组件的轻松替换；
简言之，Spring AI 是一个 AI 工程师的应用框架，它提供了一个友好的 API 和开发 AI 应用的抽象，旨在简化 AI 大模型应用的开发工作。

官网地址https://spring.io/projects/spring-ai

2、SpringAi主要功能

对主流 AI 大模型供应商提供了支持，比如：OpenAI、DeepSeek、Microsoft、Ollama、Amazon、Google HuggingFace等。
支持AI大模型类型包括：聊天、文本到图像、文本到声音等。
支持主流的Embedding Models（嵌入模型）和向量数据库，比如：Azure Vector Search、Chroma、Milvus、Neo4j、Redis、PineCone、PostgreSQL/PGVector 等。
把 AI 大模型输出映射到简单的 Java 对象（POJOs）上。
支持了函数调用（Function calling）功能。
为数据工程提供 ETL（数据抽取、转换和加载）框架。
支持 Spring Boot 自动配置和快速启动，便于运行 AI 模型和管理向量库。

3、DeepSeek介绍

DeepSeek 是一款由深度求索所开发的 AI 人工智能大模型，其基于深度学习和多模态数据融合技术，采用先进的 Transformer 架构和跨模态协同算法，可实现对复杂文档和图像的自动化解析与结构化信息提取。

依托于最新推出的"深度思考"模式（R1），这款AI大模型在极低成本下实现了与国际顶尖模型ChatGPT-o1相媲美的性能表现，其中文理解与输出能力更是远超ChatGPT、Claude等顶尖模型。再加上极具竞争力的API定价和全面开源的策略，让这款AI大模型成功在国际上火爆出圈

如果说AI是一个广泛的概念，那么DeepSeek就是是AI领域中的一个具体产品。

DeepSeek的特点‌：

‌成本‌：DeepSeek致力于降低AI应用的成本。通过采用先进的技术和独特的模型架构，DeepSeek在保持高性能的同时，显著降低了推理和训练的成本。
‌性能‌：DeepSeek在性能上表现出色。它使用强化学习技术训练，推理过程中包含大量反思与验证，能够处理更加复杂的数据和任务。在一些benchmark测试中，其性能与OpenAI的模型相当，但推理成本远低于同类产品。
‌功能‌：DeepSeek擅长处理数学、编程和复杂逻辑推理等任务。它的推理能力源于深度思考特性，推理长度与准确率呈正相关。此外，DeepSeek还支持多模态信息处理，能够应对更加多样化的应用场景。
‌应用领域‌：DeepSeek在多个领域展现出巨大的应用潜力。无论是在医疗、教育、交通等传统领域，还是在智能制造、智慧城市等新兴领域，DeepSeek都有望发挥重要作用。

4、获取DeepSeek的API KEY

访问官网地址，选择api开发平台

官网地址https://www.deepseek.com/

进入API开放平台，注册用户

创建API key，创建后记住保存密钥

充值，充值前可能需要身份认证，根据提示填写信息即可

5、整合SpringBoot

（1）创建父工程springAiProject

pom文件

XML 复制代码

    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.8</version>
        <relativePath/>
    </parent>

    <groupId>com.hk</groupId>
    <artifactId>springAiProject</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>springai_hello</module>
    </modules>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

（2）创建子工程springaihello

pom文件

XML 复制代码

<modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hk</groupId>
        <artifactId>springAiProject</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>springai_hello</artifactId>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <spring-ai.version>1.0.0-M5</spring-ai.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <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>

配置文件

XML 复制代码

server.port=8899
spring.application.name=spring-ai-deepseek-demo

# deepseek的密钥
spring.ai.openai.api-key=sk-4af4f********
# 访问deepseek的固定地址
spring.ai.openai.base-url=https://api.deepseek.com
# 模型类型
spring.ai.openai.chat.options.model=deepseek-chat
spring.ai.openai.chat.options.temperature=0.7

temperature参数用于控制生成文本的多样性。具体来说：

‌值越高‌，生成的文本越多样化，但也可能包含更多的随机性和不可预测的内容。 ‌值越低‌，生成的文本越接近于确定性的结果，即生成的文本会更加一致和可预测。

创建启动类

java 复制代码

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

创建controller

java 复制代码

@RestController
public class DeepSeekController {

    @Autowired
    private OpenAiChatModel chatModel;

    @GetMapping("/ai/generate")
    public String generate(@RequestParam(value = "message", defaultValue = "hello") String message) {
        String call = chatModel.call(message);
        System.out.println(call);
        return call;
    }
}

（3）测试

6、SpringAi的聊天模型

Spring AI的聊天模型API为开发者提供了一条便捷通道，借助预先训练的语言模型，如广为人知的GPT，它能够依据用户输入生成自然流畅、类人化的回复。这一API不仅工作机制高效，而且设计理念极为先进，旨在实现简单易用与高度可移植性，让开发者能以极少的代码改动在不同AI模型间自由切换，充分契合Spring框架一贯秉持的模块化与可互换性原则。

（1）ChatClient接口

ChatClient接口，它定义了一个与聊天服务交互的客户端。这个接口主要用于创建聊天客户端对象，设置请求规范，以及发起聊天请求。

1）实现简单的对话

用户输入消息的内容，通过SpringBoot AI封装的方法向 AI 模型发送请求，以字符串形式返回 AI 模型的响应。

ChatClient 接口提供了构建和配置聊天客户端对象的灵活性，以及发起和处理聊天请求的能力。用户可以通过 ChatClient.Builder 来定制客户端的行为，然后使用 prompt() 和 prompt(Prompt prompt) 方法设置请求规范，最后通过 call() 方法发起聊天请求。

java 复制代码

@RestController
public class ChatDeepSeekController {

    // 使用构造函数注入
    private final ChatClient client;

    public ChatDeepSeekController(ChatClient.Builder chatClientBuilder) {
        this.client = chatClientBuilder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam(value = "message", defaultValue = "给我讲个笑话") String message) {
       return client.prompt()
               //用户输入的信息
               .user(message)
               //请求大模型
               .call()
               //返回文本
               .content();
    }
}

2）实现角色预设

就是设置你是一个什么样的角色，根据这个角色来回答问题

这是未设置角色的表现

设置默认角色配置类

java 复制代码

@Configuration
public class AIConfig {

    @Bean
    public ChatClient chatClient(ChatClient.Builder builder) {
        return builder.defaultSystem("你是域见新零售的一名客服，你知道域见新零售平台的全部流程").build();
    }
}

2.编写controller

java 复制代码

@RestController
public class AIController {

    @Autowired
    private ChatClient chatClient;

    @GetMapping("/aiChat")
    public String aiChat(@RequestParam(value = "message") String msg) {
        return chatClient.prompt().user(msg).call().content();
    }
}

3.测试结果

3）实现流式响应

普通输出 call：等待大模型把回答结果全部生成后输出给用户；
流式输出stream：逐个字符输出，一方面符合大模型生成方式的本质，另一方面当模型推理效率不是很高时，流式输出比起全部生成后再输出大大提高用户体验。

编写controller

java 复制代码

@RestController
public class AIController {

    @Autowired
    private ChatClient chatClient;

    @GetMapping("/aiChat")
    public String aiChat(@RequestParam(value = "message") String msg) {
        return chatClient.prompt().user(msg).call().content();
    }

    @GetMapping(value = "/aiChatStream", produces = "text/html;charset=utf-8")
    public Flux<String> aiChatStream(@RequestParam(value = "message") String msg) {
        return chatClient.prompt().user(msg).stream().content();
    }
}

（2）ChatModel接口

ChatModel接口作为核心，定义了与AI模型交互的基本方法。它继承自Model<Prompt, ChatResponse>，提供了两个重载的call方法：

java 复制代码

public interface ChatModel extends Model<Prompt, ChatResponse> {
    default String call(String message) {...}
    @Override
    ChatResponse call(Prompt prompt);
}

在ChatModel接口中，带有String参数的call()方法简化了实际的使用，避免了更复杂的Prompt和 ChatResponse类的复杂性。但是在实际应用程序中，更常见的是使用ChatResponse call()方法，该方法采用Prompt实例并返回ChatResponse。

ChatClient底层是使用ChatModel作为属性的，在初始化ChatClient的时候可以指定ChatModel

java 复制代码

//ChatClient（部分构造器代码）
static ChatClient create(ChatModel chatModel) {
    return create(chatModel, ObservationRegistry.NOOP);
}

1）简单对话

java 复制代码

@RestController
public class DeepSeekModelController {

    @Autowired
    private ChatModel chatModel;

    @GetMapping("/openai")
    public String openai(@RequestParam(value = "msg") String msg) {
        return chatModel.call(msg);
    }

    @GetMapping("/openai2")
    public String openai2(@RequestParam(value = "msg") String msg) {
        Prompt prompt = new Prompt(msg,
                OpenAiChatOptions.builder()
                        //可以更换成其他大模型，如Anthropic3ChatOptions亚马逊
                        .model("deepseek-chat")
                        .temperature(0.8)
                        .build()
        );
        ChatResponse call = chatModel.call(prompt);
        return call.getResult().getOutput().getContent();
    }
}

测试访问 http://localhost:8899/openai2?msg=你是谁

2）提示词

提示词是引导大模型生成特定输出的输入，提示词的设计和措辞会极大地影响模型的响应结果
Prompt 提示词是与模型交互的一种输入数据组织方式，本质上是一种复合结构的输入，在 prompt 我们是可以包含多组不同角色（System、User、Aissistant等）的信息。如何管理好 Prompt 是简化 AI 应用开发的关键环节。
Spring AI 提供了 Prompt Template 提示词模板管理抽象，开发者可以预先定义好模板，并在运行时替换模板中的关键词。在 Spring AI 与大模型交互的过程中，处理提示词首先要创建包含动态内容占位符 {占位符} 的模板，然后，这些占位符会根据用户请求或应用程序中的其他代码进行替换。在提示词模板中，{占位符} 可以用 Map 中的变量动态替换。

java 复制代码

    @GetMapping("/prompt")
    public String prompt(@RequestParam(value = "name") String name, @RequestParam(value = "voice") String voice){
        String userText = "推荐3种南京好吃的美食";

        UserMessage userMessage = new UserMessage(userText);

        String sysText = "你是一个美食咨询助手，可以帮助人们查询美食信息。\n" +
                "            你的名字是{name},\n" +
                "            你应该用你的名字和{voice}的饮食习惯回复用户的请求。";

        SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(sysText);
        Message message = systemPromptTemplate.createMessage(Map.of("name", name, "voice", voice));

        Prompt prompt = new Prompt(List.of(userMessage, message));
        List<Generation> results = chatModel.call(prompt).getResults();
        return results.stream().map(item -> item.getOutput().getContent()).collect(Collectors.joining(""));
    }

7、SpringAi函数调用

Spring AI 的函数调用（Function Calling）功能允许大语言模型在生成回答时触发预定义的外部函数，从而实现动态数据获取或业务逻辑操作（如查询数据库、调用 API 等）。

SpringAI 帮我们规范了函数定义、注册等过程，并在发起模型请求之前自动将函数注入到 Prompt 中，而当模型决策在合适的时候去调用某个函数时，Spring AI 完成函数调用动作，最终将函数执行结果与原始问题再一并发送给模型，模型根据新的输入决策下一步动作。这其中涉及与大模型的多次交互过程，一次函数调用就是一次完成的交互过程。

函数调用的核心流程

第一步，定义函数：声明可供模型调用的函数（名称、描述、参数结构）。
第二步，模型交互：将函数信息与用户输入一起发送给模型，模型决定是否需要调用函数。
第三步，执行函数：解析模型的函数调用请求，执行对应的业务逻辑。
第四步，返回结果：将函数执行结果返回给模型，生成最终回答。

1、创建自定义函数

java 复制代码

@Configuration
public class Calculator {

    private record AddOperation(int a, int b){

    }

    private record MulOperation(int m, int n){

    }

    @Bean
    @Description("加法运算")
    public Function<AddOperation, Integer> addOperation(){
        return request -> request.a + request.b;
    }

    @Bean
    @Description("乘法运算")
    public Function<MulOperation, Integer> mulOperation(){
        return request -> request.m * request.n;
    }

}

Spring AI 使自定义函数这个过程变得简单，只需定义一个返回 java.util.Function 的 @Bean 定义，并在调用 ChatModel 时将 bean 名称作为选项进行注册即可。在底层，Spring 会用适当的适配器代码包装自定义的函数，以便与 AI 模型进行交互，免去了编写繁琐的代码。

2、编写controller

java 复制代码

@RestController
public class CustomFunController {

    @Autowired
    private ChatModel chatModel;

    @GetMapping(value = "/caht01")
    public String ragJsonText (@RequestParam String msg){
        return ChatClient.builder(chatModel)
                .build()
                .prompt()
                .system("""
                        您是算术计算器的代理。
                        您能够支持加法运算、乘法运算等操作，其余功能将在后续版本中添加，如果用户问的问题不支持请告知详情。
                        在提供加法运算、乘法运算等操作之前，您必须从用户处获取如下信息：两个数字，运算类型。
                        请调用自定义函数执行加法运算、乘法运算。
                        请讲中文。
                        """)
                .user(msg)
                .functions("addOperation", "mulOperation")
                .call()
                .content();
    }
}

为了让模型知道并调用你的自定义函数，您需要在 Prompt 请求中启用它，如上述代码，在functions("addOperation", "mulOperation")中告知ChatClient要使用这两个自定义函数。
另外指定了System Prompt：要求AI 模型被设定为一个算术计算器代理，能够执行加法和乘法运算，并且要求用户提供两个数字和运算类型。这个提示词内容很关键，如何让AI按照自己的意图去执行，要不断测试提示词内容。

3、测试

8、Ollama调用

（1）下载并安装 Ollama

Ollama 是一个用于本地化部署和管理大型语言模型（LLM）的工具。它支持多种开源模型（如 LLaMA、Alpaca 等），并提供了简单的 API 接口，方便开发者调用。Ollama可以让你在自己的电脑上运行各种强大的 AI 模型，就像运行普通软件一样简单。

官网地址https://ollama.com/

1）点击Download

2）安装

点击执行文件安装默认安装到C盘

如果要安装到指定位置：d盘为例

cmd打开黑窗体

运行 OllamaSetup.exe /DIR=D:\mysoftware\Ollama

安装好后配置环境变量

3）拉取 DeepSeek 模型

硬件配置建议

GPU选择（根据模型大小灵活调整）： 入门配置：NVIDIA显卡（≥8GB显存） → 适合7B/8B模型。高性能配置：NVIDIA显卡（≥16GB显存） → 支持14B大模型。无独立显卡用户：可使用CPU模式运行（速度约为GPU的20%）。
内存要求：≥16GB（推荐32GB，处理长文本时不易卡顿）
存储空间：≥50GB可用空间（建议SSD硬盘，加快模型加载速度）
操作系统： Windows 10/11（21H2及以上版本）。 macOS Ventura 13.4+。 Ubuntu 22.04 LTS/24.04 LTS

点击

点击

复制命令

以windows为例，根据不同版本，执行不同的命令拉取模型

比如，下载1.5b，执行下面命令

ollama pull deepseek-r1:1.5b

过程可能会比较长

4）运行模型

启动 Ollama 服务，默认会监听 http://localhost:11434

ollama run deepseek-r1:1.5b

（2）SpringAI整合Ollama

1）创建工程springai-Ollama

2）编写pom文件

XML 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hk</groupId>
        <artifactId>springAiProject</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>springai_Ollama</artifactId>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <spring-ai.version>1.0.0-M5</spring-ai.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <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>

    <!--下载spring-ai相关包需要用到的仓库地址-->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>

</project>

3）配置文件

XML 复制代码

server.port=8899
spring.application.name=spring-ai-ollama

spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.chat.options.model=deepseek-r1:1.5b
spring.ai.ollama.chat.options.temperature=0.7

4）创建启动类

java 复制代码

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

5）编写controller

java 复制代码

@RestController
public class ChatController {

    @Autowired
    private OllamaChatModel ollamaChatModel;

    @GetMapping("/chat")
    public String generate(@RequestParam(value = "msg", defaultValue = "hello") String msg){
        return ollamaChatModel.call(msg);
    }

    @GetMapping(value = "/chats", produces = "text/html;charset=utf-8")
    public Flux<String> generates(@RequestParam(value = "msg") String msg){
        return ollamaChatModel.stream(msg);
    }

}

6）测试

9、Spring AI Alibaba

（1）介绍

随着生成式 AI 的快速发展，基于 AI 开发框架构建 AI 应用的诉求迅速增长，涌现出了包括 LangChain、LlamaIndex 等开发框架，但大部分框架只提供了 Python 语言的实现。这些开发框架对于国内习惯了 Spring 开发范式的 Java 开发者而言，并非十分友好和丝滑。因此，基于 Spring AI 发布并快速演进 Spring AI Alibaba，是阿里云通义系列模型及服务在 Java AI 应用开发领域的最佳实践，通过提供一种方便的 API 抽象，帮助 Java 开发者我们加速和简化 Java 智能体应用的开发。同时，提供了完整的开源配套，包括可观测、网关、消息队列、配置中心等。

Spring AI Alibaba 已完整提供 Model、Prompt、RAG、Tools 等 AI 应用开发所需的必备能力，将兼具提示词模板、函数调用、格式化输出等低层次抽象，以及 RAG、智能体、对话记忆等高层次抽象。

（2）申请阿里云API Key

阿里云百炼https://www.aliyun.com/product/bailian

开通"百炼大模型推理"服务，获取API Key。

点击应用模板==【密钥管理】

（3）与SpringAI整合

文档地址https://java2ai.com/docs/1.0.0-M6.1/get-started/?spm=4347728f.13ae80de.0.0.6fe5175cWxPTJZ

1）创建工程

2）修改pom文件

XML 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hk</groupId>
        <artifactId>springAiProject</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>springai_alibaba</artifactId>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-ai.version>1.0.0-M5</spring-ai.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-starter</artifactId>
            <version>1.0.0-M5.1</version>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
</project>

3）添加配置文件

XML 复制代码

server.port=8899
spring.application.name=spring-ai-alibaba

spring.ai.dashscope.api-key=sk-026f3e*****

4）创建controller

java 复制代码

@RestController
public class SaaController {
    private static final String DEFAULT_PROMPT = "你是一个博学的智能聊天助手，请根据用户提问回答！";

    private ChatClient chatClient;

    private SaaController(ChatClient.Builder builder) {
        this.chatClient = builder.defaultSystem(DEFAULT_PROMPT)
                // 实现 Chat Memory 的 Advisor
                // 在使用 Chat Memory 时，需要指定对话 ID，以便 Spring AI 处理上下文。
                .defaultAdvisors(new MessageChatMemoryAdvisor(new InMemoryChatMemory()))
                // 实现 Logger 的 Advisor
                .defaultAdvisors(new SimpleLoggerAdvisor())
                // 设置 ChatClient 中 ChatModel 的 Options 参数
                .defaultOptions(DashScopeChatOptions.builder().withTopP(0.7).build())
                .build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam String msg){
        return chatClient.prompt(msg).call().content();
    }
}

5）测试

（4）图像模型

1）介绍

在Spring AI框架中，Image Model API旨在为与专注于图像生成的各种AI模型进行交互提供一个简单且可移植的接口，使开发者能够以最小的代码改动切换不同的图像相关模型。这一设计符合Spring模块化和互换性的理念，确保开发者可以快速调整其应用程序以适应不同的图像处理相关的AI能力。
此外，通过支持像ImagePrompt这样的辅助类来进行输入封装以及使用ImageResponse来处理输出，图像模型API统一了与致力于图像生成的AI模型之间的通信。它管理请求准备和响应解析的复杂性，为图像生成功能提供直接而简化的API交互。
Image Model API建立在Spring AI通用模型API之上，提供了特定于图像的抽象和实现。

2）相关接口

ImageModel（图像模型）

java 复制代码

@FunctionalInterface
public interface ImageModel extends Model<ImagePrompt, ImageResponse> {
	ImageResponse call(ImagePrompt request);
}

ImagePrompt（图像提示）

ImagePrompt是一个封装了ImageMessage对象列表及可选模型请求选项的ModelRequest。

java 复制代码

public class ImagePrompt implements ModelRequest<List<ImageMessage>> {
    private final List<ImageMessage> messages;
    private ImageOptions imageModelOptions;
    @Override
    public List<ImageMessage> getInstructions() {...}
	@Override
	public ImageOptions getOptions() {...}
}

ImageMessage（图像消息）

ImageMessage类封装了用于影响生成图像的文本及其权重。对于支持权重的模型，它们可以是正数或负数。

java 复制代码

public class ImageMessage {
	private String text; 
	private Float weight;
    public String getText() {...}
	public Float getWeight() {...}
}

ImageOptions（图像选项）

表示可以传递给图像生成模型的选项。ImageOptions接口扩展了ModelOptions接口，并用于定义可以传递给AI模型的一些可移植选项。

java 复制代码

public interface ImageOptions extends ModelOptions {
	Integer getN();
	String getModel();
	Integer getWidth();
	Integer getHeight();
	String getResponseFormat(); // openai - url or base64 : stability ai byte[] or base64
}

ImageResponse（图像响应）

持有AI模型的输出，每个ImageGeneration实例包含来自单一提示的可能多个输出结果之一。

java 复制代码

public class ImageResponse implements ModelResponse<ImageGeneration> {
	private final ImageResponseMetadata imageResponseMetadata;
	private final List<ImageGeneration> imageGenerations;
	@Override
	public ImageGeneration getResult() {
		// get the first result
	}
	@Override
	public List<ImageGeneration> getResults() {...}
	@Override
	public ImageResponseMetadata getMetadata() {...}
}

ImageGeneration（图像生成）

ImageGeneration类扩展自ModelResult，代表输出响应及有关此结果的元数据。

java 复制代码

public class ImageGeneration implements ModelResult<Image> {
	private ImageGenerationMetadata imageGenerationMetadata;
	private Image image;
    @Override
	public Image getOutput() {...}
	@Override
	public ImageGenerationMetadata getMetadata() {...}
}

3）案例实现

Spring AI框架的ImageModel API 抽象了应用程序通过模型调用实现"文生图"的交互过程，基本流程：应用程序接收文本，调用模型生成图片。ImageModel 的入参为包装类型ImagePrompt，输出类型为ImageResponse

java 复制代码

@RestController
public class ImageModelController {

    @Autowired
    private DashScopeImageModel imageModel;

    @GetMapping("/image")
    public void getImage(@RequestParam String msg, HttpServletResponse res){
        ImageResponse imageResponse = imageModel.call(
                new ImagePrompt(
                        msg,
                        DashScopeImageOptions.builder()
                                .withModel(DashScopeImageApi.DEFAULT_IMAGE_MODEL)
                                //要生成的图像数。必须介于 1 和 10 之间。
                                .withN(1)
                                .withHeight(1024)
                                .withWidth(1024)
                                .build()
                )
        );

        //获取生成图像地址
        String imageUrl = imageResponse.getResult().getOutput().getUrl();
        try {
            //使用输出流在浏览器输出
            URL url = URI.create(imageUrl).toURL();
            InputStream inputStream = url.openStream();
            res.setHeader("Content-Type", MediaType.IMAGE_PNG_VALUE);
            res.getOutputStream().write(inputStream.readAllBytes());
            res.getOutputStream().flush();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

（5）语音模型

1）概述

在Spring AI框架中，Text-to-Speech API提供了一个基于OpenAI的TTS（文本转语音）模型的语音端点，使用户能够：

朗读写好的博客文章。
生成多种语言的语音音频。
使用流媒体实现实时音频输出。

这一功能强大的API让用户可以轻松地将文字内容转化为语音内容，不仅支持多语言转换，还能满足实时语音输出的需求，极大地提升了内容的可访问性和用户的体验感。

2）案例实现

SpeechSynthesisModel 类是Spring AI Alibaba框架中用于表示和管理文本转语音模型的核心组件之一。
DashScopeSpeechSynthesisOptions 类通常用于配置文本转语音（TTS）服务的选项，这个类允许开发者指定一系列参数（比如：语速、音调、音量等）来定制化语音合成的结果，从而满足不同的应用场景需求。

java 复制代码

@RestController
public class TtsController {

    private static final String text = "锄禾日当午， 汗滴禾下土； 谁知盘中餐， 粒粒皆辛苦。";

    private static final String path = "d:/tts";

    @Autowired
    private DashScopeSpeechSynthesisModel speechSynthesisModel;

    @GetMapping("/tts")
    public void tts(){
        // 使用构建器模式创建 DashScopeSpeechSynthesisOptions 实例并设置参数
        DashScopeSpeechSynthesisOptions options = DashScopeSpeechSynthesisOptions.builder()
                // 设置语速
                .withSpeed(1.0)
                // 设置音调
                .withPitch(0.9)
                // 设置音量
                .withVolume(60)
                .build();

        SpeechSynthesisResponse response = speechSynthesisModel.call(new SpeechSynthesisPrompt(text, options));
        File file = new File(path);
        try (FileOutputStream fos = new FileOutputStream(file + "/output.mp3")){
            ByteBuffer buffer = response.getResult().getOutput().getAudio();
            fos.write(buffer.array());
        } catch (IOException e){
            e.printStackTrace();
        }
    }

}

（6）Spring AI实现RAG

1）向量化

* 向量数据库（Vector Database）是一种以数学向量的形式存储数据集合的数据库，通过一个数字列表来表示维度空间中的一个位置。在这里，向量数据库的功能是可以基于相似性搜索进行识别，而不是精准匹配。比如说在使用一个商城系统的向量数据库进行查询的时候，用户输入"北京"，其可能返回的结果会是 "中国、北京、华北、首都、奥运会" 等信息；输入"沈阳"，其返回结果可能会是"东北、辽宁、雪花、重工业"等信息。当然，返回的信息取决于向量数据库中存在的数据。用户可以通过参数的设置来限定返回的情况，进而适配不同的需求。

* 嵌入模型（Embedding Model）和向量数据库（Vector Database/Vector Store）是一对亲密无间的合作伙伴，也是 AI 技术栈中紧密关联的两大核心组件，两者的协同作用构成了现代语义搜索、推荐系统和 **RAG（Retrieval Augmented Generation，检索增强生成）**等应用的技术基础。

2）RAG的基本概念

RAG ，全称 Retrieval-Augmented Generation ，中文叫做检索增强生成。RAG是一种结合了检索系统和生成模型的新型技术框架，其主要目的有：

利用外部知识库
帮助大模型生成更加准确、有依据、最新的回答

通过使用RAG，解决了传统LLM存在的两个主要问题：

知识局限性：LLM的知识被固定在训练数据中，无法知道最新消息。
幻觉现象：LLM有时候会编造出并不存在的答案。

通过检索外部知识，RAG让模型突破了知识局限性，也让LLM（大语言模型）的幻觉现象得到解决。

3）RAG工作流程概述

第一，用户输入问题

用户在输入窗口输入自己的问题，这一数据被接收，并作为后续处理的查询入口

例如：用户提问

"我的智能手表出现蓝牙连接问题，怎么办？"

第二，问题向量化

根据用户初始输入的问题，调用Embedding模型，将问题转换为高维向量，以便于后续的想来那个相似度检索。

复制代码

文本："我的智能手表出现蓝牙连接问题，怎么办？"
→ 向量：[0.123, 0.582, ..., 0.001]

第三，向量数据库检索

系统会连接到一个向量数据库（如FAISS、Milvus、Pinecone、Weaviate）。然后用刚才生成的问题向量，检索知识库中与之最相似的文档片段。

当检索的时候，常见的检索参数包括：

Tok-K ：检索最相关的K条记录
相似度阈值：控制检索到内容的相关性

最后输出的结果往往是K条知识片段

复制代码

1. "蓝牙连接问题通常可以通过重启设备和重新配对解决。"
2. "如果手表固件版本较旧，请更新到最新版本以兼容蓝牙。"
3. "某些环境下，如电磁干扰，也会导致连接失败。"

第四，构建上下文

这一阶段需要组织提示词（Prompt），让LLM更好地理解背景信息。

这一部分包括：

系统提示词（System Prompt）

提前告诉LLM需要遵循的行为规范，比如

复制代码

你是一个专业的智能手表客服助理。请基于提供的背景资料，准确回答用户的问题。如果资料中没有明确答案，请如实告诉用户而不是编造。

系统提示词可以有效地设定模型角色、控制回答风格、防止幻觉

构造最终输入（Final Prompt）

一般会结合以上内容，按照如下格式进行组织

复制代码

【背景资料】
1. 蓝牙连接问题通常可以通过重启设备和重新配对解决。
2. 如果手表固件版本较旧，请更新到最新版本以兼容蓝牙。
3. 某些环境下，如电磁干扰，也会导致连接失败。

【用户问题】
我的智能手表出现蓝牙连接问题，怎么办？

【回答要求】
请结合以上资料，用简洁明了的方式回答用户的问题。如果答案无法直接从资料中找到，请礼貌告知用户。

第五，调用LLM

将构造好的Prompt提交给LLM（比如Deepseek、Qwen、GPT-4o、Claude等）

模型读取检索到的内容和问题
组织自然、连贯、准确的回答

生成结果示例：

"您好！ 根据我们的资料，您可以尝试重启智能手表并重新进行蓝牙配对。如果问题仍未解决，请检查手表固件是否为最新版本。如处于高电磁干扰环境，也可能影响连接质量，建议更换使用环境。"

第六，返回最终回答给用户

最终系统将生成的回答返回前端，展示给用户。

4）SprinAI实现RAG流程

创建配置类

配置 ChatClient 作为 Bean，其中设置系统默认角色为Java开发语言专家，负责处理用户查询并生成回答向量存储配置。

初始化 SimpleVectorStore，加载Java开发语言说明文档，将文档转换为向量形式存储。

java 复制代码

@Configuration
public class RagConfig {

    @Bean
    ChatClient chatClient(ChatClient.Builder builder){
        return builder.defaultSystem("你将作为一名Java开发语言的专家，对于用户的使用需求作出解答").build();
    }

    @Bean
    VectorStore vectorStore(EmbeddingModel embeddingModel) {
        SimpleVectorStore simpleVectorStore = SimpleVectorStore.builder(embeddingModel).build();
        // 生成一个说明的文档
        List<Document> documents = List.of(
                new Document("产品说明:名称：Java开发语言\n" +
                        "产品描述：Java是一种面向对象开发语言。\n" +
                        "特性：\n" +
                        "1. 封装\n" +
                        "2. 继承\n" +
                        "3. 多态\n"));

        simpleVectorStore.add(documents);
        return simpleVectorStore;
    }

编写controller

通过添加 QuestionAnswerAdvisor 并提供对应的向量存储，可以将之前放入的文档作为参考资料，并生成增强回答。

java 复制代码

@RestController
public class RagController {

    @Autowired
    private ChatClient chatClient;

    @Autowired
    private VectorStore vectorStore;

    @GetMapping(value = "/rag", produces = "text/plain; charset=UTF-8")
    public String rag(@RequestParam String msg){
        return chatClient.prompt()
                .user(msg)
                .advisors(new QuestionAnswerAdvisor(vectorStore))
                .call()
                .content();
    }
}

测试