Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！

地推

443人浏览 · 2025-08-21 14:39:07

地推 · 2025-08-21 14:39:07 发布

概述

在大模型技术迅速普及的当下，如何在本地环境中以低成本部署高性能AI服务，成为了广大开发者关注的焦点。

本文将结合Spring AI、Ollama和DeepSeek-R1模型，通过Docker容器化部署和Redis持久化存储，手把手教你构建一个支持连续对话的AI应用。

这一方案特别适合需要私有化部署、数据安全可控的场景，如企业内部知识库、教育问答系统等。

这是一篇全家桶式教程，主要内容包括：

环境搭建： 从安装Docker开始，到通过Docker安装Redis、Ollama，并部署DeepSeek模型，一步步带你搞定环境配置。
Spring AI集成： 详细讲解如何将Ollama和DeepSeek集成到Spring AI中，并实现连续对话功能。
效果验证： 通过实际测试，展示系统的运行效果，让你直观感受这一方案的强大之处。

环境准备

在开始之前，请确保你的环境满足以下要求：

操作系统： Windows 11
Java版本： JDK 17+(请注意Spring Boot 3.4.3的兼容性)
依赖管理： Maven 3.8.3+

环境搭建(docker,redis, ollama 和deepseek)

1. 安装docker

本地环境使用Docker进行部署，可以大大节省环境配置的工作量，同时减少组件对系统性能的影响。在不开发时，关闭Docker，还能避免各种干扰。对于还不熟悉Docker的同学，建议尽快学习掌握这一强大工具。

由于很多教程都是基于Linux系统的，这里我们详细讲解一下在Windows本地环境下的搭建步骤。首先，访问docker官网，根据你的系统选择合适的版本进行下载和安装。安装完成后，进入PowerShell，输入指令docker ps，如果能看到相关输出，说明Docker安装成功。

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_计算机

安装后，进入PowerShell，输入指令 docker ps ，看到这个就OK了

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_java_02

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_程序员_03

2.Redis容器部署

说明：此命令从Docker Hub拉取指定版本的Redis镜像，为后续的容器部署做好准备。

在本地创建文件夹C:\docker\redis\conf和C:\docker\redis\data，并在conf文件夹下创建文件redis.conf，内容如下：

bind 0.0.0.0
port 6379
requirepass 123123
dir /data
appendonly yes

bind 0.0.0.0：允许外部访问
requirepass 123123：设置访问密码，你可以根据需要自行设定，虽然是本地环境，但养成良好的安全习惯很重要
appendonly yes：开启AOF持久化

接下来，进行容器部署：

docker run -d \
-p 6579:6379 \
-v C:/docker/redis/data:/data \
-v C:/docker/redis/conf:/usr/local/etc/redis \
--name redis \
redis:7.4.2 redis-server /usr/local/etc/redis/redis.conf

说明：通过上述命令，我们基于刚才拉取的镜像创建并启动了一个Redis容器，同时将本地的配置文件和数据目录挂载到容器中，方便进行持久化存储和配置管理。

3. 安装ollama

下载ollama

创建本地文件夹C:\docker\ollama，然后运行以下命令：

docker run -d \
-v C:\docker\ollama:/root/.ollama \
-p 11434:11434 \
--name ollama \
ollama/ollama:0.6.2

功能说明：映射本地模型存储目录/root/.ollama，开放11434端口供API调用。你可以通过Deepseek模型版本查看了解更多相关信息。

4. 安装Deepseep

模型拉取，由于我没有显卡，因此最多也就拉取7b模型，大家也可以根据自己的需求选择合适的模型。

说明：此命令在已启动的Ollama容器中执行模型拉取操作，将DeepSeek-R1的7b版本模型下载到本地，以便后续进行调用和测试。

Spring AI 集成与代码实现

1. maven的核心依赖

<!-- 全局属性管理 -->
<properties>
    <java.version>23</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <!-- 自定义依赖版本 -->
    <spring-boot.version>3.4.3</spring-boot.version>
    <spring.ai.version>1.0.0-M6</spring.ai.version>
    <maven.compiler.version>3.11.0</maven.compiler.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.32</version>
        <optional>true</optional>
    </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>1.0.0-SNAPSHOT</version>-->
            <version>1.0.0-M6</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- 构建配置 -->
<build>
    <plugins>
        <!-- 编译器插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>${maven.compiler.version}</version>
            <configuration>
                <release>${java.version}</release>
                <annotationProcessorPaths>
                    <path>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                        <version>1.18.32</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>

        <!-- Spring Boot打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.projectlombok</groupId>
                        <artifactId>lombok</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

<!-- 仓库配置 -->
<repositories>
    <repository>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>https://maven.aliyun.com/repository/public</url>
    </repository>
    <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>
    <repository>
        <name>Central Portal Snapshots</name>
        <id>central-portal-snapshots</id>
        <url>https://central.sonatype.com/repository/maven-snapshots/</url>
        <releases>
            <enabled>false</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.

说明：上述Maven配置文件中，我们引入了Spring Boot、Spring Data Redis、Spring AI以及Lombok等依赖，为项目提供了Web开发、Redis数据操作、AI模型集成以及代码简化等功能支持。同时，通过插件配置和仓库配置，确保项目的构建和依赖管理能够顺利进行。

2. 核心配置(application.yml)

server:
  port:8083
spring:
application:
    name:Ollama-AI
data:
    redis:
      host:127.0.0.1
      port:6579
      password:123123
      database:0
ai:
    ollama:
      base-url:http://127.0.0.1:11434
      chat:
        model:deepseek-r1:7b

说明：在application.yml文件中，我们配置了服务器端口、Spring应用名称、Redis连接信息以及AI相关配置。其中，Redis的主机、端口、密码等参数需要与实际部署的Redis容器相匹配，而AI部分则指定了Ollama的基地址和使用的模型版本，确保系统能够正确连接和调用相应的AI服务。

3. 实现连续对话

3.1 控制器层(OllamaChatController.java)

@Slf4j
@RestController
@RequestMapping("/ai/v1")
publicclass OllamaChatController {

    privatefinal ChatClient chatClient;
    privatefinal ChatMemory chatMemory;

    public OllamaChatController(ChatClient.Builder builder, ChatMemory chatMemory) {
        this.chatClient = builder
                .defaultSystem("只回答问题，不进行解释")
                .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))
                .build();
        this.chatMemory = chatMemory;
    }

    @GetMapping("/ollama/redis/chat")
    public String chat(@RequestParam String userId, @RequestParam String input) {
        log.info("/ollama/redis/chat   input:  [{}]", input);

        String text = chatClient.prompt()
                .user(input)
                .advisors(spec -> spec.param(AbstractChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY, userId)
                        .param(AbstractChatMemoryAdvisor.CHAT_MEMORY_RETRIEVE_SIZE_KEY, 100))
                .call()
                .content();

        return text.split("</think>")[1].trim();
    }
}

说明：该控制器类定义了一个RESTful接口，用于接收用户的输入并返回AI模型的回复。通过依赖注入获取ChatClient和ChatMemory实例，构建聊天客户端，并在chat方法中处理用户的输入，调用AI模型进行对话，并将结果返回给前端。

3.2 Redis持久化(ChatRedisMemory.java)

@Slf4j
@Component
publicclass ChatRedisMemory implements ChatMemory {

    privatestaticfinal String KEY_PREFIX = "chat:history:";
    privatefinal RedisTemplate<String, Object> redisTemplate;

    public ChatRedisMemory(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void add(String conversationId, List<Message> messages) {
        String key = KEY_PREFIX + conversationId;
        List<ChatEntity> listIn = new ArrayList<>();
        for(Message msg: messages){
            String[] strs = msg.getText().split("</think>");
            String text = strs.length==2?strs[1]:strs[0];

            ChatEntity ent = new ChatEntity();
            ent.setChatId(conversationId);
            ent.setType(msg.getMessageType().getValue());
            ent.setText(text);
            listIn.add(ent);
        }
        redisTemplate.opsForList().rightPushAll(key,listIn.toArray());
        redisTemplate.expire(key, 30, TimeUnit.MINUTES);
    }

   @Override
    public List<Message> get(String conversationId, int lastN) {
        String key = KEY_PREFIX + conversationId;
        Long size = redisTemplate.opsForList().size(key);
        if (size == null || size == 0){
            return Collections.emptyList();
        }

        int start = Math.max(0, (int) (size - lastN));
        List<Object> listTmp = redisTemplate.opsForList().range(key, start, -1);
        List<Message> listOut = new ArrayList<>();
        ObjectMapper objectMapper = new ObjectMapper();
        for(Object obj: listTmp){
            ChatEntity chat =  objectMapper.convertValue(obj, ChatEntity.class);
//            log.info("MessageType.USER [{}], chat.getType [{}]",MessageType.USER, chat.getType());
            if(MessageType.USER.getValue().equals(chat.getType())){
                listOut.add(new UserMessage(chat.getText()));
            }elseif(MessageType.ASSISTANT.getValue().equals(chat.getType())){
                listOut.add(new AssistantMessage(chat.getText()));
            }elseif(MessageType.SYSTEM.getValue().equals(chat.getType())){
                listOut.add(new SystemMessage(chat.getText()));
            }
        }
        return listOut;
    }

    @Override
    public void clear(String conversationId) {
        redisTemplate.delete(KEY_PREFIX + conversationId);
    }
}

说明：此组件实现了ChatMemory接口，利用Redis进行对话历史记录的持久化存储。通过RedisTemplate操作Redis列表，实现了对话记录的添加、获取和清除功能，确保对话上下文能够在多次请求之间保持连贯，从而支持连续对话。

3.3 配置类与序列化(RedisConfig.java)

@Configuration
publicclass RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //生成整个 RedisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

说明：该配置类用于创建RedisTemplate Bean，通过设置不同的序列化方式，确保在与Redis进行数据交互时，键和值能够正确地进行序列化和反序列化操作，从而保证数据的完整性和可读性。

3.4. 实体类(ChatEntity.java)

@NoArgsConstructor
@AllArgsConstructor
@Data
public class ChatEntity implements Serializable {
    String chatId;
    String type;
    String text;
}

说明：这是一个简单的Java实体类，用于表示对话中的每一条消息记录。包含对话ID、消息类型和消息文本三个属性，通过Lombok的注解自动生成构造方法、getter和setter方法，简化了代码编写。

3.5. 启动类(OllamaChatDemoApplication.java)

@EnableCaching
@SpringBootApplication
public class OllamaChatDemoApplication {

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

测试与验证

环境启动

确保docker部署的redis和ollama服务都正常运行，通过 docker ps查看

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_spring_04

如果没有的话, 可以通过docker start redis, docker start ollama来启动

Spring 服务启动后,我们看看效果吧

我们Spring 项目中，开放了一个接口

http://127.0.0.1:8083/ai/v1/ollama/redis/chat

接下来我们问几个问题, 这些问题一环套一环, 看看他回答的怎么样吧.

你是谁

列举3个中国文学家

他们的出生地在哪

这些地方都有什么特产

不过，由于部署的版本较低，回答速度可能较慢，且可能出现中英文混杂的情况。在生产环境中，建议部署高算力的版本以获得更好的性能。

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_spring_05

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_编程_06

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_spring_07

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_java_08

另外，我们看看redis中的存储

Spring AI + DeepSeek，10分钟快速构建本地化AI对话系统！_程序员_09

补充

本文通过完整的Docker部署、Spring AI集成和Redis持久化方案，详细展示了如何低成本构建本地化AI服务。这一方案不仅支持连续对话等复杂场景，还通过容器化技术实现了环境隔离。

对于开发者而言，掌握这一技术栈将显著提升私有化AI应用的开发效率，为各种需要数据安全和隐私保护的应用场景提供有力支持。

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

从理论到工程：构建可落地的多模态AI Agent系统

本文系统性地介绍了构建生产级多模态AI Agent系统的全流程。首先阐述三大数理基础（线性代数、概率统计、信息论）对模型训练的重要性，然后以Qwen2-VL-7B和Whisper为例解析多模态基础模型的架构选择与三阶段训练策略（对齐预训练、指令微调、DPO对齐）。接着详细说明如何用LangGraph构建具有自主决策能力的Agent框架，并实现工具调用功能。最后探讨工程落地中的关键技术，包括向量检索

AI Agent技术社区

2026年企业AI办公工具深度横评：飞书 aily 等5款主流产品选型指南

最近为了给团队筛选适配现有协作体系的AI办公工具，调研了企业级AI Agent赛道几款主流产品，最终选择了飞书 aily，核心原因是它不需要额外搭建独立的AI使用链路，所有生成内容可以直接同步到团队日常使用的协作载体中，大幅降低了全员上手的学习成本。本次评测所有参评产品的综合得分均高于4.0，飞书 aily 和其余产品的最高得分差控制在0.3以内，所有评分均来自团队内部多角色用户的实际使用反馈，覆