# Agent 为何到第 60 步就失忆，上下文压缩怎么救

> 一个由轻到重的六步循环，在每次调用模型前决定 Agent 的历史哪些该留。

原文: https://fdetimes.net/zh/guides/context-compaction-long-running-agents/

一个为物流客户处理工单的 Agent，到第 60 步又调用了第 5 步已经调用过的 API，因为先前的结果已被截掉，或者埋在了几十块 JSON 下面。这只是一个假设场景，却并不陌生。模型并没有变差，变差的是上下文管理。

这几十块 JSON 从两方面造成损害。每次调用模型都得带上它们，而 IBM 解释说，计算需求随序列长度的平方增长。

与此同时，第 5 步的结果恰好落在模型最不擅长阅读的位置。IBM 把这称为“lost in the middle”（迷失在中间）现象：当模型需要仔细处理长上下文中间的信息时，表现会变差。

已经用完的 JSON 也并非无害。Redis 提醒，上下文窗口能容纳的内容有限，无关信息会污染上下文，拉低 Agent 的推理质量。因此，要让 Agent 长时间运行，办法是选择保留什么，而不是塞进更多历史。

前线部署工程师（FDE）经常遇到这种情况：Agent 在演示环境里完美跑完十轮，到了客户环境，会话进行三小时后就开始遗忘。下面的指南会搭建一个六步压缩循环，从最轻的手段到最重的。

## 要构建什么，需要准备什么

最终产物是一个函数 `manage_context(messages)`，在每次调用模型前运行。你需要 Python、一个会调用工具并把历史存为 `{"role", "content"}` 消息列表的 Agent，以及一个调用 LLM 的函数。下面的代码是**用于学习的简化版本**：`count_tokens` 和 `call_llm` 只是占位，需替换为你所用模型的 tokenizer 和 SDK。

## 第 1 步：先测量，再压缩

LangChain 文档给出的基本策略是：统计消息历史的 token 数，接近上限时进行裁剪。触发阈值要设得比真实上限低，为总结调用本身留出空间。

```python
LIMIT = 100_000          # 自行选定的阈值，小于真实的上下文窗口
TRIGGER = int(0.8 * LIMIT)

def need_compaction(messages):
    return count_tokens(messages) > TRIGGER
```

**检查：**每轮结束后打印 token 数。它通常在返回大量数据的工具调用之后陡增，这些地方要最先处理。

## 第 2 步：清除旧的工具结果，最便宜也最安全

Anthropic 把清除工具结果列为最安全、最轻量的压缩方式之一：丢弃已经用过的原始工具输出。Agent 读完 5,000 行 JSON 并得出结论后，几乎不再需要回头读原文。

```python
def clear_old_tool_results(messages, keep_last=3):
    tool_idx = [i for i, m in enumerate(messages) if m["role"] == "tool"]
    for i in tool_idx[:-keep_last]:
        messages[i]["content"] = "[旧的工具结果已清除；如有需要请查看笔记]"
    return messages
```

要注意的细节是，函数替换的是内容，而不是删除消息。这样历史结构保持完整，与下一步的警告相呼应。**检查：**重跑同一场景，对比前后的 token 数。

## 第 3 步：切分时不破坏历史

LangChain 文档指出，从状态中移除消息后，剩下的历史必须仍然有效；例如，工具调用和它的工具结果必须在一起。如果切分点落在一对中间，历史就会以一条孤立的工具结果开头，下一次模型调用可能失败。

```python
def safe_cut_index(messages, cut):
    # 把切分点往后推，直到历史不再以孤立的工具结果开头
    while len(messages) > cut and messages[cut]["role"] == "tool":
        cut += 1
    return cut
```

这是简化版本。如果你的某个工具调用会返回多个结果，应按调用 ID 配对，而不是只看 role。

## 第 4 步：做总结，因为单纯裁剪会丢信息

LangChain 也承认，从队列中丢弃消息可能丢失信息。正因如此，该库提供了 `SummarizationMiddleware`，用聊天模型来总结历史。本质上，这就是 Anthropic 所定义的压缩：总结一段快要装满的对话，再基于摘要继续。

```python
COMPACT_PROMPT = """总结之前的对话，让 Agent 能够继续工作。
原样保留：用户的目标、已做出的决策、所有 ID/文件名/数字、
未解决的错误、进行中的工作以及下一步。
删去：寒暄、已用过的工具输出、已放弃的尝试。"""

def compact(messages, old_summary, keep_recent=10):
    cut = safe_cut_index(messages, len(messages) - keep_recent)
    old, recent = messages[:cut], messages[cut:]
    summary = call_llm(COMPACT_PROMPT, previous=old_summary, new=old)
    head = {"role": "user", "content": "上一段会话的摘要：\n" + summary}
    return [head] + recent, summary
```

代码体现了两个设计选择。第一，函数接收 `old_summary`，只输入新材料。Redis 把这种做法描述为每当有新数据时增量更新摘要，而不是从头重写。

第二个选择在提示词里，按 Anthropic 推荐的思路编写：先最大化召回，确保提示词不遗漏任何相关内容，再通过删减多余内容提高精确度。

这个顺序是有原因的。Redis 指出，总结的代价是可能丢掉那些眼下看似无关、日后却很关键的细节。少一个客户 ID，危害远大于多几句话。

**结果是什么样的？**回到那个物流 Agent，以下数字为示意而虚构。历史达到 85,000 个 token，超过第 1 步中 80,000 的 `TRIGGER` 阈值。第 2 步不足以降下来，于是 `compact` 运行，上下文开头被替换为这样一段：

```text
上一段会话的摘要：
- 目标：处理客户的延迟送达工单，在今天下班前回复
- 已决定：不退款，提供免费重新配送
- ID：订单 ORD-1042，运单 VD-88317
- 未解决的错误：运单查询 API 已超时两次
- 下一步：重试查询 API，然后起草给客户的邮件
```

这五行替代了几十轮对话和工具输出。要检查的是 ID 是否完整保留：如果摘要写的是“一笔延迟的订单”而不是 `ORD-1042`，Agent 就会再次调用 API，就像开头例子里第 60 步那样。**检查：**`compact` 运行后立即打印 token 数，并亲自阅读摘要，至少在最初几次要这样做。

## 第 5 步：把重要状态移到上下文之外

有些内容不应依赖摘要的质量。Anthropic 把这种技术称为结构化笔记（structured note-taking），也叫智能体记忆（agentic memory）：Agent 定期把笔记写入上下文窗口之外的记忆存储。

```python
def write_note(key, value, path="agent_notes.md"):
    with open(path, "a", encoding="utf-8") as f:
        f.write(f"- {key}: {value}\n")
```

把这个函数注册为工具，然后在系统提示词中要求 Agent 记录每一个已敲定的决策。第 2 步的占位符指向这个文件，Agent 就知道该去哪里找。

繁重的工作分支，比如读完整个日志归档，可以交给子 Agent。按照 Anthropic 的描述，子 Agent 在干净的上下文中工作，只把精简后的摘要返回给主 Agent。

## 第 6 步：摘要也需要测试

停在第 5 步、默认摘要没问题是有风险的，因为总结这一步本身就可能丢失细节或编造细节。卡内基梅隆大学的 SEI 团队认为，单一指标的评测尚未被证明有效，所以目前的做法是使用一整套指标。

SEI 还指出，许多准确性指标需要参考摘要，而参考摘要往往没有；忠实度指标则能发现部分编造错误。

下面是一套最小的测试（仅为建议，不是标准）：

```python
def eval_summary(summary, must_keep, source_text):
    recall = sum(k in summary for k in must_keep) / len(must_keep)
    ratio = count_tokens(summary) / count_tokens(source_text)
    unsupported = call_llm("列出 SUMMARY 中未出现在 SOURCE 里的陈述",
                           summary=summary, source=source_text)
    return {"recall": recall, "compression": ratio, "unsupported": unsupported}
```

`must_keep` 是你从真实日志中自行标注的列表，用来替代你手头没有的参考摘要。以第 4 步的例子来说，这个列表至少要包含 `ORD-1042` 和 `VD-88317`。

这三个数字必须一起看：召回率高但压缩比差，说明你什么也没压缩；压缩比好但 `unsupported` 列表很长，说明摘要在编造内容。

## 仍会拖垮长会话的错误

第一个错误是本来清除旧工具结果就够了，却直接跳到总结，这会多花一次模型调用，还增加丢失细节的风险。其次是按固定消息数切分，而不检查工具调用与结果是否成对。

还有一种是每次都从头重新总结，细节在一轮轮总结中逐渐流失。最难发现的是把摘要放在上下文中间。由于模型不擅长利用长上下文中间的信息，应把摘要放在开头，把最近几轮放在末尾。

## 这项技能在客户现场如何体现

它通常以抱怨的形式出现：“Agent 跑久了就变笨”“每个会话的成本高得反常”。第一件事是要一份出问题的会话日志，逐轮画出 token 数，找出是哪个工具在撑大上下文。

阅读 FDE 或 Agent 工程师岗位的职位描述时，留意“long-running agents”“context management”“memory”这类字眼。在简历上，“用过 LangChain”说明不了什么。要写清楚每个会话的 token 减少了百分之多少、必须保留的细节召回率维持在多少，以及用哪套测试衡量。

**要点:** 只有在压缩之后能够测量 Agent 还记得什么、有没有编造内容，上下文压缩才值得信任。

一个跑了三小时仍记得第一分钟客户 ID 的 Agent，客户立刻就能感受到效果，尽管他们永远看不到背后的 `compact` 函数。

**本周动手试试:**

- 拿一份你自己真实的长 Agent 会话日志，标出 10 个必须保留的细节（ID、决策、未修复的错误），然后运行压缩提示词，数一数保留下来几个。
- 把 clear_old_tool_results 函数加进你正在构建的 Agent，在同一场景下对比前后的 token 数。
- 写一个测试，确保每次切分后，历史不会以一条丢失了对应工具调用的工具结果开头。

## 信源

- [Effective context engineering for AI agents (Anthropic Engineering)](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)

- [Short-term memory (LangChain docs)](https://docs.langchain.com/oss/python/langchain/short-term-memory)

- [Build AI agents with short-term & long-term memory in Redis](https://redis.io/blog/build-smarter-ai-agents-manage-short-term-and-long-term-memory-with-redis/)

- [What is a context window? (IBM Think)](https://www.ibm.com/think/topics/context-window)

- [Evaluating LLMs for Text Summarization: An Introduction (SEI, CMU)](https://www.sei.cmu.edu/blog/evaluating-llms-for-text-summarization-introduction/)
