1. 介绍

• 低级API，最原始方法，手动凑齐历史记录提交到大模型
• 低级API，手动把历史记录放入ChatMemory对象
• 低级API，使用ConversationalChain工具，把手动凑齐历史记录的步骤简化掉
• 高级API，实现全局记忆，数据放在内存中
• 高级API，实现为每个用户的记忆，数据放在内存中
• 高级API，实现全局记忆，数据放在数据库
• 高级API，实现为每个用户的记忆，数据放在数据库

2. 准备工作

2.1. 构建项目，添加pom文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.5.0</version>
        <relativePath/>
    </parent>

    <groupId>cn.cjc</groupId>
    <artifactId>springboot-ai</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </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>


        <!-- https://mvnrepository.com/artifact/dev.langchain4j/langchain4j -->
        <!--  LangChain4j 核心库 -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
            <version>1.9.1</version>
        </dependency>
        <!-- AiService依赖 -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-spring-boot-starter</artifactId>
            <version>1.0.1-beta6</version>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-core</artifactId>
            <version>1.9.1</version>
        </dependency>
        <!-- LangChain4j OpenAI支持（可用于通义千问的OpenAI兼容接口） -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
            <version>1.9.1-beta17</version>
        </dependency>
        <!-- 集成原生阿里云通义千问 (DashScope) -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-community-dashscope-spring-boot-starter</artifactId>
            <version>1.9.1-beta17</version>
        </dependency>
        <!--  导入响应式编程依赖包-->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-reactor</artifactId>
            <version>1.9.1-beta17</version>
        </dependency>
        <!--  mapdb-->
        <dependency>
            <groupId>org.mapdb</groupId>
            <artifactId>mapdb</artifactId>
            <version>3.0.9</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>
    </dependencies>
</project>

2.2. 配置文件

spring:
  application:
    name: springboot-ai
  main:
    allow-bean-definition-overriding: true

langchain4j:
  open-ai:
    chat-model:
      api-key: ******
      model-name: qwen-plus
      base-url: https://dashscope.aliyuncs.com/compatible-mode/v1

2.3. 提示词请求类

@Data
public class PromptRequest {
    private String prompt;
    private int userId;
}

3. 低级API

3.1. LangChain4j配置类

@Data
@Configuration
@ConfigurationProperties(prefix = "langchain4j.open-ai.chat-model")
public class LangChain4jConfig {

    private String apiKey;

    private String modelName;

    private String baseUrl;

    /**
     * 创建并配置OpenAiChatModel实例（使用通义千问的OpenAI兼容接口）
     */
    @Bean("openAiChatModel")
    public OpenAiChatModel openAiChatModel() {
        return OpenAiChatModel.builder()
                .apiKey(apiKey)
                .modelName(modelName)
                .baseUrl(baseUrl)
                .build();
    }
}

3.2. 把ChatMessage放入集合

• 这个功能的关键是自己动手，用一个集合记录所有的对话信息，然后每次提问都把新问题放入这个集合，再全部传给大模型

3.2.1. 服务类

@Service
@Slf4j
public class LowChatHistoryService {

    @Autowired
    private OpenAiChatModel openAiChatModel;

    private final List<ChatMessage> history = new ArrayList<>();

    /**
     * 1. 低级API，手动添加原始聊天消息，实现聊天记忆功能
     * @param prompt 模板中的变量
     * @return 助手生成的回答
     */
    public String lowLevelAddRawChatMessage(String prompt) {
        // 每一次的请求都存入历史对象
        history.add(UserMessage.from(prompt));

        // 对话
        AiMessage resp = openAiChatModel.chat(history).aiMessage();

        // 每一次的响应都存入历史对象
        history.add(resp);

        log.info("响应：{}", resp.text());

        return resp.text() + "[from lowLevelAddRawChatMessage]";

    }
}

3.2.2. controller类

@RestController
@RequestMapping("/api/chatHistory")
public class ChatHistoryController {

    @Autowired
    private LowChatHistoryService lowChatHistoryService;

    /**
     * 1. 低级API，把ChatMessage放入集合
     */
    @PostMapping("/lowlevel/addrawchatmessage")
    public ResponseEntity<String> addRawChatMessage(@RequestBody PromptRequest request) {
        String response = lowChatHistoryService.lowLevelAddRawChatMessage(request.getPrompt());
        return ResponseEntity.ok(response);
    }
}

3.3. 把ChatMessage放入ChatMemory

3.3.1. Tools工具类

package cn.cjc.ai.utils;

import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.TokenWindowChatMemory;
import dev.langchain4j.model.openai.OpenAiTokenCountEstimator;

public class Tools {
    /**
     * 创建一个ChatMemory实例，用于存储聊天记忆，存在内存中
     */
    public static ChatMemory createRamChatMemoryInstance() {
        // 设置记忆长度是基于token的，所以这里要根据模型名称设定分词方式
        String modelNameForToken = dev.langchain4j.model.openai.OpenAiChatModelName.GPT_4_O.toString();
        // 可以基于最大token数量来创建，也可以基于最大消息数量来创建，方法是:MessageWindowChatMemory.withMaxMessages(100)
        return TokenWindowChatMemory.withMaxTokens(5000, new OpenAiTokenCountEstimator(modelNameForToken));
    }
}

• ChatMemory有个限制长度的功能，避免了使用List时没有控制长度导致内存不断变大的问题

3.3.2. 服务类

@Service
@Slf4j
public class LowChatHistoryService {

    @Autowired
    private OpenAiChatModel openAiChatModel;

    private ChatMemory chatMemory = null;

    /**
     * 2. 低级API，手动添加ChatMessage到ChatMemory，实现聊天记忆功能
     * @param prompt 模板中的变量
     * @return 助手生成的回答
     */
    public String lowLevelAddChatMessageToChatMemory(String prompt) {
        // 创建一个ChatMemory实例，通过token数量限制记忆长度
        if (null == chatMemory) {
            chatMemory = Tools.createRamChatMemoryInstance();
        }

        // 每一次的请求都存入添加到ChatMemory中
        chatMemory.add(UserMessage.from(prompt));
        // 聊天
        AiMessage answer = openAiChatModel.chat(chatMemory.messages()).aiMessage();
        // 每一次的响应都存入添加到ChatMemory中
        chatMemory.add(answer);

        log.info("响应：{}", answer.text());
        return answer.text() + "[from lowLevelAddChatMessageToChatMemory]";
    }
}

3.3.3. controller类

@RestController
@RequestMapping("/api/chatHistory")
public class ChatHistoryController {

    @Autowired
    private LowChatHistoryService lowChatHistoryService;

    /**
     * 2. 低级API，把ChatMessage放入ChatMemory
     */
    @PostMapping("/lowlevel/addchatmessagetochatmemory")
    public ResponseEntity<String> addChatMessageToChatMemory(@RequestBody PromptRequest request) {
        String response = lowChatHistoryService.lowLevelAddChatMessageToChatMemory(request.getPrompt());
        return ResponseEntity.ok(response);
    }
}

3.4. 基于ConversationalChain的简化

3.4.1. 服务类

@Service
@Slf4j
public class LowChatHistoryService {

    @Autowired
    private OpenAiChatModel openAiChatModel;

    private ConversationalChain chain = null;

    /**
     * 3. 低级API，使用ConversationChain来实现聊天记忆功能
     * @param prompt 模板中的变量
     * @return 大模型生成的回答
     */
    public String lowLevelByConversationChain(String prompt) {
        // 创建一个ChatMemory实例，通过token数量限制记忆长度
        ChatMemory chatMemory = Tools.createRamChatMemoryInstance();

        // 创建一个ConversationChain实例来负责多轮聊天，并且把ChatMemory实例传入用于处理聊天记忆
        if (null == chain) {
            chain = ConversationalChain.builder()
                    .chatModel(openAiChatModel)
                    .chatMemory(chatMemory)
                    .build();
        }

        // 通过chain进行对话
        String answer = chain.execute(prompt);
        log.info("响应：{}", answer);

        return answer + "[from lowLevelByConversationChain]";
    }
}

3.4.2. controller类

@RestController
@RequestMapping("/api/chatHistory")
public class ChatHistoryController {

    @Autowired
    private LowChatHistoryService lowChatHistoryService;

    /**
     * 3. 低级API，基于ConversationalChain的简化
     */
    @PostMapping("/lowlevel/byconversationchain")
    public ResponseEntity<String> byConversationChain(@RequestBody PromptRequest request) {
        String response = lowChatHistoryService.lowLevelByConversationChain(request.getPrompt());
        return ResponseEntity.ok(response);
    }
}

1111

package cn.cjc.ai.service.impl;

import cn.cjc.ai.utils.Tools;
import dev.langchain4j.chain.ConversationalChain;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.model.openai.OpenAiChatModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
@Slf4j
public class LowChatHistoryService {

    @Autowired
    private OpenAiChatModel openAiChatModel;

    private ConversationalChain chain = null;

    /**
     * 3. 低级API，使用ConversationChain来实现聊天记忆功能
     * @param prompt 模板中的变量
     * @return 大模型生成的回答
     */
    public String lowLevelByConversationChain(String prompt) {
        // 创建一个ChatMemory实例，通过token数量限制记忆长度
        ChatMemory chatMemory = Tools.createRamChatMemoryInstance();

        // 创建一个ConversationChain实例来负责多轮聊天，并且把ChatMemory实例传入用于处理聊天记忆
        if (null == chain) {
            chain = ConversationalChain.builder()
                    .chatModel(openAiChatModel)
                    .chatMemory(chatMemory)
                    .build();
        }

        // 通过chain进行对话
        String answer = chain.execute(prompt);
        log.info("响应：{}", answer);

        return answer + "[from lowLevelByConversationChain]";
    }
}

4. 高级API

4.1. ChatHistoryAssistant类

public interface ChatHistoryAssistant {

    String simpleChat(String prompt);

    /**
     * 带记忆的对话，返回助手的回答
     * @param memoryId    记忆ID
     * @param userMessage 用户消息
     * @return 助手生成的回答
     */
    String chatByMemoryId(@MemoryId int memoryId, @UserMessage String userMessage);
}

4.2. 内存存储，全局记忆

4.2.1. 基于配置类新增实例

• 通过AiServices.builder方法生成模式服务代理类的实例，通过chatMemory方法绑定ChatMemory实例，这样就能在对话时把记录存入ChatMemory中

    @Bean("assistantRamGlobal")
    public ChatHistoryAssistant assistantRamGlobal(@Qualifier("openAiChatModel") OpenAiChatModel chatModel) {
        // 创建一个ChatMemory实例，通过token数量限制记忆长度，记录在内存中
        ChatMemory chatMemory = Tools.createRamChatMemoryInstance();

        // 生成Assistant服务实例已经绑定了chatMemory
        return AiServices.builder(ChatHistoryAssistant.class)
                .chatModel(chatModel)
                .chatMemory(chatMemory)
                .build();
    }

4.2.2. 服务类

@Service
@Slf4j
public class HighChatHistoryService {

    @Resource(name = "assistantRamGlobal")
    private ChatHistoryAssistant assistantRamGlobal;

    /**
     * 4. 高级API，基于内存的全局记忆
     *
     * @param prompt
     * @return
     */
    public String highLevelRamGlobal(String prompt) {
        String answer = assistantRamGlobal.simpleChat(prompt);
        log.info("响应：{}",answer);
        return answer + "[from highLevelRamGlobal]";
    }
}

4.2.3. controller类

@RestController
@RequestMapping("/api/chatHistory")
public class ChatHistoryController {

    @Autowired
    private HighChatHistoryService highChatHistoryService;

    /**
     * 4. 高级API，内存存储，全局记忆
     */
    @PostMapping("/highlevel/ram/global")
    public ResponseEntity<String> highLevelRamGlobal(@RequestBody PromptRequest request) {
        // 使用基于内存的全局记忆功能
        String response = highChatHistoryService.highLevelRamGlobal(request.getPrompt());
        return ResponseEntity.ok(response);
    }
}

4.3. 内存存储，指定用户ID

4.3.1. 基于配置类新增实例

• 通过AiServices.builder方法生成模式服务代理类的实例，注意这里调用了chatMemoryProvider方法，而入参是个Lambda表达式，每个memoryId都会创建一个ChatMemory实例

    @Bean("assistantRamById")
    public ChatHistoryAssistant assistantRamById(@Qualifier("openAiChatModel") OpenAiChatModel chatModel) {
        // 注意，这里通过chatMemoryProvider来指定每个id和chatMemory的对应关系，记录在内存中
        return AiServices.builder(ChatHistoryAssistant.class)
                .chatModel(chatModel)
                .chatMemoryProvider(memoryId -> Tools.createRamChatMemoryInstance())
                .build();
    }

4.3.2. 服务类

@Service
@Slf4j
public class HighChatHistoryService {

    @Resource(name = "assistantRamById")
    private ChatHistoryAssistant assistantRamById;

    /**
     * 5. 高级API，基于内存的用户记忆
     * @param userID
     * @param prompt
     * @return
     */
    public String highLevelRamByUserID(int userID, String prompt) {
        String secondAnswer = assistantRamById.chatByMemoryId(userID, prompt);
        log.info("响应：" + secondAnswer);
        return secondAnswer + "[from highLevelRamByUserID]";
    }
}

4.3.3. controller类

@RestController
@RequestMapping("/api/chatHistory")
public class ChatHistoryController {

    @Autowired
    private HighChatHistoryService highChatHistoryService;

    /**
     * 5. 高级API，内存存储，指定用户ID
     */
    @PostMapping("/highlevel/ram/byuserid")
    public ResponseEntity<String> highLevelRamByUserID(@RequestBody PromptRequest request) {
        // 使用基于内存的用户ID记忆功能
        String response = highChatHistoryService.highLevelRamByUserID(request.getUserId(), request.getPrompt());
        return ResponseEntity.ok(response);
    }
}

4.4. 持久化存储，全局记忆

• 由于LangChain4j对持久化的支持是通过接口实现的，因此并未限制具体的方式，这里为了简单用了嵌入式数据库mapdb，亦可按照自己的习惯选择其他数据库，例如MySQL

4.4.1. 新增EmbeddedGlobalDb实现类

• 实现了ChatMemoryStore接口，这样就可以支持聊天持久化能力了，可以看到getMessages、updateMessages、deleteMessages这些方法的具体实现可以随心所欲，这里是对dbmap数据库进行读写，您可以改为其他数据库的操作

package cn.cjc.ai.db;

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.mapdb.DB;

import java.util.List;
import java.util.Map;

public class EmbeddedGlobalDb implements ChatMemoryStore {

    private DB db;
    private Map<String, String> map;

    /**
     * 带Map参数的构造方法，使用用户提供的映射
     * @param map 用户提供的映射实例
     */
    public EmbeddedGlobalDb(DB db, Map<String, String> map) {
        this.db = db;
        this.map = map;
    }

    @Override
    public List<ChatMessage> getMessages(Object memoryId) {
        String json = map.get((String) memoryId);
        return ChatMessageDeserializer.messagesFromJson(json);
    }

    @Override
    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
        String json = ChatMessageSerializer.messagesToJson(messages);
        map.put((String) memoryId, json);
        // 只有当db不为null时才提交事务
        if (db != null) {
            db.commit();
        }
    }

    @Override
    public void deleteMessages(Object memoryId) {
        map.remove((String) memoryId);
        // 只有当db不为null时才提交事务
        if (db != null) {
            db.commit();
        }
    }
}

4.4.2. 增加EmbeddedByIdDb实现类

• 按照用户id保存聊天记录时用到的，也就是下一个功能是才会用到

package cn.cjc.ai.db;

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.mapdb.DB;

import java.util.List;
import java.util.Map;

public class EmbeddedByIdDb implements ChatMemoryStore {

    private DB db;
    private Map<Integer, String> map;

    /**
     * 带Map参数的构造方法，使用用户提供的映射
     * 
     * @param map 用户提供的映射实例
     */
    public EmbeddedByIdDb(DB db, Map<Integer, String> map) {
        this.db = db;
        this.map = map;
    }

    @Override
    public List<ChatMessage> getMessages(Object memoryId) {
        String json = map.get((int) memoryId);
        return ChatMessageDeserializer.messagesFromJson(json);
    }

    @Override
    public void updateMessages(Object memoryId, List<ChatMessage> messages) {
        String json = ChatMessageSerializer.messagesToJson(messages);
        map.put((int) memoryId, json);
        // 只有当db不为null时才提交事务
        if (db != null) {
            db.commit();
        }
    }

    @Override
    public void deleteMessages(Object memoryId) {
        map.remove((int) memoryId);
        // 只有当db不为null时才提交事务
        if (db != null) {
            db.commit();
        }
    }
}

4.4.3. 基于Tools类新增静态方法

• 增加一个静态方法createStoreInstance，用于封装ChatMemoryStore实例的创建过程。
• 再增加一个静态方法createDbChatMemoryInstance，作用是创建ChatMemory实例，在创建时通过chatMemoryStore方法把前面的ChatMemoryStore传入，这样一来，往ChatMemory传入的对话记录就会被持久化到数据库中。也就是说，静态方法可以创建一个具有持久化能力的ChatMemory实例

package cn.cjc.ai.utils;

import cn.cjc.ai.db.EmbeddedByIdDb;
import cn.cjc.ai.db.EmbeddedGlobalDb;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.memory.chat.TokenWindowChatMemory;
import dev.langchain4j.model.openai.OpenAiTokenCountEstimator;
import dev.langchain4j.store.memory.chat.ChatMemoryStore;
import org.mapdb.DB;
import org.mapdb.DBMaker;

import java.util.Map;

import static org.mapdb.Serializer.INTEGER;
import static org.mapdb.Serializer.STRING;

public class Tools {

    /**
     * 创建一个ChatMemoryStore实例，用于存储聊天记忆，存在数据库中
     * @return ChatMemoryStore实例
     */
    public static ChatMemoryStore createStoreInstance(String dbName, boolean isById) {
        ChatMemoryStore rlt = null;
        // 创建一个MapDB实例，用于存储聊天记忆
        DB db = DBMaker.fileDB(dbName).transactionEnable().make();
        if (isById) {
            Map<Integer, String> dbMap = db.hashMap("messages", INTEGER, STRING).createOrOpen();
            rlt = new EmbeddedByIdDb(db, dbMap);
        } else {
            Map<String, String> dbMap = db.hashMap("messages", STRING, STRING).createOrOpen();
            rlt = new EmbeddedGlobalDb(db, dbMap);
        }
        return rlt;
    }

    /**
     * 创建一个ChatMemory实例，用于存储聊天记忆，存在数据库中
     * @return ChatMemory实例
     */
    public static ChatMemory createDbChatMemoryInstance(String dbName, boolean isById) {
        // 创建一个MapDB实例，用于存储聊天记忆
        ChatMemoryStore store = createStoreInstance(dbName, isById);
        return MessageWindowChatMemory
                .builder()
                .maxMessages(100)
                .chatMemoryStore(store)
                .build();
    }
}

4.4.4. 基于配置类新增实例

• 通过AiServices.builder方法生成了模式服务代理类的实例，通过chatMemory方法绑定ChatMemory实例，且ChatMemory实例具备持久化保存对话记录的能力

    @Bean("assistantDbGlobal")
    public ChatHistoryAssistant assistantDbGlobal(@Qualifier("openAiChatModel") OpenAiChatModel chatModel) {
        // 创建一个ChatMemory实例，通过消息数量限制记忆长度，记录在数据库中
        ChatMemory chatMemory = Tools.createDbChatMemoryInstance("chat-memory-global.db", false);

        // 生成Assistant服务实例已经绑定了chatMemory
        return AiServices.builder(ChatHistoryAssistant.class)
                .chatModel(chatModel)
                .chatMemory(chatMemory)
                .build();
    }

4.4.5. 服务类

@Service
@Slf4j
public class HighChatHistoryService {

    @Resource(name = "assistantDbGlobal")
    private ChatHistoryAssistant assistantDbGlobal;

    /**
     * 6. 高级API，基于数据库的全局记忆
     */
    public String highLevelDbGlobal(String prompt) {
        String secondAnswer = assistantDbGlobal.simpleChat(prompt);
        log.info("响应：" + secondAnswer);
        return secondAnswer + "[from highLevelDbGlobal]";
    }
}

4.4.6. controller类

@RestController
@RequestMapping("/api/chatHistory")
public class ChatHistoryController {

    @Autowired
    private HighChatHistoryService highChatHistoryService;

    /**
     * 6. 高级API，持久化存储，全局记忆
     */
    @PostMapping("/highlevel/db/global")
    public ResponseEntity<String> highLevelDbGlobal(@RequestBody PromptRequest request) {
        // 使用基于数据库的全局记忆功能
        String response = highChatHistoryService.highLevelDbGlobal(request.getPrompt());
        return ResponseEntity.ok(response);
    }
}

4.5. 持久化存储，指定用户ID

4.5.1. 基于配置类新增实例

• 首先创建ChatMemoryProvider对象，根据不同用户id分别生成具有持久化能力的ChatMemory对象，最后通过AiServices.builder来创建模型服务的代理类实例

    @Bean("assistantDbById")
    public ChatHistoryAssistant assistantDbById(@Qualifier("openAiChatModel") OpenAiChatModel chatModel) {
        ChatMemoryStore chatMemoryStore = Tools.createStoreInstance("chat-memory-byid.db", true);

        ChatMemoryProvider chatMemoryProvider = memoryId -> MessageWindowChatMemory.builder()
                .id(memoryId)
                .maxMessages(100)
                .chatMemoryStore(chatMemoryStore)
                .build();

        // 生成Assistant服务实例已经绑定了chatMemory
        return AiServices.builder(ChatHistoryAssistant.class)
                .chatModel(chatModel)
                .chatMemoryProvider(chatMemoryProvider)
                .build();
    }

4.5.2. 服务类

@Service
@Slf4j
public class HighChatHistoryService {

    @Resource(name = "assistantDbById")
    private ChatHistoryAssistant assistantDbById;

    /**
     * 7. 高级API，基于数据库的用户记忆
     * @param userID
     * @param prompt
     * @return
     */
    public String highLevelDbByUserID(int userID, String prompt) {
        String answer = assistantDbById.chatByMemoryId(userID, prompt);
        log.info("响应：" + answer);
        return answer + "[from highLevelDbByUserID]";
    }
}

4.5.3. controller类

@RestController
@RequestMapping("/api/chatHistory")
public class ChatHistoryController {

    @Autowired
    private HighChatHistoryService highChatHistoryService;

    /**
     * 7.高级API，持久化存储，指定用户ID
     */
    @PostMapping("/highlevel/db/byuserid")
    public ResponseEntity<String> highLevelDbByUserID(@RequestBody PromptRequest request) {
        // 使用基于数据库的用户ID记忆功能
        String response = highChatHistoryService.highLevelDbByUserID(request.getUserId(), request.getPrompt());
        return ResponseEntity.ok(response);
    }
}