🎯 今日核心问题

  1. 模型本身没有状态,那「记忆」到底存在哪一环?
  2. 128K 窗口听起来很大,为什么一个客服会话跑 40 轮就爆?
  3. 哪些内容可以丢、哪些一旦丢了就再也算不回来?

📖 精读提纲

【一】先接受一个事实:模型是无状态的

每次调用 chatModel.generate(messages),服务端都是把整串 List<ChatMessage> 重新读一遍然后做一次前向计算。模型不会因为你昨天问过它「用户 U1024 的订单 A123」就记住——记忆完全由你拼进 messages 的那段文本构成。这一条想清楚,后面六天的所有设计都是在回答同一个问题:下一轮调用时,我该把哪些文本塞进去?

所以「上下文窗口满了」不是模型的问题,是你的拼接策略的问题。你没有释放策略,它就一定会在某个轮次爆掉。

【二】窗口里真正在消耗 token 的往往不是对话

拿一个真实的客服 Agent 举例,一轮调用的 token 构成大致是:系统提示 1.2K、工具定义 2.6K(12 个工具,每个带 JSON Schema)、检索到的知识库片段 4K、用户历史订单摘要 1.5K、对话历史 N 轮、本轮用户输入 0.2K。你会发现固定的脚手架就吃掉约 10K,对话历史只占其中一部分。

这个结构决定了两条优化顺序:先砍脚手架(工具按场景动态注入、知识片段按需检索、订单摘要预先压缩),再谈裁对话历史。很多团队一上来就做对话摘要,结果省了 2K,回头发现 12 个工具的 Schema 还在那里每轮重发。

还有一个隐性成本:上下文越长,注意力越散。即使窗口塞得下,把 60 轮历史全塞进去,模型对第 3 轮里那句「我不要发票,只要退款」的召回率会显著下降。这不是 bug,是长上下文本身的特性。所以裁剪不只是省钱,是保准确率。

【三】三类信息,三种处理方式

把窗口里的内容按「丢失后能否重算」分类,处理方式就自然出来了:

绝大多数上下文溢出事故,都是把第二类当成第一类丢掉了。

【四】四种释放策略,按代价从低到高

滑动窗口(丢最老的):零成本但会丢关键信息,适合闲聊型。摘要压缩(把老历史折成一段):一次额外 LLM 调用,能保住大意,但会丢细节和原话。结构化抽取(从老历史里抽出 槽位 存起来,原文丢弃):最贵但最可靠,适合有明确业务字段的场景(订单号、诉求类型、已承诺的补偿)。外部检索(原文全部落库,需要时按相关度捞回来):把「记住」从窗口搬到存储,是最接近人类记忆的做法,也是 D3 的主题。

工程上的正确姿势是混合:常驻区 + 结构化槽位 + 最近 N 轮原文 + 更早历史的摘要。今天先把这套预算分配写死并且可度量,明天再逐个实现。

💻 代码示例

先做一个上下文预算器:估算每块内容的 token、按优先级分配窗口、超了就按既定顺序降级。这一步不做,后面的裁剪策略都是在猜。

package com.example.memory;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.ToolExecutionResultMessage;
import dev.langchain4j.data.message.UserMessage;
import org.springframework.stereotype.Component;

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

/**
 * 上下文预算器:在把 messages 发给模型之前,保证总 token 不超阈值。
 * 中文按 1 字 ≈ 1 token、英文按 4 字符 ≈ 1 token 粗估,误差 10% 以内足够做预算。
 */
@Component
public class ContextBudgeter {

    /** 预留输出空间,模型回答不会因为输入占满而截断 */
    private static final int RESERVED_FOR_OUTPUT = 800;

    public int estimate(String text) {
        if (text == null || text.isEmpty()) {
            return 0;
        }
        int cjk = 0;
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            if (c >= 0x4E00 && c <= 0x9FFF) {
                cjk++;
            }
        }
        int other = text.length() - cjk;
        return cjk + (int) Math.ceil(other / 4.0);
    }

    public int estimateAll(List<ChatMessage> messages) {
        int sum = 0;
        for (ChatMessage m : messages) {
            sum += estimate(m.text()) + 4;   // 每条消息的角色标记开销
        }
        return sum;
    }

    /**
     * @param history 按时间正序的完整历史
     * @param windowTokens 模型窗口(如 32768)
     * @return 裁剪后的历史 + 被丢弃的消息数
     */
    public TrimResult trim(List<ChatMessage> history, int windowTokens) {
        int budget = windowTokens - RESERVED_FOR_OUTPUT;
        int used = estimateAll(history);
        if (used <= budget) {
            return new TrimResult(history, 0, used);
        }

        // 1. 先把工具结果消息的正文压成一行,工具结果是可重算的,优先瘦身
        List<ChatMessage> slimmed = new ArrayList<>(history.size());
        for (ChatMessage m : history) {
            if (m instanceof ToolExecutionResultMessage t) {
                slimmed.add(ToolExecutionResultMessage.from(
                        t.id(), t.toolName(), oneLine(t.text(), 120)));
            } else {
                slimmed.add(m);
            }
        }
        used = estimateAll(slimmed);
        if (used <= budget) {
            return new TrimResult(slimmed, 0, used);
        }

        // 2. 从最老的一轮开始丢,但永不丢第一条 SystemMessage
        int head = 0;
        while (head < slimmed.size()
                && !(slimmed.get(head) instanceof SystemMessage)) {
            head++;
        }
        int dropTo = head + 1;   // 跳过常驻的 System 区
        int dropped = 0;
        while (used > budget && dropTo < slimmed.size()) {
            // 以「一轮」为单位丢:UserMessage 及其后的 AiMessage / Tool 结果一起丢
            int end = dropTo + 1;
            while (end < slimmed.size() && !(slimmed.get(end) instanceof UserMessage)) {
                end++;
            }
            for (int i = dropTo; i < end; i++) {
                used -= estimate(slimmed.get(i).text()) + 4;
                dropped++;
            }
            dropTo = end;
        }

        List<ChatMessage> kept = new ArrayList<>();
        kept.addAll(slimmed.subList(0, head + 1));
        if (dropTo > head + 1) {
            kept.add(UserMessage.from("[系统提示] 已省略 " + dropped
                    + " 条较早的对话记录,如需确认细节请主动询问用户。"));
        }
        kept.addAll(slimmed.subList(dropTo, slimmed.size()));
        return new TrimResult(kept, dropped, estimateAll(kept));
    }

    private String oneLine(String s, int max) {
        String flat = s.replaceAll("\\s+", " ").trim();
        return flat.length() <= max ? flat : flat.substring(0, max) + "…";
    }

    public record TrimResult(List<ChatMessage> messages, int droppedMessages, int tokens) {
    }
}

接入调用点,只需要在发送前包一层:

// 改造前
Response<AiMessage> r = chatModel.generate(memory.messages());

// 改造后:裁剪 + 打点
ContextBudgeter.TrimResult t = budgeter.trim(memory.messages(), 32768);
log.info("context tokens={} dropped={} turns={}",
        t.tokens(), t.droppedMessages(), t.messages().size());
Response<AiMessage> r = chatModel.generate(t.messages());
metrics.record("agent.context.tokens", t.tokens());

跑一个真实客服会话(用户 U1024 报订单 A123 延误,中途插问发票、插问退货政策、再回来问进度),日志里 tokens 会从 9K 一路爬到 34K,第 41 轮开始出现 dropped>0。此时检查模型回答,会发现它开始重复询问「您的订单号是多少」——这就是丢了不可重算信息的典型症状,也是明天要解决的事。

✏️ 今日动手

① 在你的工程里接入 ContextBudgeter,把手上的 system prompt + 全部工具 Schema 先估一遍,记下「固定脚手架占用」这个数字;② 故意把窗口阈值调到 6000,跑 10 轮会话,观察每轮 tokens 与 dropped;③ 记录模型在被丢弃历史后哪一轮开始答非所问,贴到笔记里,这将是 D2 对比摘要压缩效果的基线。

🔖 明日预告

今天只是把超出的部分丢掉,代价是模型失忆。明天做三件更细的事:滚动窗口如何保证不切断工具调用对、摘要压缩在哪一层触发、以及怎么从老对话里抽出结构化槽位来替代原文。