LangChain4j（5）——聊天记忆的多用户支持和持久化存储

原创 已于 2025-04-12 11:38:50 修改 · 996 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #人工智能 #LangChain4j

于 2025-04-08 14:10:25 首次发布

支持多用户

上篇文章中，我们使用Chat Memory实现了对聊天内容的储存，但是，其中的代码案例只支持存储一个用户的聊天数据。实际应用中，我们的系统肯定是多用户的，每个用户都需要维护各自的聊天数据。为了解决这个问题，我们可以使用ChatMemoryProvider实现，ChatMemoryProvider的源码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package dev.langchain4j.memory.chat;

import dev.langchain4j.memory.ChatMemory;

@FunctionalInterface
public interface ChatMemoryProvider {
    ChatMemory get(Object var1);
}

从源码中，我们可以看到，ChatMemoryProvider中仅包含一个get方法，我们可以使用用户id做为该方法的参数。

支持多用户的代码如下：

package com.renr.langchain4jnew.app;

import com.renr.langchain4jnew.constant.CommonConstants;
import dev.langchain4j.community.model.zhipu.ZhipuAiChatModel;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.chat.ChatMemoryProvider;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.store.memory.chat.ChatMemoryStore;

import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class App7 {

    public static void main(String[] args) {

        // 表示将聊天的上下文信息存储到内容中
        InMemoryChatMemoryStore memoryStore = new InMemoryChatMemoryStore();
        // 创建对象，通过lambda表达式重写其中的get方法
        ChatMemoryProvider chatMemoryProvider = userId -> MessageWindowChatMemory.builder()
                .id(userId)
                .maxMessages(10)
                .chatMemoryStore(memoryStore)
                .build();

        // 创建智谱的模型对象
        ZhipuAiChatModel zhipuAiChatModel = ZhipuAiChatModel.builder()
                // 模型key
                .apiKey(CommonConstants.API_KEY)
                // 精确度
                .temperature(0.9)
                .model("GLM-4-Flash")
                .maxRetries(3)
                .callTimeout(Duration.ofSeconds(60))
                .connectTimeout(Duration.ofSeconds(60))
                .writeTimeout(Duration.ofSeconds(60))
                .readTimeout(Duration.ofSeconds(60))
                // 请求的日志
                //.logRequests(true)
                // 响应数据的日志
                //.logResponses(true)
                .build();

        // 用户发送的消息
        UserMessage firstUserMessage = UserMessage.from("你好，我叫张三");
        // 将问题添加到chat memory
        // 假设用户id是111，根据chatMemoryProvider.get(111)获取该用户的ChatMemory对象
        chatMemoryProvider.get(111).add(firstUserMessage);

        // 发送消息时，直接通过ChatMemory获取聊天的上下文
        AiMessage firstAiMessage = zhipuAiChatModel.chat(chatMemoryProvider.get(111).messages()).aiMessage();
        System.out.println("第一次回答：" + firstAiMessage.text());
        // 将回答的内容添加到chat memory
        chatMemoryProvider.get(111).add(firstAiMessage);

        UserMessage secondUserMessage = UserMessage.from("请问我叫什么名字?");
        chatMemoryProvider.get(111).add(secondUserMessage);


        AiMessage secondAiMessage = zhipuAiChatModel.chat(chatMemoryProvider.get(111).messages()).aiMessage();
        System.out.println("第二次回答：" + secondAiMessage.text());
        chatMemoryProvider.get(111).add(secondAiMessage);
    }


}

本例中，我们将上下文信息存储在InMemoryChatMemoryStore对象中。我们创建了一个ChatMemoryProvider对象，并且通过lambda表达式作为参数，用于返回ChatMemory对象。

在创建MessageWindowChatMemory对象时，对其指定一个id属性（本例使用用户id表示）。

发送聊天消息时，需要先根据用户id获取ChatMemory对象，然后将消息内容添加到ChatMemory中。本例使用的用户id是111，实际业务中需要通过相关的业务逻辑获取用户id。

持久化存储

上面的例子中，我们将聊天信息是存储在内存中的，如果需要进行持久化存储，用户只需要实现ChatMemoryStore接口即可。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package dev.langchain4j.store.memory.chat;

import dev.langchain4j.data.message.ChatMessage;
import java.util.List;

public interface ChatMemoryStore {
    List<ChatMessage> getMessages(Object var1);

    void updateMessages(Object var1, List<ChatMessage> var2);

    void deleteMessages(Object var1);
}

该接口包含3个方法：

getMessage：根据用户id获取聊天数据列表，当调用ChatMemoryProvider的get方法时，会自动调用该方法。

updateMessages：向聊天列表中添加聊天数据，或者聊天列表达到上限需要淘汰数据时，会自动调用该方法。我们可以在这个方法中进行聊天数据的持久化存储。

deleteMessages：根据用户id删除聊天列表。

本例使用mysql存储聊天数据，使用hutool进行数据库的crud操作

mysql中新建表

导入jar

相对于之前的jar，增加了mysql驱动和hutool的jar。

<dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
            <version>1.0.0-beta2</version>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-community-zhipu-ai</artifactId>
            <version>1.0.0-beta2</version>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai</artifactId>
            <version>1.0.0-beta2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.30</version>
        </dependency>

resource目录下增加db.setting文件

该文件中我们指定了连接数据库的驱动、用户名和密码登信息。hutool的数据库操作工具类，会自动加载该文件。

## db.setting文件
url = jdbc:mysql://localhost:3306/db2406
user = root
pass = root
## 可选配置
# 是否在日志中显示执行的SQL
showSql = true
# 是否格式化显示的SQL
formatSql = false
# 是否显示SQL参数
showParams = true

测试代码

package com.renr.langchain4jnew.app;

import cn.hutool.db.Db;
import cn.hutool.db.Entity;
import com.renr.langchain4jnew.constant.CommonConstants;
import dev.langchain4j.community.model.zhipu.ZhipuAiChatModel;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.chat.ChatMemoryProvider;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.store.memory.chat.ChatMemoryStore;
import lombok.SneakyThrows;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

import static dev.langchain4j.data.message.ChatMessageDeserializer.messagesFromJson;
import static dev.langchain4j.data.message.ChatMessageSerializer.messagesToJson;


public class App8 {

    public static void main(String[] args) {

        // 创建自定义持久化类对象
        PersistentChatMemoryStore store = new PersistentChatMemoryStore();
        // 通过chatMemoryStore(store)指定持久化对象
        ChatMemoryProvider chatMemoryProvider = userId -> MessageWindowChatMemory.builder()
                .id(userId)
                .maxMessages(10)
                .chatMemoryStore(store)
                .build();

        // 创建智谱的模型对象
        ZhipuAiChatModel zhipuAiChatModel = ZhipuAiChatModel.builder()
                // 模型key
                .apiKey(CommonConstants.API_KEY)
                // 精确度
                .temperature(0.9)
                .model("GLM-4-Flash")
                .maxRetries(3)
                .callTimeout(Duration.ofSeconds(60))
                .connectTimeout(Duration.ofSeconds(60))
                .writeTimeout(Duration.ofSeconds(60))
                .readTimeout(Duration.ofSeconds(60))
                // 请求的日志
                //.logRequests(true)
                // 响应数据的日志
                //.logResponses(true)
                .build();

        // 删除原来的用户聊天数据
        store.deleteMessages(111);

        // 用户发送的消息
        UserMessage firstUserMessage = UserMessage.from("你好，我叫张三");
        // 将问题添加到chat memory
        chatMemoryProvider.get(111).add(firstUserMessage);
        // 发送消息时，直接通过ChatMemory获取聊天的上下文
        AiMessage firstAiMessage = zhipuAiChatModel.chat(chatMemoryProvider.get(111).messages()).aiMessage();
        System.out.println("第一次回答：" + firstAiMessage.text());
        chatMemoryProvider.get(111).add(firstAiMessage);

        // 用户发送的消息
        UserMessage secondUserMessage = UserMessage.from("请问我叫什么名字?");
        chatMemoryProvider.get(111).add(secondUserMessage);
        // ai返回的额消息，这里将之前的消息也一并发送,ai根据上下文返回合适的信息
        AiMessage secondAiMessage = zhipuAiChatModel.chat(chatMemoryProvider.get(111).messages()).aiMessage();
        System.out.println("第二次回答：" + secondAiMessage.text());
        chatMemoryProvider.get(111).add(secondAiMessage);

    }

    // 自定义实现持久化的类
    static class PersistentChatMemoryStore implements ChatMemoryStore {

        @SneakyThrows
        @Override
        public List<ChatMessage> getMessages(Object memoryId) {
            Entity chatMsg = Db.use().get(Entity.create("chat_msg").set("uid", memoryId));
            if (chatMsg != null) {
                String message = chatMsg.getStr("message");
                List<ChatMessage> chatMessages = messagesFromJson(message);
                return chatMessages;
            } else {
                return new ArrayList<>();
            }
        }

        @SneakyThrows
        @Override
        public void updateMessages(Object memoryId, List<ChatMessage> messages) {
            Entity chatMsg = Db.use().get(Entity.create("chat_msg").set("uid", memoryId));
            if (chatMsg != null) {
                Db.use().update(
                        Entity.create().set("message", messagesToJson(messages)), //修改的数据
                        Entity.create("chat_msg").set("uid", memoryId) //where条件
                );
            } else {
                Db.use().insert(
                        Entity.create("chat_msg")
                                .set("uid", memoryId)
                                .set("message", messagesToJson(messages))
                );
            }
        }

        @SneakyThrows
        @Override
        public void deleteMessages(Object memoryId) {
            Db.use().del(
                    Entity.create("chat_msg").set("uid", memoryId)//where条件
            );
        }
    }

}

注意：Db.use()是hutool中提供的操作数据库的方法，关于该类的使用，我们可以才考hutool的官网，本文不再赘述。

数据库（Hutool-db） | Hutool

执行后查看数据库数据

通过表中数据，可以看到聊天数据进行了正确的持久化。

需要说明的是，按照本例的写法，每次运行程序时都会先清空原来的聊天数据，并且按照json形式在一条记录中存储所有聊天记录。如果需要存储所有的聊天历史记录，读者可以自行对自定义的持久化类进行进一步的修改。

基于LangChain4j实现聊天记忆（Chat Memory）功能的学习
风雨无阻学习之路
04-03 1130
手动管理和维护ChatMessage（聊天消息）是繁琐的。因此，LangChain4j提供了一个ChatMemory抽象概念，以及多种现成的实现方式。ChatMemory可以作为独立的低级组件使用，也可以作为高级组件（如AI服务）的一部分。
LangChain4J Chat Memory（聊天记忆）
qq_36178841的博客
02-22 1140
根据使用的记忆算法，它可以以各种方式修改历史：驱逐某些消息、总结多条消息、总结独立消息、从消息中删除不重要的细节、向消息中注入额外的信息（例如，RAG）或指令（例如，结构化输出）等。如果包含 ToolExecutionRequests 的 AiMessage 被驱逐，以下孤立的 ToolExecutionResultMessage(s) 也会被自动驱逐，以避免与某些 LLM 提供商（如 OpenAI）相关的问题，这些提供商禁止在请求中发送孤立的 ToolExecutionResultMessage(s)。
LangChain4j入门AI（五）聊天记忆持久化
持续学习ing
05-19 1791
本文探讨了在实现大模型聊天记忆功能时，如何选择合适的存储介质以替代默认的内存存储方案。内存存储存在数据易丢失、容量受限、扩展性差、安全性低等缺陷，因此需要更可靠的存储方案。文章分析了多种存储介质的优缺点，包括向量数据库、关系型数据库、文档数据库、内存缓存数据库、对象存储和专用记忆管理系统。综合考虑成本、开发复杂度和系统适用性，文档数据库MongoDB被认为是最合适的选择。文章详细介绍了MongoDB的部署、依赖引入、配置文件设置，并通过源码解析展示如何自定义实现ChatMemoryStore接口，完成持久化
【ChatMemory聊天记忆】
MuYiLuck的博客
08-29 837
 本文简单介绍了SpringAI的聊天记忆功能，聊天记忆解决了大语言模型(LLM)无状态的问题，通过ChatMemory抽象层实现多轮对话上下文存储。还对聊天记忆的具体实现进行了简单的介绍，帮助新手快速上手聊天记忆功能。
4.聊天记忆 Chat memory
weixin_44250247的博客
05-11 1027
MongoDB 是一个基于文档的 NoSQL 数据库，由 MongoDB Inc. 开发。NoSQL，指的是非关系型的数据库。NoSQL有时也称作Not Only SQL的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。MongoDB 的设计理念是为了应对大数据量、高性能和灵活性需求。MongoDB使用集合（Collections）来组织文档（Documents），每个文档都是由键值对组成的。数据库（Database）：存储数据的容器，类似于关系型数据库中的数据库。
LangChain4j系列：LangChain4j ChatMemory聊天记忆详解与实战
优快云_224022的博客
08-14 3802
LangChain4j系列：LangChain4j ChatMemory聊天记忆详解与实战
JavaAI：LangChain4j学习（二）聊天，记忆存储，流式输出
Sdirws的博客
03-28 1461
JavaAI：LangChain4j学习（二）聊天，记忆存储，流式输出
LangChain4j +DeepSeek大模型应用开发——5 持久化聊天记忆 Persistence
欢迎来到空说的博客
04-29 1190
MongoDB 是一个基于文档的 NoSQL( 非关系型的数据库 ) 数据库，设计理念是为了应对大数据量、高性能和灵活性需求。MongoDB使用集合（）来组织文档（Documents），每个文档都是由键值对组成的。数据库（Database）：存储数据的容器，类似于关系型数据库中的数据库。集合（Collection）：数据库中的一个集合，类似于关系型数据库中的表。文档（Document）：集合中的一个数据记录，类似于关系型数据库中的行（row），以 BSON 格式存储。
LangChain4j——用户记忆(多轮对话)
专注写bug
06-19 1275
在应用端与大模型的对话中，大模型充当的只是一个类似工具函数的作用，每次进行对话只对当次对话做出回应，往期会话并不会做记录。也就是没有前后连贯的上下文。
LangChain4j +DeepSeek大模型应用开发——8 Function Calling 函数调用
欢迎来到空说的博客
05-04 522
Function Calling 函数调用也叫Tools 工具`
「LangChain4j入门 — JavaAI程序」
guojiaqi_的博客
12-16 1935
大模型，英文名叫 Large Model，大型模型。早期的时候，也叫 Foundation Model，基础模型。 大模型是一个简称。完整的叫法，应该是 “人工智能预训练大模型”。预训练，是一项技术，我们后面再解释。 我们现在口头上常说的大模型，实际上特指大模型的其中一类，也是用得最多的一类——语言大模型（LargeLanguage Model，也叫大语言模型，简称 LLM）。 除了语言大模型之外，还有视觉大模型、多模态大模型等。现在，包括所有类别在内的大模型合集，被称为广义的大模型。
使用 LangChain 从短暂记忆到持久记忆
2401_85233349的博客
07-23 1391
详细介绍如何将简单的聊天机器人转变为具有长期记忆和上下文理解能力的复杂 AI 助手
LangChain4j -- ChatMemory
weixin_38424523的博客
04-09 477
管理和手动维护是繁琐的工作，因此LangChain4j提供了一个名为ChatMemory的抽象层，以及多个开箱即用的实现。ChatMemory可以用作独立的底层组件，也可以作为高层次组件如AI服务的一部分使用。
LangChain4j学习（二）：持久化、删除聊天记忆
文文的博客
06-24 599
本文介绍了基于Spring Boot和LangChain4j构建带记忆功能的聊天助手的实现步骤。主要包括：1)配置pom.xml依赖(LangChain4j 1.0.1-beta6、Spring Boot 3.3.2)；2)yml文件配置OpenAI参数和MySQL连接；3)创建聊天记忆表存储对话记录；4)定义带有@AiService注解的ChatAssistant接口；5)实现PersistentChatMemoryStore持久化存储类；6)通过ChatMemoryProvider提供记忆管理；7)开发
langchain4j实战：AiServices（chatMemory、chatMemoryProvider）的使用
VivianStark的博客
05-20 1733
本节主要介绍聊天对话内存ChatMemory，由于语言模型不保留对话的状态，因此有必要在与语言模型的每次交互中提供所有先前的消息。有助于跟踪对话并确保消息适合语言模型的上下文窗口。以下示例与大模型交互中，先告诉他“你好，我是小橘”，然后再问他“我叫什么”，看他的问答完全不知道我的名字，明明前面已经告诉大模型了，为啥还不知道呢，这是因为每次执行model.generate方法与大模型交互，相当于打开了一个新的对话窗口，对于大模型来说，没法直接关联到上下文信息。
Langchain4j中Redis 的 memoryStore 实现
weixin_72973409的博客
06-16 180
【代码】Langchain4j中Redis 的 memoryStore 实现。
五、持久化聊天记忆 Persistence
sktlim的博客
05-19 1052
如果需要持久化存储，可以实现一个自定义的聊天记忆存储类，以便将聊天消息存储在你选择的任何持久化存储介质中。大模型中聊天记忆的存储选择哪种数据库，需要综合考虑数据特点、应用场景和性能要求等因素，以下。戳、消息内容等，且需要进行复杂的查询和统计分析，如按用户统计对话次数、按时间范围查。支持事务处理，确保数据的一致性和完整性，适用于结构化数据的存储。：内存数据库，读写速度极高。：当聊天记忆中包含多样化的信息，如文本消息、图片、语音等多媒体数据，或者消。的缩写，是对不同于传统的关系型数据库的数据库管理系统的统称。
langchain4j-(5)-记忆缓存与持久化
最新发布
u010803649的博客
09-15 1320
本文探讨了大模型对话系统中的记忆缓存技术及其实现。记忆缓存通过选择性存储和复用历史对话信息，解决了大模型在多轮对话中存在的上下文遗忘、重复计算和个性化缺失等问题。文章区分了"历史"（完整对话记录）与"记忆"（加工后的上下文信息）的概念，并介绍了两种清除策略：基于消息条数的简单版和基于token数量的精准版。通过LangChain4j框架展示了具体代码实现，包括基本对话缓存和Redis持久化存储方案。实验结果表明，记忆缓存能有效保持对话连贯性，使AI能准确记住用户信息。
LangChain4j记忆缓存+持久化
张同学的博客
07-30 896
本文介绍了聊天系统中记忆缓存的实现方案，提供两种淘汰策略：基于消息数量的MessageWindowChatMemory和基于令牌数量的TokenWindowChatMemory。通过Spring Boot集成LangChain4j框架，演示了如何配置两种记忆缓存策略，并实现多用户上下文隔离的聊天功能。文章包含完整的代码示例，包括依赖引入、配置类定义、控制器实现和测试结果展示，为开发AI聊天系统中记忆缓存功能提供了实用参考。
SpringBoot集成LangChain4j实现AI多轮对话记忆功能
Spring Boot 与 LangChain4j 结合实现多轮对话，即具备记忆功能的聊天系统，是当前人工智能与企业级 Java 应用开发融合的一个典型场景。该示例代码的核心目标在于利用 Spring Boot 的强大后端框架能力，集成 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值