1、概述

        在智能化转型的浪潮下，很多小伙伴开始卷大模型应用开发相关的方向，本着认真工作(摸鱼划水)的目的，我也学习了一下相关的内容，今天就给大家分享一下如何在我们的项目中快速的接入AI大模型，我们先从Langchain4j 的基本使用开始，逐步的完成一个具备聊天记忆的AI智能助手应用。

2、Langchain4j 快速入门

2.1.1、Langchain4j get-started

        首先我们先别管这玩意儿是什么，咱们搞个入门案例 先跑起来，试试是什么效果，我们再去聊它是什么，能做什么。我们直接看官方文档  LangChain4j | LangChain4j 

我们直接看 get-started 页面，如下所示：

这个页面上描述的是 如何创建一个 Maven 工程 集成 langchain4j 。

 2.1.2、Langchain4j 入门案例

我们根据官方入门案例的描述 来创建一个Maven 工程，首先依赖信息如下

 <dependencies>
        <!-- 基于open-ai 规范的langchain4j接口 -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai</artifactId>
            <version>1.0.0-beta3</version>
        </dependency>
    </dependencies>

 接着我们官网上copy 一段代码下来

我们先建一个类，将上述代码复制进去

package org.wcan.lc4j;

import dev.langchain4j.model.openai.OpenAiChatModel;

/**
 * @Description
 * @Author wcan
 * @Date 2025/4/30 下午 17:15
 * @Version 1.0
 */
public class DemoOne {
    public static void main(String[] args) {

        OpenAiChatModel model = OpenAiChatModel.builder()
                .baseUrl("http://langchain4j.dev/demo/openai/v1")
                .apiKey("demo")
                .modelName("gpt-4o-mini")
                .build();

        //向模型提问
        String answer = model.chat("Say 'Hello World'");
        System.out.println(answer); // Hello World
    }
}

 我们运行上述代码，发现控制台打印出了 hello world 了。

好吧，通过这段代码也不能让你体验到 Langchain4j 是什么，能做什么。接下来我们可以修改一下上面的内容。

    public static void main(String[] args) {
        OpenAiChatModel model = OpenAiChatModel.builder()
                .baseUrl("http://langchain4j.dev/demo/openai/v1")
                .apiKey("demo")
                .modelName("gpt-4o-mini")
                .build();

        //向模型提问
        String answer = model.chat("你是谁丫，详细的介绍一下你");
        System.out.println(answer);
    }

 运行上述代码，观察控制台，我们看打印出来的结果 是不是能看得出来，这玩意其实是和大模型交互的一个Java 客户端工具啊，我们姑且先这么理解。

2.1.3、Langchain4j 简介

前面我们根据官网的文档描述，编写了一个简单的入门案例，相信你可能有点感觉了，接下来我们就来简单介绍下 Langchain4j 是什么，能做什么以及出现的背景和主要解决什么问题。

en,头大了，真不上写这些没有意义的文字，，，，前面我们 既然它能和GPT交互，那我们也可以直接GPT吧 。修改一下chat 方法的入参

String answer = model.chat("我现在很想知道 Langchain4j 是什么，能做什么，出现的背景以及它主要是为了解决什么问题");

运行main函数后我们看控制台输出的信息

好家伙，输出的真详细，嗯，，，大家自己看吧。

2.1.4、入门总结 

        还是给大家总结一下吧

 3、集成SpringBoot

3.1、搭建项目环境

        绝大多数Java程序员其实就是Spring程序员，所以在我们入门了之后就需要研究一下 怎么和Spring集成了，首先肯定还是看文档  Spring Boot Integration | LangChain4j

https://docs.langchain4j.dev/tutorials/spring-boot-integration

 我们先创建一个SpringBoot 项目，相关依赖如下


    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-boot.version>3.2.6</spring-boot.version>
        <langchain4j.version>1.0.0-beta3</langchain4j.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>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>
  </dependencies>


 <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>dev.langchain4j</groupId>
                <artifactId>langchain4j-bom</artifactId>
                <version>${langchain4j.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

 接着编写一个启动类

package org.wcan.lc4j;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @ClassName LangchainApplication
 * @Description TODO
 * @Author wcan
 * @Date 2025/4/30 下午 17:56
 * @Version 1.0
 */
@SpringBootApplication
public class LangchainApplication {
    public static void main(String[] args) {
        SpringApplication.run(LangchainApplication.class,args);
    }
}

 然后就是配置文件了，我们需要新建一个配置文件，配置文件的内容参考官方文档。

server.port=9000

langchain4j.open-ai.chat-model.base-url=http://langchain4j.dev/demo/openai/v1
langchain4j.open-ai.chat-model.api-key=demo
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini

#请求和响应日志
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true
#启用日志debug级别
logging.level.root=debug

 3.2、编写对话业务

        我们新建一个Controller，主要功能是获取请求参数传过来的问题，将问题转发给 gpt,最后将gpt 返回的结果当成响应参数 返回。

package org.wcan.lc4j.controller;

import dev.langchain4j.model.openai.OpenAiChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * @Description
 * @Author wcan
 * @Date 2025/4/30 下午 18:09
 * @Version 1.0
 */
@RestController
@RequestMapping("/langchain4j")
public class LangChainController {

    @Autowired
    private OpenAiChatModel openAiChatModel;

    @GetMapping("/chat")
    public Map<String, Object> chat(@RequestParam("question")String question) {
        Map<String, Object> retMap = new HashMap<String, Object>();
        String answer = openAiChatModel.chat(question);
        //输出结果
        System.out.println(answer);
        retMap.put("answer",answer);
        return retMap;
    }
}

3.3、对话功能测试

启动项目，我们使用工具测试，我们可以在这里提问了。

4、聊天记忆

4.1、什么是聊天记忆

          下面这张图是我使用gpt 提问的对话内容，我一共问了两个问题

从上图中我们不难的发现 GPT 其实是有聊天记忆功能的，我连续问了两个问题，gpt 是知道我之前问的问题内容的，那么我们接下来试试 我们自己开发的对话业务 是否具备对应的功能呢

回到测试工具，我们先提出第一个问题

 接着我们提出第二个问题

看着似乎它并不具备聊天记忆的功能。 

4.2、实现聊天记忆

   我们先不解释，直接上代码，先看效果再聊原理，首先我们引入依赖

       <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
        </dependency>

这个依赖也是来源于官方文档，按照官网上的说法是这个 starter  功能更全,并且有更高级的功能类。

接着新建一个接口，相关内容如下：

package org.wcan.lc4j.assistant;

import dev.langchain4j.service.spring.AiService;

import static dev.langchain4j.service.spring.AiServiceWiringMode.EXPLICIT;

@AiService(wiringMode = EXPLICIT,
        chatModel = "openAiChatModel",
        chatMemory = "chatMemory")
public interface Assistant {
    String chat(String userMessage);
}

接着我们需要定义一个配置类，在这个配置类中我们初始化一个 ChatMemory 对象。


package org.wcan.lc4j.config;

import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MemoryChatAssistantConfig {

    @Bean
    ChatMemory chatMemory() {
        return MessageWindowChatMemory.withMaxMessages(10);
    }
}

关于 ChatMemory 从字面意思上理解就是 聊天记忆，具体的作用就是维护多条聊天记录。

由于我们手动维护和管理ChatMessages很麻烦。因此，LangChain4j提供了一个ChatMemory抽象以及多个开箱即用的实现。ChatMemory可以用作独立的低级组件，也可以用作像AI Services这样的高级组件的一部分。

https://docs.langchain4j.dev/tutorials/chat-memory
Maintaining and managing ChatMessages manually is cumbersome. Therefore, LangChain4j offers a ChatMemory abstraction along with multiple out-of-the-box implementations.

ChatMemory can be used as a standalone low-level component, or as a part of a high-level component like AI Services.

ChatMemory acts as a container for ChatMessages (backed by a List), with additional features like:

最后我们在 LangChainController 里面加入下面的代码

    @Autowired
    private Assistant assistant;


    @GetMapping("/assistantChat")
    public Map<String, Object> assistantChat(@RequestParam("question")String question) {
        Map<String, Object> retMap = new HashMap<String, Object>();
        String answer = assistant.chat(question);
        retMap.put("answer",answer);
        return retMap;
    }

4.3、功能测试

重新启动项目，我们使用工具测试聊天记忆功能

第二次请求 

 我们发现已经实现了聊天记忆的功能了。

5、AIService

5.1、什么是AiService

前面我们使用了一个 @AiService 注解，在这个注解中我们指定了 chatModel 和 chatMemory两个属性，这么些有什么目的呢，我们还是去官网上找答案

https://docs.langchain4j.dev/tutorials/ai-services

从官方的描述上来看 ChatLanguageModel、ChatMessage、ChatMemory 这些都是 low-level 的组件，你可以很灵活的去使用，但是往往需要编写大量的模板代码，并且我们的 AI应用 通常涉及多个交互，因此编排它们就会变得更加繁琐，很显然这不是一个好的设计。

对于上述场景，Langchain4j中提供了两种解决方案，一种是 chain 另外一种是 AIService。

关于 Chain 看官方的意思是不打算继续扩展了，所以我们重点来学习AiSevice  

官方的说法  AI Service 是专门为Java 准备的， 设计思路和 SpringDataJPA或Reform非常相似。也就是说我们可以声明一个接口，然后 LangChain4j 提供一个实现该接口的对象（代理）来实现具体的细节功能。

官网上还提供了一个入门案例，其实上个章节我们实现聊天记忆就是参照这个入门案例实现的。

 5.2、AI Service 能做什么

        按照官方文档上的描述  

 它可以 格式化LLM 的输入以及 解析LLM的输出，以及 聊天记忆 可以用于构建有状态的聊天机器人，以促进来回交互，并自动化对LLM的每次调用都是隔离的流程。

5.3、案例实战 - 聊天记忆隔离

5.3.1、聊天记忆存在的问题

字面意思就是 多个用户访问应用的时候 聊天记忆是相互隔离的，我们先来看看现状，我们使用测试工具发送一个问题

接着我们打开浏览器 模拟第二个用户 

我们发现第二个用户询问的时候 我们的应用返回了第一个用户问的问题。 这个时候假如第一个用户继续提问

好巧不巧 第二个用户继续提问 

假如第一个用户问 刚刚问了什么问题

很显然返回的信息 串用户了。

5.3.2、聊天记忆隔离实现

按照之前实现聊天记忆的步骤，我们需要新建一个接口，用来定义聊天记忆隔离的方法

package org.wcan.lc4j.assistant;

import dev.langchain4j.service.MemoryId;
import dev.langchain4j.service.UserMessage;
import dev.langchain4j.service.spring.AiService;

import static dev.langchain4j.service.spring.AiServiceWiringMode.EXPLICIT;

/**
 * @ClassName SeparateChatAssistant
 * @Description TODO
 * @Author wcan
 * @Date 2025/4/30 下午 23:25
 * @Version 1.0
 */
@AiService(
    wiringMode = EXPLICIT,
    chatMemory = "chatMemory",
        chatModel = "openAiChatModel",
    chatMemoryProvider = "chatMemoryProvider"
)
public interface SeparateChatAssistant {

    /**
     * 聊天记录隔离
     * @param memoryId 聊天id
     * @param userMessage 用户消息
     * @return
     */
    String chat(@MemoryId int memoryId, @UserMessage String userMessage);
}

接着我们要编写一个配置，放在配置类中


package org.wcan.lc4j.config;

import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.ChatMemoryProvider;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MemoryChatAssistantConfig {

    /**
    * @Description 聊天记忆组件
    * @Param []
    * @return dev.langchain4j.memory.ChatMemory
    * @Date 2025/4/30 下午 23:26
    * @Author wcan
    * @Version 1.0
    */
    @Bean
    ChatMemory chatMemory() {
        return MessageWindowChatMemory.withMaxMessages(10);
    }

    /**
    * @Description 聊天记忆隔离组件
    * @Param []
    * @return dev.langchain4j.memory.chat.ChatMemoryProvider
    * @Date 2025/4/30 下午 23:26
    * @Author wcan
    * @Version 1.0
    */
    @Bean
    ChatMemoryProvider chatMemoryProvider() {
        return memoryId -> MessageWindowChatMemory.builder()
                .id(memoryId)
                .maxMessages(10)
                .build();
    }
}

 最后就是我们的业务层的代码了，我们继续再 LangChainController 添加以下代码

 @Autowired
    private SeparateChatAssistant separateChatAssistant;

    @GetMapping("/separateChat")
    public Map<String, Object> separateChat(@RequestParam("id")Integer id,@RequestParam("question")String question) {
        Map<String, Object> retMap = new HashMap<String, Object>();
        String answer = separateChatAssistant.chat(id,question);
        retMap.put("answer",answer);
        return retMap;
    }

我们再入参列表中需要多传入一个用户标识的字段，这里为了简单起见直接叫 id .至此我们的聊天记忆隔离功能已经开发完成

5.3.3、功能测试

 用户1 提问  

用户2 提问

用户1 继续询问 刚才问题问了什么问题

这个结果是对的，我们再看看用户2的询问

好了多用户之间的聊天记忆隔离我们也实现了。

5.4、聊天记忆存储原理分析

        我们来看下之前的案例中 聊天记忆是怎么存储的，可以直接看 SingleSlotChatMemoryStore 这个类，

 从这个类的注释信息中我们可以了解到  ChatMemory（聊天信息）在内存中。这种存储机制是暂时的，在应用程序重启后 保存数据都会丢失。这个类中的代码也很简单，我们这几个方法上 打上断点可以调试进来。

那我是怎么找到这个类的呢？其实也很简单，我们的入口毫无疑问肯定是在我们编写的配置类中注入 ChatMemoryProvider 对象的地方

这里我们进入 build 方法内部， 方法签名如下：

dev.langchain4j.memory.chat.MessageWindowChatMemory.Builder#build

这个方法创建了一个 MessageWindowChatMemory 对象，构造器传入了一个 Builder 对象，我们点进去看 MessageWindowChatMemory 类的代码，就会发现 ChatMemoryStore 组件是作为一个成员集成到了 MessageWindowChatMemory 里面了。

 从代码注释的最后一行内容我们可以知道 默认的实现是 SingleSlotChatMemoryStore。现在已经捋清楚了这个源码的过程了，你就可以自己调试了。

5.5、ChatMemoryStore

      前面我们知道了 聊天记忆都是存储在内存中的，默认的实现是 SingleSlotChatMemoryStore，它实现了 ChatMemoryStore 接口，这个接口中定义了基本的几个维护聊天记忆列表的方法。下面是这个接口的类图

这个接口中一个有三个方法，分别是 获取聊天记忆 更新聊天记忆以及删除聊天记忆，从注释信息中可以了解到，我们可以实现这个接口，根据自己的策略实现自己的保存策略。 

换而言之，这个接口是 Langchain4j 留下的扩展，我们想想 为什么需要自己实现呢？

很显然，我们保存的聊天记忆是存在内存中的，也就是说 一旦程序重启后，之前的记忆全部都丢失了，这对于一个应用来说很尴尬，每次都要重新认识。其次，我们如果是分布式架构，当我们的软件包部署在不同的节点上，那么每个节点都维护自己的本地内存，不同的节点上保存的聊天记忆也会出现断片的问题。

这两点原因，就有足够的理由让我们去自定义实现聊天记忆保存的逻辑了。

6、Persistence

6.1、持久化存储技术选型

关于持久化存储的方案，官方文档上也有详细的说明，我们可以参考这个章节

https://docs.langchain4j.dev/tutorials/chat-memory

根据上面的描述 默认情况下，ChatMemory实现将ChatMessages存储在内存中。如果需要持久性，可以实现自定义ChatMemoryStore，将 ChatMessages 存储在您选择的任何持久性存储中。

所谓的持久性存储 你可以理解成 关系型数据库或者是文件系统，这里我们考虑到 聊天记忆中包含多样化的信息，如文本消息、图片、语音等甚至是其他的非结构化的数据，换而言之即使 消息格式不固定，并且会频繁变化，毫无疑问首选 mongoDB。

6.2、MongoDB 环境准备

我们使用docker 快速的搭建好 MongoDB 的运行环境

docker pull mongo:5.0
docker run --name mongo:5.0  \
-d  \
-p 9030:27017 \
-v /opt/dataDir/mogdb:/data/db \
mongo

运行上述命令，查看 mongodb 进程

MongoDB 启动完成后可以使用客户端工具连接

 mongodb://ip:端口

eg: mongodb://192.168.200.101:9000

同样的我们也可以使用 图形界面工具

相关工具的下载链接

命令行工具
https://www.mongodb.com/try/download/shell
图形界面工具
https://www.mongodb.com/try/download/compass

6.3、SpringBoot集成 MongoDB

接下来我们使用SpringBoot 整合 MongoDB，首先添加依赖包

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

接着需要配置 MongoDB 的连接信息，直接在application.properties 文件中添加以下内容

spring.data.mongodb.uri=mongodb://192.168.11.100:9030/gpt-4o-mini_memory_db

 创建每次会话记忆的实体类

package org.wcan.lc4j.entity;

import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document("gpt_messages")
public class ChatMessages {

    @Id
    private ObjectId messageId;

    private String memoryId;
    private String content;

    public ObjectId getMessageId() {
        return messageId;
    }

    public void setMessageId(ObjectId messageId) {
        this.messageId = messageId;
    }

    public String getMemoryId() {
        return memoryId;
    }

    public void setMemoryId(String memoryId) {
        this.memoryId = memoryId;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

本篇文章主要不是讲解MongoDB,为了方便起见我们直接使用Spring Data 中的 mongoTemplate。下面我们先来编写一个测试的Controller，测试下连接 MongoDB 是否成功

package org.wcan.lc4j.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.wcan.lc4j.entity.ChatMessages;

import java.util.HashMap;
import java.util.Map;

/**
 * @ClassName MongoTestController
 * @Description TODO
 * @Author wcan
 * @Date 2025/5/7 下午 22:02
 * @Version 1.0
 */
@RestController
@RequestMapping("/mongo")
public class MongoTestController {

    @Autowired
    private MongoTemplate mongoTemplate;

    @GetMapping("/saveChat")
    public Map<String, Object> separateChat(@RequestParam("id")Integer id,@RequestParam("question")String question) {
        Map<String, Object> retMap = new HashMap<String, Object>();
        ChatMessages chatMessages = new ChatMessages();
        chatMessages.setMessage(question);
        chatMessages.setMemoryId(String.valueOf(id));
        mongoTemplate.insert(chatMessages);
        retMap.put("flag",0);
        return retMap;
    }

    @GetMapping("/getChat")
    public Map<String, Object> assistantChat(@RequestParam("id")Integer id) {
        Map<String, Object> retMap = new HashMap<String, Object>();
        Criteria criteria = Criteria.where("memoryId").is(id);
        Query query = new Query(criteria);
        ChatMessages chatMessages = mongoTemplate.findOne(query, ChatMessages.class);
        retMap.put("chatMessages",chatMessages);
        return retMap;
    }
}

 启动服务，我们使用工具测试

然后查看MongoDB 中的数据

好了，MongoDB的环境搭建完成。

6.4、聊天记忆持久化实现 

        我们按照之前的分析，自定义一个类实现 ChatMemoryStore 接口，将聊天以及存储到 MongoDB中，思路其实很简单，无非就是将 mongoTemplate 注入到 ChatMemoryStore，然后基于 mongoTemplate 将 聊天内容存到MongoDB 中，相关代码如下

package org.wcan.lc4j.store;

import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.ChatMessageDeserializer;
import dev.langchain4j.data.message.ChatMessageSerializer;
import dev.langchain4j.store.memory.chat.ChatMemoryStore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Component;
import org.wcan.lc4j.entity.ChatMessages;

import java.util.LinkedList;
import java.util.List;

@Component
public class MongoChatMemoryStore implements ChatMemoryStore {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public List<ChatMessage> getMessages(Object memoryId) {
        Criteria criteria = Criteria.where("memoryId").is(memoryId);
        Query query = new Query(criteria);
        ChatMessages chatMessages = mongoTemplate.findOne(query, ChatMessages.class);
        if(chatMessages == null)
            return new LinkedList<>();
        return ChatMessageDeserializer.messagesFromJson(chatMessages.getMessage());
    }

    @Override
    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
        Criteria criteria = Criteria.where("memoryId").is(memoryId);
        Query query = new Query(criteria);
        Update update = new Update();
        update.set("content", ChatMessageSerializer.messagesToJson(messages));
        //根据query条件能查询出文档，则修改文档；否则新增文档
        mongoTemplate.upsert(query, update, ChatMessages.class);
    }

    @Override
    public void deleteMessages(Object memoryId) {
        Criteria criteria = Criteria.where("memoryId").is(memoryId);
        Query query = new Query(criteria);
        mongoTemplate.remove(query, ChatMessages.class);
    }
}

接着需要在配置类中 注入 MongoChatMemoryStore 


package org.wcan.lc4j.config;

import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.ChatMemoryProvider;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.wcan.lc4j.store.MongoChatMemoryStore;

@Configuration
public class MemoryChatAssistantConfig {

    /**
    * @Description 聊天记忆组件
    * @Param []
    * @return dev.langchain4j.memory.ChatMemory
    * @Date 2025/4/30 下午 23:26
    * @Author wcan
    * @Version 1.0
    */
    @Bean
    ChatMemory chatMemory() {
        return MessageWindowChatMemory.withMaxMessages(10);
    }

    /**
    * @Description 聊天记忆隔离组件
    * @Param []
    * @return dev.langchain4j.memory.chat.ChatMemoryProvider
    * @Date 2025/4/30 下午 23:26
    * @Author wcan
    * @Version 1.0
    */
//    @Bean
//    ChatMemoryProvider chatMemoryProvider() {
//        return memoryId -> MessageWindowChatMemory.builder()
//                .id(memoryId)
//                .maxMessages(10)
//                .build();
//    }

    //注入持久化对象
    @Autowired
    private MongoChatMemoryStore mongoChatMemoryStore;

    @Bean
    ChatMemoryProvider chatMemoryProvider() {
        return memoryId -> MessageWindowChatMemory.builder()
                .id(memoryId)
                .maxMessages(10)
                .chatMemoryStore(mongoChatMemoryStore)//配置持久化对象
                .build();
    }
}

最后我们启动项目即可进行测试

我们查看 MongoDB 中的数据

 我们重启应用后 也可以接着上次的聊天内容继续聊。大家可以自行测试。

7、总结

        本篇文章 主要介绍了 Langchain4j 的基础概念和基本用法以及Langchain4j 中的高阶API 。结合官方文档以及多个代码案例，介绍如何快速的将 AI大模型 集成到自己的应用里，最后提供了一种持久化聊天记忆的解决方案，希望对大家有帮助。

# java # AIGC
Logo
EazyDevelop社区

一站式 AI 云服务平台

更多推荐

cover

国内低代码平台：2025 年国内主流平台盘点

avatar EazyDevelop社区
cover

从零开始搭建个人RAG知识库：RAGFlow+DeepSeek保姆级教程！

avatar EazyDevelop社区
cover

5分钟搞定！MySQL/PostgreSQL 到 Elasticsearch 的实时同步

avatar EazyDevelop社区