对话记忆与上下文工程
本篇要点:能让助手记住该记的、忘掉该忘的,并且为每一次请求算清 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 依赖与记忆配置
<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>spring:
ai:
chat:
memory:
repository:
jdbc:
# 默认 embedded:只有内嵌库才自动建表。生产上设 never,交给 Flyway
initialize-schema: neverpackage 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();
}
}运行结果(启动时表已存在,无需建表):
20:01:32.882 INFO JdbcChatMemoryRepositoryAutoConfiguration : Using JdbcChatMemoryRepository (dialect=Postgres)
20:01:32.901 INFO MemoryConfig : ChatMemory=MessageWindowChatMemory(maxMessages=12, repository=JdbcChatMemoryRepository)3.2 会话键、预算与压缩
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);
}
}运行结果:
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=falsepromptTokens 是服务端返回的真实值,不是自己按字数估的。估出来的数只够做粗排,做预算要用这个字段。
3.3 同一会话串行化
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 发出):
[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 预算告警、提示注入的防线,以及输出里那些不该出现的手机号和身份证号怎么脱敏。