欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

LangChain4j实战全系列链接

  1. 准备工作
  2. 极速开发体验
  3. 细说聊天API
  4. 集成到spring-boot
  5. 图像模型
  6. 聊天记忆，低级API版

本篇概览

  • 本篇是《LangChain4j实战》系列的第六篇文章，经过了前面的整体学习，咱们对LangChain4j的基本能力已经有了一定了解，接下来就该针对LangChain4j的一些重要功能逐个学习了，首先要学的是聊天记忆功能，一共有两篇文章来学习此功能，本篇是第一篇，关注如何用低级API实现
  • 接下来会先简单说说什么是记忆功能，然后创建一个spring-boot工程，在里面创建几个接口用来体验不同方法实现的记忆功能，最后把工程运行起来看实际效果

关于记忆功能

  • 关于记忆功能的作用，咱们来看个对话场景，调用了最简单的大模型chat接口来完成
第一次提问：介绍一下曹操
大模型回答：曹操（155年－220年），字孟德，小名阿瞒，沛国谯县（今安徽亳州）人，是中国东汉末年杰出的政治家、军事家、文学家、书法家

第二次提问：他的对手有哪些？
大模型回答：你好！你提到“他的对手”，但没有具体说明是哪位人物
  • 可见，对于第二次的问题，大模型不知道"他"是谁，也就是说它在回答时完全不知道前面聊过曹操
  • 解决记忆问题的办法是让大模型知道前面的聊天记录，针对次需求LangChain4j给我们提供了多种工具，这里把它们全部梳理出来，如下图所示，可见低级API和高级API都能实现聊天记忆功能
    在这里插入图片描述
  • 虽然有多种方法实现聊天记忆，但是它们也各有优缺点，低级API把串联功能完全交给开发者，可以随意扩展，甚至可以修改原先的聊天记录内容，而高级API则可以简化代码，让开发者以极低的成本实现多轮对话
  • 接下来编码体验这些能力，将按照如下步骤进行
  1. 调整父工程，这是整个系列的父工程，把本篇要新建的子工程添加到父工程中，以及新增的依赖库
  2. 新建子工程
  3. 开发和运行，低级API，最原始方法，手动凑齐历史记录提交到大模型
  4. 开发和运行，低级API，手动把历史记录放入ChatMemory对象
  5. 开发和运行，低级API，使用ConversationalChain工具，把手动凑齐历史记录的步骤简化掉
  6. 开发和运行，高级API，实现全局记忆，数据放在内存中
  7. 开发和运行，高级API，实现为每个用户的记忆，数据放在内存中
  8. 开发和运行，高级API，实现全局记忆，数据放在数据库
  9. 开发和运行，高级API，实现为每个用户的记忆，数据放在数据库
  • 由于代码量太大，本篇只给出低级API的代码，也就是1-5，高级API放在下一篇，要是都写在一篇中就太多了，我写着累您看着也累

源码下载（觉得作者啰嗦的，直接在这里下载）

  • 如果您只想快速浏览完整源码，可以在GitHub下载代码直接运行，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：
名称 链接 备注
项目主页 https://github.com/zq2599/blog_demos 该项目在GitHub上的主页
git仓库地址(https) https://github.com/zq2599/blog_demos.git 该项目源码的仓库地址，https协议
git仓库地址(ssh) git@github.com:zq2599/blog_demos.git 该项目源码的仓库地址，ssh协议
  • 这个git项目中有多个文件夹，本篇的源码在langchain4j-tutorials文件夹下，如下图红色箭头所示：
    在这里插入图片描述

编码：父工程调整

  • 《准备工作》中创建了整个《LangChain4j实战》系列代码的父工程，本篇实战会在父工程下新建一个子工程，所以这里要对父工程的pom.xml做少量修改

  1. 增加一个自定义变量mapdb.version，这样可以把所有依赖库的版本号集中起来管理，如下图黄框所示
    在这里插入图片描述

  2. 增加嵌入式数据库mapdb的依赖，如下图黄框所示，它是用来通过数据库来保存对话记录，避免了内存保存时的丢失风险
    在这里插入图片描述

  3. modules中增加一个子工程，如下图黄框所示
    在这里插入图片描述

编码：新增子工程

  • 新增名为memory的子工程
  1. langchain4j-totorials目录下新增名memory为的文件夹
  2. memory文件夹下新增pom.xml，内容如下
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.bolingcavalry</groupId>
        <artifactId>langchain4j-totorials</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>memory</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <!-- Spring Boot Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Spring Boot Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- JUnit Jupiter Engine -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- Mockito Core -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- Mockito JUnit Jupiter -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!-- LangChain4j Core -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-core</artifactId>
        </dependency>
        
        <!-- LangChain4j OpenAI支持（用于通义千问的OpenAI兼容接口） -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai</artifactId>
        </dependency>

        <!-- 官方 langchain4j（包含 AiServices 等服务类） -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j</artifactId>
        </dependency>

        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-community-dashscope</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mapdb</groupId>
            <artifactId>mapdb</artifactId>
        </dependency>

        <!-- langchain4j 1.x版本中的服务功能已包含在core模块中 -->
        
        <!-- 日志依赖由Spring Boot Starter自动管理，无需单独声明 -->
    </dependencies>

    <build>
        <plugins>
            <!-- Spring Boot Maven Plugin -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>3.3.5</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
  1. 在langchain4j-totorials/memory/src/main/resources新增配置文件application.properties，内容如下，主要是三个模型的配置信息，记得把your-api-key换成您自己的apikey
# Spring Boot 应用配置
server.port=8080
server.servlet.context-path=/

# LangChain4j 使用OpenAI兼容模式配置通义千问模型
# 注意：请将your-api-key替换为您实际的通义千问API密钥
langchain4j.open-ai.chat-model.api-key=your-api-key
# 通义千问模型名称
langchain4j.open-ai.chat-model.model-name=qwen3-max
# 阿里云百炼OpenAI兼容接口地址
langchain4j.open-ai.chat-model.base-url=https://dashscope.aliyuncs.com/compatible-mode/v1

# 日志配置
logging.level.root=INFO
logging.level.com.bolingcavalry=DEBUG
logging.pattern.console=%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
# 应用名称
spring.application.name=memory
  1. 新增启动类，依旧平平无奇
package com.bolingcavalry;

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

/**
 * Spring Boot应用程序的主类
 */
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
  • 现在新的子工程已经创建好了，接下来开始写功能代码，由于涉及到的功能比较多，本次不打算像之前那样先写service再写controller，而是按照每个完整的功能来开发，保证每个功能的代码都能说得清楚

编码，低级API，把ChatMessage放入集合

  • 首先来实现的是最简单的做法，就是下图红框中那个
    在这里插入图片描述
  • 这个功能的关键是自己动手，用一个集合记录所有的对话信息，然后每次提问都把新问题放入这个集合，再全部传给大模型
  • 先增加模型的配置类，新建文件langchain4j-totorials/memory/src/main/java/com/bolingcavalry/config/LangChain4jConfig.java，内容如下
@Configuration
public class LangChain4jConfig {

    @Value("${langchain4j.open-ai.chat-model.api-key}")
    private String apiKey;

    @Value("${langchain4j.open-ai.chat-model.model-name:qwen-turbo}")
    private String modelName;

    @Value("${langchain4j.open-ai.chat-model.base-url}")
    private String baseUrl;

    /**
     * 创建并配置OpenAiChatModel实例（使用通义千问的OpenAI兼容接口）
     * 
     * @return OpenAiChatModel实例
     */
    @Bean
    public OpenAiChatModel openAiChatModel() {
        return OpenAiChatModel.builder()
                .apiKey(apiKey)
                .modelName(modelName)
                .baseUrl(baseUrl)
                .build();
    }
}
  • 然后是服务类langchain4j-totorials/memory/src/main/java/com/bolingcavalry/service/QwenService.java，代码如下，具体功能下面就会讲到
package com.bolingcavalry.service;

import dev.langchain4j.chain.ConversationalChain;
import dev.langchain4j.data.message.*;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.model.openai.OpenAiChatModel;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.bolingcavalry.util.Tools;

/**
 * 通义千问服务类，用于与通义千问模型进行交互
 */
@Service
public class QwenService {

    private static final Logger logger = LoggerFactory.getLogger(QwenService.class);

    @Autowired
    private OpenAiChatModel openAiChatModel;

		private 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);

        logger.info("响应：" + resp.text());

        return resp.text() + "[from lowLevelAddRawChatMessage]";
    }
  • 上述代码中，先是依赖注入了模型实例openAiChatModel，然后准备一个集合history用于保存所有会话记录，具体功能在lowLevelAddRawChatMessage方法中，里面把每一次的对话记录都保存在history中，然后在调用openAiChatModel.chat方法时把所有问答记录全部传给了大模型
  • 最后是controller类QwenController.java，这里面没啥值得看的，就是在相应http请求时调用了服务类的lowLevelAddRawChatMessage方法
package com.bolingcavalry.controller;

import com.bolingcavalry.service.QwenService;
import lombok.Data;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 通义千问控制器，处理与大模型交互的HTTP请求
 */
@RestController
@RequestMapping("/api/qwen")
public class QwenController {

    private final QwenService qwenService;

    /**
     * 构造函数，通过依赖注入获取QwenService实例
     * 
     * @param qwenService QwenService实例
     */
    public QwenController(QwenService qwenService) {
        this.qwenService = qwenService;
    }

    /**
     * 提示词请求实体类
     */
    @Data
    static class PromptRequest {
        private String prompt;
        private int userId;
    }

    /**
     * 响应实体类
     */
    @Data
    static class Response {
        private String result;

        public Response(String result) {
            this.result = result;
        }
    }

    /**
     * 检查请求体是否有效
     * 
     * @param request 包含提示词的请求体
     * @return 如果有效则返回null，否则返回包含错误信息的ResponseEntity
     */
    private ResponseEntity<Response> check(PromptRequest request) {
        if (request == null || request.getPrompt() == null || request.getPrompt().trim().isEmpty()) {
            return ResponseEntity.badRequest().body(new Response("提示词不能为空"));
        }
        return null;
    }

    @PostMapping("/lowlevel/addrawchatmessage")
    public ResponseEntity<Response> addRawChatMessage(@RequestBody PromptRequest request) {
        ResponseEntity<Response> checkRlt = check(request);
        if (checkRlt != null) {
            return checkRlt;
        }

        try {
            // 调用QwenService获取模型响应
            String response = qwenService.lowLevelAddRawChatMessage(request.getPrompt());
            return ResponseEntity.ok(new Response(response));
        } catch (Exception e) {
            // 捕获异常并返回错误信息
            return ResponseEntity.status(500).body(new Response("请求处理失败: " + e.getMessage()));
        }
    }
  • 通过上述代码可见，只要把所有聊天记录传给大模型就能实现记忆功能，这就是最原始的办法，可以作为功能演示，但决不能用在生产环境，否则大量对话记录存入history集合会导致占用内存越来越多且不会释放
  • 最简单的记忆功能就已经完成了，现在把工程运行起来试试，在memory目录下执行以下命令即可启动服务
mvn spring-boot:run
  • 用vscode的 REST Client插件发起http请求，参数如下
POST http://localhost:8080/api/qwen/lowlevel/addrawchatmessage
Content-Type: application/json
Accept: application/json

{
  "prompt": "一百字介绍曹操"
}
  • 收到响应如下
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 13 Dec 2025 01:46:39 GMT
Connection: close

{
  "result": "曹操（155年－220年），字孟德，东汉末年杰出的政治家、军事家、文学家。他统一北方，挟天子以令诸侯，奠定曹魏基业。虽被传统史书称为“奸雄”，但其唯才是举、屯田安民、诗文慷慨，展现出复杂而卓越的才能。其子曹丕称帝后，追尊为魏武帝。[from lowLevelAddRawChatMessage]"
}
  • 此时上述对话内容都已经存入集合中，可以继续问有关曹操的其他问题了
POST http://localhost:8080/api/qwen/lowlevel/addrawchatmessage
Content-Type: application/json
Accept: application/json

{
  "prompt": "他有哪些主要对手？"
}
  • 响应如下，可见大模型知道这里的他说的是曹操，回答的也是关于曹操的内容了
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 13 Dec 2025 01:48:14 GMT
Connection: close

{
  "result": "曹操一生主要对手包括：\n\n1. **袁绍**：北方最强军阀，官渡之战（200年）被曹操击败，势力瓦解。  \n2. **刘备**：汉室宗亲，联合孙权在赤壁之战（208年）大败曹操，后建立蜀汉。  \n3. **孙权**：据守江东，与刘备结盟抗曹，长期对峙于江淮、荆州一带。  \n4. **吕布**：勇猛善战，曾夺曹操兖州，后被擒杀。  \n5. **马超、韩遂**：西凉军阀，曾起兵反曹，被曹操用离间计击破。  \n\n这些对手或割据一方，或志在复兴汉室，与曹操在政治、军事上激烈对抗，共同塑造了三国鼎立格局。[from lowLevelAddRawChatMessage]"
}
  • 至此，第一个功能就开发完成了，配置类、服务类、controller这些也都创建完成，接下来的开发都会在这些类中增加代码

编码，低级API，把ChatMessage放入ChatMemory

  • 前面的方法虽然管用，但是做法过于原始，在LangChain4j中是不会直接用List来存储历史消息的，而是ChatMemory接口及其实现类，这里咱们来体验一下该对象的用法，如下图红框所示，注意，现在只是体验ChatMemory，整个记忆功能还是原始的手动记录，还未简化
    在这里插入图片描述

  • 新建工具类langchain4j-totorials/memory/src/main/java/com/bolingcavalry/util/Tools.java，里面有个静态方法用来创建ChatMemory的实例

package com.bolingcavalry.util;

import java.util.Map;

import org.mapdb.DB;
import org.mapdb.DBMaker;

import com.bolingcavalry.persistence.EmbeddedByIdDb;
import com.bolingcavalry.persistence.EmbeddedGlobalDb;

import static org.mapdb.Serializer.*;

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;

public class Tools {
    /**
     * 创建一个ChatMemory实例，用于存储聊天记忆，存在内存中
     * 
     * @return 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时没有控制长度导致内存不断变大的问题
  • 在服务类QwenService中增加代码
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);

        logger.info("响应：" + answer.text());
        return answer.text() + "[from lowLevelAddChatMessageToChatMemory]";
    }
  • 从上述代码可见openAiChatModel.chat方法接受chatMemory作为入参把聊天记录全部拿到
  • 接下来是controller类中增加一个http响应，使用上述lowLevelAddChatMessageToChatMemory方法
    @PostMapping("/lowlevel/addchatmessagetochatmemory")
    public ResponseEntity<Response> addChatMessageToChatMemory(@RequestBody PromptRequest request) {
        ResponseEntity<Response> checkRlt = check(request);
        if (checkRlt != null) {
            return checkRlt;
        }

        try {
            // 调用QwenService获取模型响应
            String response = qwenService.lowLevelAddChatMessageToChatMemory(request.getPrompt());
            return ResponseEntity.ok(new Response(response));
        } catch (Exception e) {
            // 捕获异常并返回错误信息
            return ResponseEntity.status(500).body(new Response("请求处理失败: " + e.getMessage()));
        }
    }
  • 开发完毕，运行服务体验此功能，请求信息
POST http://localhost:8080/api/qwen/lowlevel/addchatmessagetochatmemory
Content-Type: application/json
Accept: application/json

{
  "prompt": "一百字介绍曹操"
}
  • 响应
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 13 Dec 2025 02:31:35 GMT
Connection: close

{
  "result": "曹操（155年－220年），字孟德，东汉末年杰出的政治家、军事家、文学家。他统一北方，奠定曹魏基业，推行屯田、唯才是举等政策。文学上，他开创建安文学新风，诗作慷慨悲凉，代表作有《观沧海》《短歌行》《龟虽寿》等，与子曹丕、曹植并称“三曹”，对后世影响深远。[from lowLevelAddChatMessageToChatMemory]"
}
  • 再问
POST http://localhost:8080/api/qwen/lowlevel/addchatmessagetochatmemory
Content-Type: application/json
Accept: application/json

{
  "prompt": "他有哪些文学成就？"
}
  • 收到的响应符合预期
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 13 Dec 2025 02:34:46 GMT
Connection: close

{
  "result": "曹操的文学成就主要包括：\n\n1. **开创建安文学新风**：其作品风格“慷慨悲凉、志深笔长”，成为建安风骨的代表。\n2. **诗歌成就卓著**：善用乐府旧题写时事与抱负，代表作有《观沧海》（中国首首完整山水诗）、《短歌行》（“对酒当歌，人生几何”）、《龟虽寿》（“老骥伏枥，志在千里”）等，语言质朴而气势雄浑。\n3. **推动文坛繁荣**：广揽文士，形成邺下文人集团，促进建安文学兴盛。\n4. **散文清峻通脱**：如《让县自明本志令》，兼具政治性与文学性。\n\n他与儿子曹丕、曹植合称“三曹”，在中国文学史上地位崇高。[from lowLevelAddChatMessageToChatMemory]"
}

编码，低级API，基于ConversationalChain的简化

  • 您应该会发现前面的做法太原始了，每次都要自己写代码保存历史记录，为什么不能通过封装来简化这些操作呢？
  • LangChain4j也考虑到了这一点，提供ConversationalChain类支持记录历史功能，如下图红框
    在这里插入图片描述
  • 开始编码实现上述功能，在QwenService类增加服务方法，如下，可见非常简单，只要使用ConversationalChain的API即可，历史记录会被自动存入ChatMemory中
    /**
     * 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);
        logger.info("响应：" + answer);

        return answer + "[from lowLevelByConversationChain]";
    }
  • 在controller类中增加对上述方法的使用
    @PostMapping("/lowlevel/byconversationchain")
    public ResponseEntity<Response> byConversationChain(@RequestBody PromptRequest request) {
        ResponseEntity<Response> checkRlt = check(request);
        if (checkRlt != null) {
            return checkRlt;
        }

        try {
            // 调用QwenService获取模型响应
            String response = qwenService.lowLevelByConversationChain(request.getPrompt());
            return ResponseEntity.ok(new Response(response));
        } catch (Exception e) {
            // 捕获异常并返回错误信息
            return ResponseEntity.status(500).body(new Response("请求处理失败: " + e.getMessage()));
        }
    }
  • 运行起来，请求
POST http://localhost:8080/api/qwen/lowlevel/byconversationchain
Content-Type: application/json
Accept: application/json

{
  "prompt": "一百字介绍曹操"
}
  • 响应
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 13 Dec 2025 03:40:21 GMT
Connection: close

{
  "result": "曹操（155年－220年），字孟德，东汉末年杰出的政治家、军事家、文学家。他统一北方，挟天子以令诸侯，奠定曹魏基业。虽被传统史书称为“奸雄”，但其唯才是举、屯田安民、诗文慷慨，展现出复杂而卓越的才能。其子曹丕称帝后，追尊为魏武帝。[from lowLevelByConversationChain]"
}
  • 再请求
POST http://localhost:8080/api/qwen/lowlevel/byconversationchain
Content-Type: application/json
Accept: application/json

{
  "prompt": "他在与北方游牧民族的军事斗争中有哪些成就？"
}
  • 收到响应如下，可见记忆功能正常
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 13 Dec 2025 03:41:06 GMT
Connection: close

{
  "result": "曹操在与北方游牧民族的军事斗争中取得显著成就。他主要面对的是乌桓（又称乌丸）和匈奴等部族。建安十二年（207年），为彻底消除袁氏残余势力与乌桓的联合威胁，曹操亲率大军远征乌桓，在白狼山之战中大破乌桓主力，斩其首领蹋顿，降服二十余万部众，基本解除了乌桓对中原的威胁。此役不仅巩固了北方边疆，也加速了北方民族的内迁与融合。此外，曹操对南匈奴采取分化、内迁、设官监管的策略，将其纳入郡县管理体系，有效防止其大规模叛乱，稳定了并州、幽州等地的边防。这些举措为曹魏及后世处理民族关系提供了重要经验。[from lowLevelByConversationChain]"
}
  • 至此，基于低级API的聊天记忆功能就全部介绍完了，聪明的您应该发现了一个问题：如果两个人同时调用该服务，像下面这样
用户A：介绍一下曹操
大模型：曹操是...

用户B：介绍一下刘备
大模型：刘备是...

用户A：他有那些军事成就
大模型：刘备的军事成就是...
  • 显然用户A想知道的是曹操的军事成就，但是由于传给大模型的是所有的对话记录，从大模型视角是不知道提问的用户还分为用户A和用户B，所以回答的结果不是用户A想要的
  • 关于如何解决该问题就放在下一篇高级API篇吧，还有持久化问题也留在下一篇解决

你不孤单，欣宸原创一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 数据库+中间件系列
  6. DevOps系列
# 人工智能 # java # 语言模型
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

9个降AIGC工具推荐！研究生高效避坑指南

avatar 2048 AI社区
cover

强烈安利自考必备TOP10 AI论文平台

avatar 2048 AI社区

【GitHub项目推荐--Apache Airflow：工作流编排与调度平台】

是一个开源的工作流编排平台，用于以编程方式编写、调度和监控工作流。作为Apache软件基金会的顶级项目，Airflow采用Python编写，允许用户将工作流定义为代码，从而实现更好的可维护性、版本控制、测试性和协作性。该项目自2015年创建以来，已成为数据工程和数据处理领域的事实标准工具。核心价值代码即工作流：工作流以Python代码定义（DAGs），支持版本控制和协作开发灵活调度：基于依赖关系的

avatar 2048 AI社区