《AI Agent 技术原理与架构·运行时、协议与系统架构》7.3 前缀缓存与上下文复用

模型请求的 prefill 成本与上下文长度成正比,多个请求共享相同的系统提示与工具定义时,它们的前缀可以被 KV 缓存复用,后续请求只需 prefill 差异化部分。实验维护一个最长公共前缀缓存,模拟一组请求的 prefill 节省,演示系统提示变化如何缩短命中前缀。结论是缓存收益取决于前缀稳定性。

以下 token 数、前缀长度与请求序列均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。500 个 SYS token 是讲解用的模型,真实系统的缓存命中与 KV 语义以推理服务商的实现为准,但"共享前缀可被复用、前缀变化会缩短命中"这一条不变。

7.1、7.2 讲了组装与压缩,解决"放什么进上下文"。这一节从成本看同一个问题:不管放进什么,prefill 都要花与上下文长度成正比的钱。请求之间共享的固定前缀,能不能只算一次?

答案是可以,这就是前缀缓存(prefix cache)。多个请求共享相同的系统提示与工具定义时,它们的前缀是相同的,前一个请求的 KV 缓存可以直接复用,后续请求只需 prefill 差异化部分。这一节实现一个最长公共前缀缓存,量化节省,并演示前缀变化如何削弱收益。

为什么共享前缀值得缓存

模型请求的 prefill 成本与上下文长度成正比(见卷一 4.1)。一次 Agent 运行里,同一个系统提示、同一组工具定义会出现在一连串请求中——每次都是同样的 500 token 前缀。

请求前缀差异化部分全量 prefill
1SYS(500)t1, p1502
2SYS(500)t1, q1502
3SYS(500)t2, r1502

如果三个请求各 prefill 502 token,总计 1506;如果复用共享的 500 token 前缀,第二个请求只需 prefill 差异化部分(2 token)+ 命中缓存的前缀,总计大幅下降。缓存收益 = 共享前缀长度 ×(请求数 − 1)。

前缀缓存怎么失效

前缀缓存不是永远命中。缓存维护的是"已注册请求的最长公共前缀"——前缀变化会缩短命中:

事件前缀变化命中长度
请求 1、2 共享 SYS前缀 = SYS + [t1]501
请求 3 前缀变成 SYS[:300]公共前缀缩到 300300

系统提示加了一个字、工具定义换了一个参数,前缀就变了,缓存命中从 501 缩到 300。缓存收益取决于前缀稳定性:前缀越稳定,命中越长;前缀越常变,缓存越不值。这解释了为什么 7.1 组装要稳定系统提示、7.2 压缩要避免每次变化。

最小实验:最长公共前缀缓存

实验实现 PrefixCache(register 更新最长公共前缀并返回命中长度),模拟一组请求的 prefill 节省。

# file: agp_lab/prefix_cache.py | write
# tier: 3
# verify: python3 -m unittest tests.test_prefix_cache
"""前缀缓存与上下文复用:共享前缀与 prefill 节省。

模型请求的 prefill 成本与上下文长度成正比。多个请求共享
同样的系统提示与工具定义时,它们的前缀是相同的,可以被
KV 缓存复用,后续请求只需 prefill 差异化部分。

本模块维护一个"最长公共前缀"缓存,模拟一组请求的 prefill
节省,并演示系统提示变化如何缩短命中前缀。
"""
from __future__ import annotations

from typing import Any


class PrefixCache:
    """维护已注册请求的最长公共前缀。"""

    def __init__(self) -> None:
        self.common: list[Any] = []

    def register(self, tokens: list[Any]) -> int:
        """注册一个请求,更新最长公共前缀,返回命中长度。"""
        if not self.common:
            self.common = list(tokens)
            return 0
        length = self.longest_common(tokens)
        self.common = self.common[:length]
        return length

    def longest_common(self, tokens: list[Any]) -> int:
        if not self.common:
            return 0
        length = 0
        for left, right in zip(self.common, tokens):
            if left != right:
                break
            length += 1
        return length


def simulate(requests: list[list[Any]]) -> dict[str, Any]:
    """requests 为 token 序列列表,返回总 prefill 与缓存节省。"""
    cache = PrefixCache()
    total_prefill = 0
    saved = 0
    for request in requests:
        hit = cache.register(request)
        total_prefill += len(request)
        saved += hit
    return {
        "requests": len(requests),
        "total_prefill": total_prefill,
        "cached_prefix_saved": saved,
        "with_cache": total_prefill - saved,
    }


SYS: list[str] = ["s"] * 500


def demo() -> dict[str, Any]:
    requests = [
        SYS + ["t1", "p1"],
        SYS + ["t1", "q1"],
        SYS + ["t2", "r1"],
    ]
    cache = PrefixCache()
    hits = [cache.register(request) for request in requests]
    changed_request = SYS[:300] + ["z", "t3"]
    changed_hit = cache.register(changed_request)
    return {
        "hits": hits,
        "changed_hit": changed_hit,
        "simulation": simulate(requests),
    }


if __name__ == "__main__":
    for key, value in demo().items():
        print(f"{key}: {value}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.prefix_cache

输出:

hits: [0, 501, 500]
changed_hit: 300
simulation: {'requests': 3, 'total_prefill': 1506, 'cached_prefix_saved': 1001, 'with_cache': 505}

三段输出对应三件事:

  1. hits=[0, 501, 500]:第一个请求没有可复用前缀,命中 0;第二个请求与第一个共享 SYS + [t1],命中 501;第三个请求与公共前缀只共享 SYS,命中 500。命中随公共前缀收缩而下降——请求 1、2 多了共同的 t1,请求 3 只共享 SYS。
  2. changed_hit=300:前缀变成 SYS[:300] 的请求命中只有 300——系统提示被改了前 300 个 token 之后的内容,公共前缀立刻缩水。这是"缓存收益取决于前缀稳定性"的直接证据。
  3. simulation:三个请求全量 prefill 1506 token;启用缓存后 with_cache=505,节省 1001。1001 = 501 + 500,恰好是第二个、第三个请求复用的前缀长度之和。

一个值得点破的细节:hits=[0, 501, 500] 中第二个请求命中 501(SYS 的 500 + 共享的 t1 一个 token),第三个请求命中 500(只共享 SYS)。公共前缀是"所有已注册请求的交集"——注册新请求时,公共前缀可能变短(从 501 缩到 500),因为它要同时匹配所有历史请求。这与 7.2 的"按需压缩"形成对照:压缩是主动丢内容,缓存是自动缩前缀。

前缀缓存的收益上限,取决于前缀能稳定多久。生产里三个实践让前缀更稳定:把易变的请求特有内容放差异化部分,系统提示与工具定义冻结发布(不随每次请求微调),以及用 7.2 的压缩策略控制记忆片段的波动。前缀稳定是缓存收益的前提,反过来,缓存收益也反过来激励前缀稳定。

实践让前缀稳定让前缀不稳
固定系统提示是每次微调
工具定义冻结是工具频繁变更
记忆放差异化段是记忆混进前缀
压缩控制波动是每次压缩结果不同

缓存还有一个运维维度:命中率要监控。命中率突然下降,通常意味着某个上游改了前缀——系统提示改了、工具定义变了、记忆策略调整了。命中率曲线是前缀稳定性的仪表盘,比翻代码更快发现谁动了前缀。

最后,缓存语义要区分前缀命中与全部命中。实验里的缓存只保证公共前缀复用;如果两个请求前缀完全相同,理论上可以全量复用。生产 KV 缓存通常还有更细的命中粒度,但"共享前缀越长,命中越值"这个方向不变。

缓存还要考虑容量与淘汰。KV 缓存占显存,不能无限攒:缓存什么、保留多久,是容量规划问题。两个原则:复用概率高的前缀优先保留(系统提示、热工具的缓存命中率高),差异化部分不缓存(一次性的请求内容,缓存了也没第二次命中)。

缓存对象复用概率建议
系统提示高长期缓存
工具定义中高缓存,工具变更时失效
检索文档低缓存短窗口
差异化部分无不缓存

缓存与压缩的配合也直接影响命中率。 7.2 说过压缩结果要稳定,这里接上:稳定压缩保持前缀不变,缓存命中率才稳。反过来,缓存命中率的变化也暴露压缩的不稳定——命中率掉了,先查压缩策略是不是变了。缓存不是独立的优化,它是 7.1 组装、7.2 压缩效果的放大器:前缀越稳,放大越明显。

前缀缓存与上下文组装是同一个决策的两面。 7.1 组装决定"请求里放什么",直接影响前缀有多稳定;7.3 缓存决定"稳定的前缀省多少"。组装不稳定,缓存策略再精也白搭;组装稳定了,缓存收益自动变大。优化缓存的第一步,常常是去稳定组装,而不是去调缓存。

决策影响收益方向
组装顺序稳定前缀一致命中率↑
系统提示冻结前缀不变命中率↑
工具定义冻结前缀不变命中率↑
记忆不混前缀前缀干净命中率↑

还有一个规模视角:缓存是幂等优化的放大器。命中率提升 20%,在多租户高频请求下放大成整体成本的 20% 下降;在低频场景下放大有限。评估缓存收益要看请求的重复度——重复度决定缓存值不值:一次性的请求流,缓存几乎没收益;同一前缀高频复用的场景(客服、工具类 Agent),缓存收益最大。

缓存与容灾:KV 缓存是热数据,故障迁移时缓存要不要跟着走?跟走则故障时命中率不掉、但迁移成本高;不跟走则故障期缓存重建、prefill 成本回弹。缓存策略要写进容灾方案,而不是容灾后缓存自动失效就完事。

前缀缓存还有一个安全维度:缓存的内容可能过敏感。 系统提示、工具定义、检索文档缓存在共享 KV 缓存里,别的请求(或别的租户)命中同一前缀,会不会读到不该读的内容?前缀缓存默认按"前缀内容"而不是按"请求归属"复用——敏感上下文要排除在可共享前缀之外,或按租户隔离缓存。

前缀内容共享风险处理
公开系统提示低可共享
含租户数据中租户隔离
含秘密/密钥高不缓存

命中检测也要防"前缀近似"。 实验用的是严格前缀相等(token 级一致才命中);生产 KV 缓存有的支持"公共前缀长度"计算,允许部分复用。部分复用要保证"复用的是真正共享的部分"——前缀边界切错了,复用的内容就不一致,模型行为会偏差。缓存命中的正确性,与命中率一样重要。

前缀缓存的"失效广播"要跟工具/策略变更联动。 工具定义更新、系统提示调整后,缓存的前缀过期了——不失效的话,后续请求命中旧前缀、读到旧工具定义,Agent 按旧 schema 调用就出错。缓存失效要绑定变更发布:工具注册表、策略配置有版本号,前缀缓存带上版本号判断命中,版本不一致就失效重建。

变更源缓存动作后果如果不做
工具定义更新失效对应前缀按旧 schema 调用
系统提示调整失效系统前缀读到旧策略
压缩策略变化失效前缀命中新旧混合

架构判据

前缀缓存是否合格,用五条判据检查:

判据合格的样子不合格的样子
共享前缀复用差异化 prefill + 复用前缀每个请求全量 prefill
命中可量化命中长度/节省有明确数字不知道省了多少
前缀稳定系统/工具定义稳定每次请求前缀都变
失效可观察前缀变化缩短命中可追踪缓存收益突然消失
组装配合7.1 稳定前缀,7.2 压缩配合组装随意变更前缀

判据第三条是缓存收益的根:前缀稳定性决定缓存价值。 判据第五条提醒缓存不是孤立的——7.1 组装、7.2 压缩与 7.3 缓存要配合:组装稳定前缀、压缩控制变化、缓存才能复用得起来。

小结

  • prefill 成本与上下文长度成正比;请求间共享的固定前缀可以被 KV 缓存复用。
  • 缓存收益 = 共享前缀长度 ×(请求数 − 1);复用前缀后只需 prefill 差异化部分。
  • 前缀变化会缩短命中:系统提示一变,公共前缀立刻缩水。
  • 缓存收益取决于前缀稳定性,与 7.1 组装、7.2 压缩配合才值。

阅读导航:上一节:7.2 压缩、摘要与预算分配 · 下一节:8.1 向量、倒排与图存储 。

常见错误与边界

  1. 每个请求全量 prefill。 共享前缀不缓存,等于每次都重算同样的 500 token;要复用。
  2. 前缀不稳定。 系统提示、工具定义每次微调,公共前缀缩水,缓存收益消失;前缀要稳定。
  3. 不知道省了多少。 没有命中量化的缓存是无底洞;要跟踪命中长度与节省。
  4. 把缓存当无限。 公共前缀是所有历史请求的交集,新请求可能让它变短;缓存命中会衰减。
  5. 组装随意变更前缀。 组装稳定前缀、压缩控制变化、缓存复用,三者要配合而不是互拆。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图