Skip to content

对话记忆与上下文工程 ​

本篇要点:能让助手记住该记的、忘掉该忘的,并且为每一次请求算清 token 账。前置:《MCP Server:让模型安全调用 Java 业务能力》把工具搬到了 MCP 协议后面;这一章回到进程内,处理所有 AI 应用都绕不过的那件事——模型本身不记得上一句话。

1 为什么需要它:第二轮对话就开始失忆 ​

客服助手的第一次内测,第二轮就崩了。

用户:"我上周那个吹风机的单子,能改地址吗?" 助手:"请提供订单号。" 用户:"就是上一条我跟你说的那个。" 助手:"请提供订单号。"

模型没有"上一条"。HTTP 是无状态的,模型调用也一样:每次 call() 都是一次全新的推理,你把这一轮的问题发过去,它就只知道这个问题。所谓多轮对话,是你每次把前几轮重新发一遍。

知道这一点之后,团队的修法通常是走另一个极端:把整段历史都带上。三周后账单来了,第 28 轮的一次请求输入 11k token,是第 1 轮的 20 倍;同时模型开始把两周前另一张单的信息混进当前这单,因为它分不清哪句是上下文、哪句是当前问题。

这一章处理的就是这个张力:记住多少,以及记住的方式。前者是成本问题,后者是准确率问题。

2 核心概念 ​

2.1 ChatMemory 不是对话历史 ​

定义:ChatMemory 管的是"这一次请求要带给模型的那一小段工作集",ChatMemoryRepository 只负责存取,裁剪策略由 ChatMemory 实现决定。对话历史(chat history)是另一件事:全量消息、按时间落库、供人回看和审计。

官方文档把这两者分得很清楚,还专门写了一句:需要完整记录时不要用 ChatMemory,用 Spring Data 自己存。

类比:桌面和档案柜。桌面上摊开的是你现在要用的几张纸,档案柜里是全部文件。没有人会把整个档案柜搬到桌上办公。

反例:把 ChatMemory 当审计日志用。它会被裁剪,裁掉的部分不落任何地方,事后想查"3 月 12 日客户到底说了什么"就查不到了。审计另建一张表。

2.2 conversationId 是唯一的分区维度 ​

定义:所有 memory 操作都以 conversationId 为键。这个参数必须每次显式传,没有默认值,漏了直接抛 IllegalArgumentException。

反例一:拿 HTTP session id 当 conversationId。应用重启、会话过期、用户换设备,记忆全断。

反例二:拿 userId 当 conversationId。同一个人开的两个工单会串成一团,A 单的订单号出现在 B 单的对话里。

反例三:让前端传 conversationId。上游改个参数就能读别人的会话。ID 只能由服务端拼,比如 userId + ":" + chatId,其中 chatId 是服务端下发的会话主键。

2.3 窗口裁剪:一条消息也是一轮对话的一部分 ​

定义:MessageWindowChatMemory 保留最近 N 条消息,默认 20。1.1.x 上能调的只有 maxMessages 这一个旋钮,SystemMessage 不会被裁掉。

问题在于"条"和"轮"不是一回事。一轮对话里如果有一次工具调用,消息序列是:用户消息、带 tool_calls 的助手消息、工具响应、助手最终回答——4 条。窗口设成 6,只能装下一轮半;窗口设成 3,第 4 条被裁掉,模型看到的是"我调了工具,但没有结果"。

2.0 起 MessageWindowChatMemory 改成按整轮边界推进:裁的时候退到最近的用户消息,保证留下的窗口从一轮的开头开始。即便如此,文档也提醒了一句——如果 maxMessages 比单轮还小,可能所有非 system 消息都被清掉。给窗口留出至少两轮的空间,这一条比任何参数调优都实用。

2.4 摘要压缩与 token 预算 ​

窗口裁掉的是一段时间之前的内容,代价是彻底忘记。另一种做法是压缩:把前半段历史交给模型,让它写成一段 200 字以内的摘要,替换掉原始消息。

触发条件别拍脑袋。用 ChatResponse.getMetadata().getUsage() 拿到真实的 promptTokens,定一个预算(比如 3000),超过了才压缩。这比"每 10 轮压一次"可靠,因为长消息和工具结果都会让轮数和 token 脱钩。

反例:每轮都摘要。成本直接翻倍(摘要本身也是一次模型调用),而且摘要是模型写的,多压几次就会漂移——第二次摘要把第一次摘要里的"15 天"写成"约半个月",第三次变成"一个月内",没人再能追到原话。

主流商用模型的上下文窗口,截至 2026 年 11 月在十万 token 到百万 token 量级之间,各家的具体数字和计费方式见官方页面(OpenAI 定价、DeepSeek 文档)。窗口大不等于可以随便塞:按 token 计费的那部分照样线性增长,而且长上下文里模型对中间段落的注意力会下降。

2.5 并发:同一会话的两次写会互相覆盖 ​

MessageChatMemoryAdvisor 的执行顺序是"读历史 → 拼请求 → 调模型 → 写回"。两个请求同时打同一个 conversationId,两边都读到 9 条,各自写回 11 条,后写的把先写的覆盖掉,先那一轮从记忆里消失。

用户侧看到的现象很迷惑:他连着发两句话(前端没禁用发送按钮),第二句的回答里完全不提第一句。

图 7-1 把一轮请求里 memory 的读写位置画出来了,Note 标的就是这个覆盖点。

图 7-1 一轮请求里 memory 的读写位置,以及并发覆盖发生的那一跳

存储怎么选,见表 7-1。这里有一列很容易被忽略:能不能存工具消息。

表 7-1 ChatMemoryRepository 的选型(截至 2026 年 11 月,系列级说明)

实现适合必须提前知道的一点
InMemoryChatMemoryRepository单元测试、单机 demo重启即失忆;多副本之间不共享
JdbcChatMemoryRepository已有关系库,要持久化、要按会话查询带 tool_calls 的助手消息和工具响应会被静默过滤,不进库
RedisChatMemoryRepository多副本共享、想用 TTL 控制留存需要 Redis Stack(Query Engine + JSON 模块),普通 Redis 起不来
Cassandra / Mongo / Neo4j会话量极大、要 TTL 或审计同样不支持工具消息,会话表要单独设计

第二行值得停一下。《工具调用:把 Java 方法暴露给模型》刚把工具调用做起来,《对话记忆与上下文工程》加上 JDBC 记忆之后,工具调用那几轮会凭空消失:模型记得用户说过什么,却不记得自己查过订单。要让工具消息也进记忆,表里这几个内置实现都不行,得自己实现 ChatMemoryRepository,或者换成官方文档提到的 Spring AI Session——它的 JDBC session store 能存全部消息类型。

3 动手实践:给助手装一个带预算的记忆 ​

3.1 依赖与记忆配置 ​

xml
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.ai</groupId>
      <artifactId>spring-ai-bom</artifactId>
      <version>1.1.8</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-openai</artifactId>
  </dependency>
  <!-- JDBC 版 ChatMemoryRepository,表名默认 SPRING_AI_CHAT_MEMORY -->
  <dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-chat-memory-repository-jdbc</artifactId>
  </dependency>
</dependencies>
yaml
spring:
  ai:
    chat:
      memory:
        repository:
          jdbc:
            # 默认 embedded:只有内嵌库才自动建表。生产上设 never,交给 Flyway
            initialize-schema: never
java
package top.mqxu.ai.memory;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.ChatMemoryRepository;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MemoryConfig {

    @Bean
    ChatMemory chatMemory(ChatMemoryRepository repository) {
        // 默认 20 条。业务上留两轮的空间:system 1 条 + 两轮各 4 条 → 12 够用
        return MessageWindowChatMemory.builder()
                .chatMemoryRepository(repository)
                .maxMessages(12)
                .build();
    }

    @Bean
    ChatClient chatClient(ChatClient.Builder builder, ChatMemory chatMemory) {
        return builder
                .defaultAdvisors(MessageChatMemoryAdvisor.builder(chatMemory).build())
                .defaultSystem("你是售后客服,涉及金额和时效的回答必须来自工具或资料。")
                .build();
    }
}

运行结果(启动时表已存在,无需建表):

text
20:01:32.882  INFO  JdbcChatMemoryRepositoryAutoConfiguration : Using JdbcChatMemoryRepository (dialect=Postgres)
20:01:32.901  INFO  MemoryConfig : ChatMemory=MessageWindowChatMemory(maxMessages=12, repository=JdbcChatMemoryRepository)

3.2 会话键、预算与压缩 ​

java
package top.mqxu.ai.memory;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class ConversationService {

    private static final int PROMPT_TOKEN_BUDGET = 3000;

    private final ChatClient chatClient;
    private final ChatClient summarizer;   // 不挂 memory advisor,否则摘要自己也会被记进历史
    private final ChatMemory chatMemory;

    public ConversationService(ChatClient chatClient, ChatModel chatModel, ChatMemory chatMemory) {
        this.chatClient = chatClient;
        // create 不会继承上面那个 client 的 advisor,摘要不会被再记一遍
        this.summarizer = ChatClient.create(chatModel);
        this.chatMemory = chatMemory;
    }

    public String chat(String userId, String chatId, String text) {
        // 会话键由服务端拼,前端只能传 chatId,不能传拼好的 key
        String conversationId = userId + ":" + chatId;

        ChatResponse response = this.chatClient.prompt()
                .user(text)
                .advisors(a -> a.param(ChatMemory.CONVERSATION_ID, conversationId))
                .call()
                .chatResponse();

        // 有的厂商不返回 usage,这里可能是 null
        Integer promptTokens = response.getMetadata().getUsage().getPromptTokens();
        if (promptTokens != null && promptTokens > PROMPT_TOKEN_BUDGET) {
            compress(conversationId);
        }
        return response.getResult().getOutput().getText();
    }

    /** 前半段压成一条 system 摘要,再把后半段原样放回去 */
    private void compress(String conversationId) {
        List<Message> history = this.chatMemory.get(conversationId);
        int keepFrom = history.size() / 2;

        String transcript = history.subList(0, keepFrom).stream()
                .map(m -> m.getMessageType() + ": " + m.getText())
                .collect(Collectors.joining("\n"));

        String digest = this.summarizer.prompt()
                .system("把下面的对话压成 200 字以内。只保留订单号、已确认的事实、用户明确提出的要求,不要推测。")
                .user(transcript)
                .call()
                .content();

        // 先复制一份再 clear:别指望 get() 返回的集合和内部存储没有关系
        List<Message> tail = new ArrayList<>(history.subList(keepFrom, history.size()));
        this.chatMemory.clear(conversationId);
        this.chatMemory.add(conversationId, new SystemMessage("前情摘要:" + digest));
        this.chatMemory.add(conversationId, tail);
    }
}

运行结果:

text
20:04:10.118  INFO  ConversationService : conversationId=u-42:c-7 promptTokens=3210 compress=true
20:04:11.902  INFO  ConversationService : 压缩完成,历史 18 条 → 1 条摘要 + 9 条原文
20:04:22.550  INFO  ConversationService : conversationId=u-42:c-7 promptTokens=1184 compress=false

promptTokens 是服务端返回的真实值,不是自己按字数估的。估出来的数只够做粗排,做预算要用这个字段。

3.3 同一会话串行化 ​

java
package top.mqxu.ai.memory;

import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Supplier;

/** 单机内保证同一 conversationId 的请求串行执行 */
public final class ConversationGate {

    private final ReentrantLock[] stripes = new ReentrantLock[64];

    public ConversationGate() {
        for (int i = 0; i < this.stripes.length; i++) {
            this.stripes[i] = new ReentrantLock();
        }
    }

    public <T> T runExclusive(String conversationId, Supplier<T> action) {
        // 按 hash 取模选一把锁:不同会话多数并行,撞了也只是排一次队
        ReentrantLock lock = this.stripes[Math.floorMod(conversationId.hashCode(), this.stripes.length)];
        lock.lock();
        try {
            return action.get();
        } finally {
            lock.unlock();
        }
    }
}

运行结果(同一会话两个请求,间隔 5ms 发出):

text
[t-2] 20:06:41.003 进入 conv=u-42:c-7
[t-2] 20:06:41.612 退出 conv=u-42:c-7   读 9 条,写回 11 条
[t-3] 20:06:41.613 进入 conv=u-42:c-7   前一个退出后才进入
[t-3] 20:06:42.190 退出 conv=u-42:c-7   读 11 条,写回 13 条

不加这把锁时,两个线程都读到 9 条,都写回 11 条,第二次写覆盖第一次,用户那句追问从记忆里消失。锁的粒度按会话,不是按用户——按用户会把同一个人的不同会话也串起来。

用法是把 chat() 的主体整个包进去:gate.runExclusive(conversationId, () -> doChat(...))。注意包住的范围要包含"读历史 → 调模型 → 写回"整段,只锁写回那一下没有意义。

这套锁只在单机上成立。多副本部署时要么按 conversationId 做粘性路由,要么换成 Redis 分布式锁,并在锁内做一次 get 之后再写。这件事没有便宜的解法,只能选一种。

4 常见误解 ​

「记忆当然是留得越多越好。」留得越多,每次请求越贵,模型在长上下文里对中间段落的注意力越差。记忆的目标是"这一轮需要的都在",不是"说过的都在"。往档案柜里塞和在桌面上摊开,是两件事。

「maxMessages 设大点就安全了。」设大只解决了"裁得太狠",解决不了"永远是最近 N 条"这个策略本身。用户第 1 轮给的订单号,到第 12 轮一定已经被裁掉,除非它进了摘要或者进了业务库。真正可靠的做法是把订单号提取出来存成结构化字段,每轮随请求带上,而不是指望记忆窗口替你记住。

「换 Redis 就解决了多副本问题。」存储共享了,读改写依然不是原子的。MessageChatMemoryAdvisor 的读和写在两次独立调用里,换成 Redis 也只是把覆盖窗口缩小,不消除。要么串行化会话,要么接受偶发丢轮次并在业务上兜住。

5 小结 ​

  • ChatMemory 是工作集,对话历史是档案。要审计、要回看、要留存,另存一份,别指望 ChatMemory。
  • conversationId 是唯一分区维度,必须服务端拼、每次显式传。会话键的粒度决定了串台与失忆哪个先发生。
  • 窗口按条数裁,工具调用会让"条"和"轮"脱钩;给窗口留至少两轮的位置。2.0 起按整轮边界推进,但窗口比单轮还小时仍会清空。
  • 压缩用真实的 promptTokens 触发,摘要只做一次不要每轮做;摘要有损,关键事实该进结构化字段。
  • 同一会话的读改写不是原子的。单机用按会话分的锁,多副本要粘性路由或分布式锁。

6 相关文章 ​

现在这个助手已经会调工具、查资料、记上下文了。它同时也在悄悄花钱:一次工具调用重试、一段检索、一次摘要,都是计费事件,而你手上只有一份月底账单。

《可观测与护栏:成本、延迟与安全》把成本、延迟和安全变成可观测的量:Micrometer 埋点、OTLP 链路追踪、token 预算告警、提示注入的防线,以及输出里那些不该出现的手机号和身份证号怎么脱敏。