LLM TREND

大模型技术趋势分享：LLM、RAG、Prompt、Agent、Fine-tuning等

LLM

利用 Spring AI 构建具备记忆功能的智能聊天机器人：深度解析与实践

By llmtrend #大模型

随着 大模型 技术的飞速发展，智能聊天机器人已成为各个领域不可或缺的一部分。然而，构建一个真正智能的聊天机器人，不仅仅是简单的问答，更需要它具备记忆能力，能够记住之前的对话内容，从而提供更自然、更连贯的交互体验。本文将深入探讨如何利用 Spring AI 框架构建具备聊天记忆功能的智能聊天机器人，并结合实际案例和代码示例，详细解析其实现原理与关键技术。

Spring AI 简介与环境搭建

Spring AI 是一个强大的框架，旨在简化基于 大模型 的应用程序开发。它提供了与各种 大模型 交互的抽象层，以及诸如提示工程、文档加载和检索、向量数据库集成等多种实用工具。本文将使用 Spring AI 1.0.0-M6 版本，结合 Java 17 和 Spring Boot 3.5.0，并与 Ollama 集成，搭建一个本地运行的智能聊天机器人环境。

首先，需要在 pom.xml 文件中添加必要的 Maven 依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
        <version>1.0.0-M6</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-core</artifactId>
        <version>1.0.0-M6</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 的核心依赖，Ollama 集成依赖以及 Spring Web 依赖。 spring-ai-bom 用于管理 Spring AI 相关依赖的版本，确保版本兼容性。

其次，在 application.properties 文件中配置 Ollama 模型。本文使用 Mistral 模型：

spring.application.name=llama3
spring.ai.ollama.chat.model=mistral

最后，需要安装并运行 Ollama。访问 https://ollama.com 下载并安装 Ollama，然后在终端运行 ollama run mistral。Ollama 允许开发者在本地轻松运行开源 大模型，无需互联网连接或 API 密钥，极大地降低了开发门槛。

基础聊天机器人：无记忆的简单实现

在实现具备聊天记忆功能的机器人之前，我们先构建一个基础的、不具备记忆能力的聊天机器人。这个机器人每次只能根据当前输入进行回复，无法记住之前的对话内容。

package com.example.RAG;

import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ChatController {

    private final ChatModel chatModel;

    public ChatController(@Qualifier("ollamaChatModel") ChatModel chatModel) {
        this.chatModel = chatModel;
    }

    @PostMapping("/chat")
    public String chat(@RequestBody String userMessage) {
        Prompt prompt = new Prompt(new UserMessage(userMessage));
        return chatModel.call(prompt).getResult().getOutput().getText();
    }
}

这段代码定义了一个 ChatController，它接收来自 /chat 接口的 POST 请求，将用户消息封装成 UserMessage 对象，然后创建一个 Prompt 对象，并将其传递给 ChatModel 进行处理。ChatModel 负责调用 大模型，并将响应结果返回。

例如，我们先发送消息 “My name is John.”，然后再发送消息 “What is my name?”。由于这个基础机器人没有记忆功能，所以它无法回答 “John.”，因为它不记得之前的对话内容。每次交互都是独立的。

实现聊天记忆：自定义解决方案

为了让聊天机器人具备记忆功能，我们需要维护一个消息历史记录。每次接收到用户消息时，将消息添加到历史记录中，并在创建 Prompt 对象时，将整个历史记录作为上下文传递给 大模型。

package com.example.RAG;

import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;

@RestController
public class ChatController {

    private final ChatModel chatModel;
    private final List<UserMessage> messageHistory;

    public ChatController(@Qualifier("ollamaChatModel") ChatModel chatModel) {
        this.chatModel = chatModel;
        this.messageHistory = new ArrayList<>();
    }

    @PostMapping("/chat")
    public String chat(@RequestBody String userMessage) {
        UserMessage userMsg = new UserMessage(userMessage);
        messageHistory.add(userMsg);
        Prompt prompt = new Prompt(new ArrayList<>(messageHistory));
        return chatModel.call(prompt).getResult().getOutput().getText();
    }
}

在这个改进后的 ChatController 中，我们添加了一个 messageHistory 列表，用于存储所有的 UserMessage 对象。每次接收到新的消息时，我们将其添加到 messageHistory 中，并将整个 messageHistory 列表传递给 Prompt 对象。这样，大模型 就可以访问到之前的对话内容，从而实现聊天记忆功能。

现在，如果我们再次发送 “My name is John.”，然后再发送 “What is my name?”，聊天机器人就可以正确地回答 “John.”。它通过 聊天记忆 功能，记住了之前的对话内容，并将这些信息用于生成响应。

聊天记忆的优势与应用场景

具备聊天记忆功能的智能聊天机器人，在许多场景下都具有显著优势：

  • 更自然、更连贯的对话体验： 机器人可以记住之前的对话内容，避免用户重复输入相同的信息，使得对话更加流畅自然。
  • 支持 follow-up 问题： 用户可以基于之前的对话内容提出 follow-up 问题，而无需重新提供上下文信息。例如，用户可以先问 “What is the capital of France?”，然后问 “What is its population?”。
  • 个性化推荐： 机器人可以根据用户的历史对话记录，了解用户的兴趣和需求，从而提供更加个性化的推荐服务。例如，在电商领域，机器人可以根据用户的购买历史和浏览记录，推荐相关的商品。
  • 任务型对话： 在任务型对话场景下，机器人需要记住用户的意图和目标，才能完成复杂的任务。例如，用户可以通过聊天的方式预定机票、查询天气等。

优化聊天记忆：Token 限制与上下文管理

虽然聊天记忆功能可以显著提升用户体验，但也需要考虑一些重要的因素，特别是 大模型 的 Token 限制和上下文管理。

  • Token 消耗： 每次交互都会增加请求中的 Token 数量。更多的 Token 意味着更高的成本和更慢的响应速度。
  • 上下文窗口限制： 大模型 只能处理有限数量的 Token，这个限制被称为上下文窗口。例如，GPT-3.5 的上下文窗口为 4,096 个 Token，GPT-4 的上下文窗口为 8,192 或 32,768 个 Token。如果对话历史记录超过了上下文窗口的限制，就需要采取一些措施来减少 Token 的使用，例如：
    • 总结旧的消息： 将旧的消息总结成更短的摘要，减少 Token 的使用。
    • 只包含最相关的交互： 移除与当前问题无关的对话历史记录。
    • 智能截断历史： 根据一定的策略，截断部分对话历史记录。

例如，我们可以设置一个最大历史记录长度，当 messageHistory 列表的长度超过这个限制时，就移除最旧的消息。或者，我们可以使用一些算法，例如 TF-IDF 或 BM25，来评估每条消息的相关性，并只保留最相关的消息。

// 设置最大历史记录长度
private static final int MAX_HISTORY_SIZE = 10;

@PostMapping("/chat")
public String chat(@RequestBody String userMessage) {
    UserMessage userMsg = new UserMessage(userMessage);
    messageHistory.add(userMsg);

    // 移除最旧的消息，保持历史记录长度不超过 MAX_HISTORY_SIZE
    if (messageHistory.size() > MAX_HISTORY_SIZE) {
        messageHistory.remove(0);
    }

    Prompt prompt = new Prompt(new ArrayList<>(messageHistory));
    return chatModel.call(prompt).getResult().getOutput().getText();
}

持久化聊天记忆：集成 Redis

目前，我们的聊天记忆实现是基于内存的，这意味着当应用程序重启时，所有的对话历史记录都会丢失。为了实现持久化的聊天记忆，我们需要将对话历史记录存储到数据库中。Redis 是一个流行的内存数据库，非常适合用于存储聊天历史记录。

首先，需要在 pom.xml 文件中添加 Redis 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后，在 application.properties 文件中配置 Redis 连接信息：

spring.redis.host=localhost
spring.redis.port=6379

接下来，我们需要创建一个 RedisTemplate，用于与 Redis 交互。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer()); // 可以根据实际情况选择合适的序列化器
        return template;
    }
}

最后，我们需要修改 ChatController，使用 Redis 来存储和检索对话历史记录。

package com.example.RAG;

import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
public class ChatController {

    private final ChatModel chatModel;
    private final RedisTemplate<String, Object> redisTemplate;

    @Value("${spring.application.name}")
    private String appName;

    public ChatController(@Qualifier("ollamaChatModel") ChatModel chatModel, RedisTemplate<String, Object> redisTemplate) {
        this.chatModel = chatModel;
        this.redisTemplate = redisTemplate;
    }

    @PostMapping("/chat")
    public String chat(@RequestBody String userMessage) {
        // 从 Redis 中获取对话历史记录
        List<UserMessage> messageHistory = (List<UserMessage>) redisTemplate.opsForList().range(appName + ":messageHistory", 0, -1);
        if (messageHistory == null) {
            messageHistory = new ArrayList<>();
        }

        UserMessage userMsg = new UserMessage(userMessage);
        messageHistory.add(userMsg);

        // 将对话历史记录存储到 Redis 中
        redisTemplate.opsForList().rightPushAll(appName + ":messageHistory", messageHistory.toArray());

        Prompt prompt = new Prompt(new ArrayList<>(messageHistory));
        return chatModel.call(prompt).getResult().getOutput().getText();
    }
}

这段代码使用 RedisTemplate 将对话历史记录存储在 Redis 的 List 中。键的名称是 appName + ":messageHistory"，其中 appName 是 Spring Boot 应用程序的名称。每次接收到新的消息时，我们首先从 Redis 中获取对话历史记录，然后将新的消息添加到历史记录中，并将更新后的历史记录存储回 Redis。

通过集成 Redis，我们可以实现持久化的聊天记忆功能，即使应用程序重启，对话历史记录也不会丢失。

Spring AI 提供的 Memory 功能

Spring AI 框架本身也提供了 Memory 接口，用于管理聊天机器人的状态。我们可以利用 Spring AI 提供的 Memory 接口简化聊天记忆的实现。 虽然文章中未使用，但在实际开发中，推荐使用 Spring AI 自带的 Memory 功能，例如 ConversationBufferWindowMemory 或 TokenWindowMemory。 这些 Memory 实现已经考虑了 Token 限制和上下文管理等问题，并提供了更高级的功能，例如自动总结历史记录。

结论与展望

本文深入探讨了如何利用 Spring AI 框架构建具备聊天记忆功能的智能聊天机器人。通过维护消息历史记录，并将其作为上下文传递给 大模型，我们可以显著提升聊天机器人的交互体验。同时，我们还需要考虑 Token 限制、上下文管理以及数据持久化等因素，才能构建一个真正实用、高效的智能聊天机器人。

随着 大模型 技术的不断发展，智能聊天机器人的应用场景将越来越广泛。未来的研究方向包括：更智能的上下文管理、更高效的记忆存储、更强大的自然语言理解能力以及更个性化的用户体验。 Spring AI 作为强大的开发框架，将继续在 大模型 应用开发领域发挥重要作用。 深入理解并灵活运用 Spring AI，将帮助开发者构建更加智能、更加人性化的聊天机器人，为人们的生活和工作带来更多便利。

By llmtrend

Related Post

LLM

本地部署 DeepSeek-R1：使用 Ollama 轻松驾驭大模型

llmtrend
LLM

Spring AI赋能：利用工具调用（Tool Calling）构建更强大的大语言模型应用

llmtrend
LLM

从预训练到策略优化：大型语言模型 (LLM) 如何实现与人类意图对齐

llmtrend

You Missed

LLM

从预训练到策略优化：大型语言模型 (LLM) 如何实现与人类意图对齐

LLM

Spring AI赋能：利用工具调用（Tool Calling）构建更强大的大语言模型应用

AI Tools

AI 内容捷径：为什么过度依赖 AI 写作会损害你的 WordPress 网站 SEO？

Agent

2025年值得关注的五大 Agentic AI框架：迎接自主智能新时代