🎯 今日核心问题

  1. 滚动窗口按「条数」裁和按「token」裁,差在哪?
  2. 摘要压缩什么时候触发,触发在哪一层,由谁来做?
  3. 为什么说关键信息抽取比摘要更值得写?抽出来的东西存在哪?

📖 精读提纲

【一】按条数裁的窗口会切断工具调用对

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 又是一张白纸。明天讲长期记忆:事实存向量库按语义召回,关系(谁买了什么、属于哪个项目)存数据库按结构查,以及两者怎么在一次查询里合并。