🎯 今日核心问题
- 滚动窗口按「条数」裁和按「token」裁,差在哪?
- 摘要压缩什么时候触发,触发在哪一层,由谁来做?
- 为什么说关键信息抽取比摘要更值得写?抽出来的东西存在哪?
📖 精读提纲
【一】按条数裁的窗口会切断工具调用对
LangChain4j 的 MessageWindowChatMemory 默认丢弃最老的消息直到数量达标。问题在于它认的是「消息条数」,而一轮工具调用会产生 AiMessage(toolCalls) → ToolExecutionResultMessage × N 这样的成组结构。砍掉 AiMessage 只留工具结果,下一次请求会被网关直接 400(因为没有对应的 tool_call_id);反过来只砍工具结果留下 toolCalls,模型会认为「我调了工具但没拿到结果」从而重调一次,白烧一轮 token。
所以窗口的单位应该是「turn」而不是「message」:一个 turn = 一条 UserMessage + 它引发的所有 AiMessage / Tool 结果。裁剪时以 turn 为最小丢弃粒度,并且从后往前数 turn,永远保证最后 1 个 turn 是完整的。
另一个坑是按条数裁意味着每轮消耗的 token 波动极大:一条 20KB 的订单 JSON 和一句「好的」都是一条消息。查一下 MessageWindowChatMemory 的存在意义就明白了——它适合固定问答形态,不适合 Agent。生产上直接换 TokenWindowChatMemory,或者自己按 token 裁。
【二】摘要压缩:在 70% 水位线触发,不要在 100% 时救火
摘要的触发时机决定了它的成本。等到窗口满了再摘,你要么已经丢了几轮、要么得做一次巨大的同步调用把 30 轮压成一段,用户会明显卡顿。正确做法是水位线触发:当 tokens > 0.7 × window 时,把最老的一半 turn 摘要成一段,压回窗口。这样每次摘要的量恒定、延迟可控,而且永远留 30% 余量给突发输入。
摘要本身有两条红线:一是幂等,同一段历史被摘两次不能变成「摘要的摘要」,否则跑 100 轮后语言会彻底走形;二是可审计,摘要必须能追溯到它覆盖的消息 id 范围,出事时才能回答「模型当时到底看到了什么」。所以摘要不是覆盖写,而是往 summary 表里新增一条带 from_seq / to_seq 的版本记录。
摘要提示词不要写「总结对话」,要写「抽取以下对话中关于当前任务的事实、用户的诉求与约束、已作出的承诺,忽略寒暄与重复内容,不超过 300 字」。前者产出的是叙事,后者产出的是状态。
【三】关键信息抽取:把「原话」变成「槽位」
摘要的致命缺陷是不可靠:它是概率生成的,第 80 轮时那段摘要可能把「70 元」记成「100 元」。而业务字段(订单号、诉求类型、补偿金额、用户明确拒绝的方案)不允许模糊。这类信息应该走结构化抽取:每 N 轮(或检测到用户出现否定/修正/新诉求时)让模型抽一次 JSON,写入业务表,然后在拼 prompt 时以「已知槽位」的形式渲染出来。
抽取的价值不只是准,而是可被 Java 代码消费。槽位一旦是结构化的,你就可以做确定性校验:用户说「订单 A123」解析出的 orderId 必须能在订单表里查到,查不到就回问,而不是让模型拿着一个不存在的订单号编答案。这就是摘要永远做不到的事。
三者的分工可以这样记:窗口保流畅、摘要保连贯、槽位保准确。窗口负责「最近在聊什么」,摘要负责「之前大概聊了什么」,槽位负责「必须答对的那些事情」。
💻 代码示例
一个 turn 感知的短期记忆:按 token 水位触发摘要,同时把槽位抽取委托给一个单独的提示词。存储用内存 Map,接口对齐 LangChain4j 的 ChatMemory,后面换成 Redis 只需改实现。
package com.example.memory;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatLanguageModel;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
/** 按 turn 裁切 + 水位线摘要的短期记忆 */
public class ShortTermMemory {
private final ChatLanguageModel model;
private final int windowTokens;
private final double compactAt = 0.7;
private final Map<String, Session> sessions = new ConcurrentHashMap<>();
public ShortTermMemory(ChatLanguageModel model, int windowTokens) {
this.model = model;
this.windowTokens = windowTokens;
}
public static final class Session {
final List<ChatMessage> raw = new ArrayList<>(); // 全部原文,只增不删
String summary = ""; // 覆盖 [0, summaryUpTo) 区间的摘要
int summaryUpTo = 0;
int lastSummaryTokens = 0;
}
public void add(String conversationId, ChatMessage message) {
Session s = sessions.computeIfAbsent(conversationId, k -> new Session());
synchronized (s) {
s.raw.add(message);
if (estimate(s.raw) > windowTokens * compactAt) {
compact(conversationId, s);
}
}
}
/** 返回真正发给模型的 messages:摘要 + 最近的完整 turn */
public List<ChatMessage> build(String conversationId) {
Session s = sessions.get(conversationId);
if (s == null) {
return List.of();
}
synchronized (s) {
List<ChatMessage> out = new ArrayList<>();
if (!s.summary.isEmpty()) {
out.add(UserMessage.from("[历史摘要] " + s.summary));
}
out.addAll(alignFrom(s.raw, s.summaryUpTo));
return out;
}
}
/** 水位线触发:把最老的一半未摘要 turn 折成摘要 */
private void compact(String conversationId, Session s) {
List<int[]> turns = splitTurns(s.raw, s.summaryUpTo);
if (turns.size() < 2) {
return; // 只剩一个 turn 时摘要没有意义,宁可让上层报错
}
int take = Math.max(1, turns.size() / 2);
int toSeq = turns.get(take - 1)[1];
StringBuilder batch = new StringBuilder();
if (!s.summary.isEmpty()) {
batch.append("已有摘要:").append(s.summary).append("\n\n");
}
batch.append("新增对话:\n");
for (int i = 0; i < toSeq; i++) {
batch.append(s.raw.get(i).type()).append(": ")
.append(clip(s.raw.get(i).text(), 600)).append('\n');
}
String prompt = """
把下面这段客服对话压成不超过 300 字的状态摘要,必须包含:
1) 用户当前的诉求与订单号;2) 用户明确拒绝过的方案;
3) Agent 已承诺但未完成的事项;4) 已确认的关键事实(金额、时间、单号)。
不要写寒暄,不要写"用户说"这类叙事,直接写事实条目。
如果新内容与已有摘要冲突,以新内容为准并在条目后标注[已更正]。
""" + batch;
synchronized (s) {
s.summary = model.generate(prompt).trim();
s.summaryUpTo = toSeq;
s.lastSummaryTokens = estimate(List.of(UserMessage.from(s.summary)));
}
}
/** 从 from 开始对齐到一个 turn 边界,保证不会把 tool 结果和它的 toolCall 拆开 */
private List<ChatMessage> alignFrom(List<ChatMessage> raw, int from) {
int i = from;
while (i < raw.size() && !(raw.get(i) instanceof UserMessage)) {
i++;
}
List<ChatMessage> out = new ArrayList<>(raw.subList(i, raw.size()));
// 最后一轮若以 AiMessage(toolCalls) 收尾但缺结果,整体丢弃,避免非法请求
while (!out.isEmpty() && out.get(out.size() - 1) instanceof AiMessage ai
&& ai.hasToolExecutionRequests()) {
out.remove(out.size() - 1);
}
return out;
}
private List<int[]> splitTurns(List<ChatMessage> raw, int from) {
List<int[]> turns = new ArrayList<>();
int start = -1;
for (int i = from; i < raw.size(); i++) {
if (raw.get(i) instanceof UserMessage) {
if (start >= 0) {
turns.add(new int[]{start, i});
}
start = i;
}
}
if (start >= 0) {
turns.add(new int[]{start, raw.size()});
}
return turns;
}
private int estimate(List<ChatMessage> msgs) {
int t = 0;
for (ChatMessage m : msgs) {
t += (m.text() == null ? 0 : m.text().length()) + 4;
}
return t;
}
private String clip(String s, int n) {
return s == null ? "" : (s.length() <= n ? s : s.substring(0, n) + "…");
}
public String newSession() {
String id = UUID.randomUUID().toString();
sessions.put(id, new Session());
return id;
}
}
用 40 轮客服对话压测,关键观测值是 summary 的膨胀速度:如果第 10 轮摘要是 280 字、第 20 轮变成 310、第 40 轮变成 460,说明你的提示词没约束住「不重复已有摘要」,摘要正在自我繁殖。稳定状态下它应该始终在 250–320 字之间抖动,因为每次都是「旧摘要 + 新增对话 → 新摘要」,输入输出规模恒定。
对照 D1 的基线:同一段 40 轮会话,纯滑动窗口在第 41 轮开始问「订单号是多少」;换成水位线摘要后,模型能一路答到第 60 轮还记得 A123,但会开始把「70 元补偿」说成「补偿已发放」——这正是摘要丢细节的体现,也是明天槽位抽取要补的漏洞。
✏️ 今日动手
① 把 ShortTermMemory 接到你现有的 Agent 上,跑 40 轮脚本化客服对话;② 打印每次 compact 前后的 token 数与摘要文本,检查摘要有没有出现「摘要的摘要」式退化;③ 故意构造一条工具调用在末尾被裁的场景,验证 alignFrom 能避免 400;④ 记录摘要调用带来的额外 token 成本(应该是总量的 5% 以内)。
🔖 明日预告
短期记忆只管一个会话。用户下周再来,或者换到另一个渠道,Agent 又是一张白纸。明天讲长期记忆:事实存向量库按语义召回,关系(谁买了什么、属于哪个项目)存数据库按结构查,以及两者怎么在一次查询里合并。