Prompt Caching 落地实践:让多轮 AI 交互的首字延迟与成本都降下来

今年团队把内部的技术文档库、工单排障系统和低代码平台全面接入了大模型做智能助手。初期跑 Demo 时大家都很兴奋,但真放到测试环境让大几十号人高频用起来,两个最现实的问题立刻浮上水面:首字等待时间(TTFT)太长,以及调用账单以惊人的速度消耗。

为了保证模型对复杂业务逻辑的遵从度,我们的 System Prompt 往往写得极长,里面塞了详细的角色设定、输出格式约束、安全边界,再加上十几个 Function Calling 的 JSON Schema 定义和几个 Few-Shot 样本,光静态的前置上下文就占了 4,000 到 8,000 个 token。用户哪怕只是输入一句“你好”或者在多轮对话里追问一个细节,服务端每次都要把几千个 token 的前置序列送去完整 Prefill 一遍。

前阵子主流模型提供商(Anthropic Claude、OpenAI、DeepSeek 等)和推理框架陆续推行了 Prompt Caching(提示词缓存 / 前缀缓存)。我们在客户端与中间网关做了一轮针对性的改造,把多轮交互的上下文缓存命中率拉到了 85% 以上。借着这篇笔记,把背后的机制、踩坑细节和数据做个记录。

为什么长 Prompt 的 Prefill 阶段那么慢?

要理解 Prompt Caching 的价值,得先回到 Transformer 架构的自注意力机制上。

大模型生成文本的生命周期明确切分成两个阶段:

1
2
3
4
5
6
7
8
9
10
11
12
+-------------------------------------------------------------------+
| 1. Prefill(首字生成前,并行计算) |
| Prompt (N tokens) ---> 计算全部 K、V 矩阵并写入内存 (KV Cache) |
| 计算复杂度 ~ O(N^2),耗时长,直接决定了 TTFT(首字延迟) |
+-------------------------------------------------------------------+
|
v
+-------------------------------------------------------------------+
| 2. Decode(流式吐字阶段,逐字自回归) |
| 每次仅基于上一个 token 计算新的 Q,复用前面缓存的 KV 矩阵 |
| 计算复杂度 ~ O(N),逐 token 流式输出 |
+-------------------------------------------------------------------+

在 Decode 阶段,由于前面所有 token 的 Key 和 Value 向量已经被暂存在了显存里(即大家常说的 KV Cache),模型每输出一个新词,只需要计算当前词的 Query 并与之前的 KV 做点积,这个阶段的延迟相对可控。

痛点全在 Prefill 阶段。在模型吐出第一个字之前,它必须把输入的所有 token 并行过一遍前向计算,并把这一长串上下文对应的 KV 矩阵填满显存。输入序列长度如果是 $N$,自注意力的计算量大致与 $N^2$ 成正比。当你的前置指令多达几千或上万 token 时,GPU 需要花费大量算力去反复咀嚼这批一模一样的话,用户在屏幕前就会面对数秒的白屏或 Loading 转圈。

如果同一个用户在多轮对话里聊了 10 轮,或者 100 个用户在同一时间打开应用,难道这几千个固定不变的静态 token 每次都要从头到尾被 GPU 重算一遍吗?

显然极度浪费算力。 Prompt Caching 的本质,就是在服务端或推理引擎层(如 vLLM、SGLang、Mooncake 等)把这一段公共前缀计算好的 KV 状态缓存在显存或内存里。只要下一次请求的前缀序列在字节级完全一致,引擎直接命中缓存读取 KV,跳过昂贵的 Prefill 矩阵乘法,瞬间进入 Decode 阶段。

缓存机制的差异:显式标记 vs 隐式前缀

虽然各家服务商都支持了缓存,但协议设计和收费逻辑有明显的分野。

1. Anthropic Claude:显式断点(Explicit Breakpoints)

Anthropic 的实现非常具象。它要求开发者在请求体的特定位置显式插入 cache_control 参数:

1
2
3
4
5
6
7
8
9
10
{
"system": [
{
"type": "text",
"text": "你是一个严谨的代码审查助手...",
"cache_control": { "type": "ephemeral" }
}
],
"messages": [...]
}
  • 生效门槛:Sonnet 3.5 要求至少包含 1024 个 token(Haiku 则是 2048 个)才会触发缓存。低于这个长度即使加了标记也不会缓存。
  • 缓存寿命:默认 TTL 是 5 分钟(每次命中会自动顺延)。
  • 经济账:创建缓存(Cache Write)需要加收约 25% 的费用,但命中缓存(Cache Read)只需要基础输入价格的 10%(即 0.1x)。只要同一份前缀在 5 分钟内被复用超过 2 次,整体成本就开始大幅下降。

2. DeepSeek 与 OpenAI:隐式自动前缀(Implicit Prefix Caching)

DeepSeek 和 OpenAI 的做法则对上层应用更透明,不需要传额外的控制字段。模型服务侧会自动按固定步长(比如以 64 或 128 个 token 为一个 Block)计算前缀的哈希值。

只要请求的前序 token 能对齐前面的 Block,底层就会自动复用 KV Cache。DeepSeek 在 API 返回的 usage 字段里明确给出了命中明细:

1
2
3
4
5
6
7
8
9
10
{
"usage": {
"prompt_tokens": 4210,
"completion_tokens": 180,
"total_tokens": 4390,
"prompt_tokens_details": {
"cached_tokens": 4096
}
}
}

DeepSeek 的缓存读取价格甚至低至未命中价格的 0.1x 左右,在超长文本的场景下优势极为夸张。

前端和网关架构最容易踩的四个坑

看起来原理很简单对不对?只要把静态内容放前面就好了嘛。但我们在落地过程中发现,如果不做专门的工程梳理,线上的缓存命中率很容易跌到 10% 以下甚至经常归零。

原因在于:前缀缓存是严格自左向右、字节级精确匹配的。

从第一个字符开始,只要中间有哪怕一个空格、一个换行、或者一个动态时间戳发生了变化,该位置之后的所有内容全部缓存失效(Cache Invalidation)。

坑一:把动态变量写在 System Prompt 开头

很多业务模板为了让模型感知当前环境,喜欢这样写模板:

1
2
3
4
5
6
7
8
// 错误示范:在最顶部插入动态变量
const systemPrompt = `
当前时间:${new Date().toISOString()}
当前用户ID:${currentUser.id}
系统环境:production

你是一个精通前端架构的技术专家,请遵循以下规范...(此处省略4000字系统规则)
`;

每一次请求进入,new Date().toISOString() 都在变化,导致整段几千字的规则虽然一字没改,但在哈希匹配眼里第一行就变了。后面的 4,000 字直接沦为陪葬,永远无法命中缓存。

修正原则:静态在前,动态后置。

把所有固定不变的背景规则、输出格式、代码规范提升到最顶层;把当前时间戳、当前上下文元数据挪到 System 尾部,或者当作一条单独的 User 辅助消息塞在最后:

1
2
3
4
5
6
7
8
9
10
11
12
// 规范改造:静态规则置顶,动态上下文沉底
const systemPrompt = [
{
type: "text",
text: BASE_SYSTEM_INSTRUCTIONS, // 4000字静态规则,稳定命中缓存
cache_control: { type: "ephemeral" }
},
{
type: "text",
text: `[Runtime Context]\nTime: ${currentHour}\nUserId: ${currentUser.id}` // 动态信息
}
];

坑二:Tool / Function Calling 顺序乱跳

现代 Agent 应用通常会挂载一批工具。通常我们会在代码里用一个普通对象或字典来维护所有 Tool,比如:

1
2
3
4
5
6
7
const tools = {
searchDoc: { ... },
executeSql: { ... },
sendMail: { ... }
};

const payloadTools = Object.keys(tools).map(k => tools[k]);

在部分 JS 引擎或不同中间件传输反序列化时,对象的遍历顺序可能不确定;或者某天某个开发者往对象中间插了一个新方法,导致导出的数组顺序变了。

在大模型 API 协议里,Tools 定义通常会被序列化在 Prompt 的最前端。如果 Tool A 和 Tool B 的顺序颠倒了一下,整个前缀哈希瞬间崩坏。

应对方案:在向模型发请求之前,必须对 Tools 数组按工具名称进行显式稳定的字典排序(Deterministic Sorting)。

1
payloadTools.sort((a, b) => a.function.name.localeCompare(b.function.name));

坑三:网关轮询负载均衡导致的缓存“穿透”

这是在微服务和多实例部署时最隐秘的杀手。

假设后台为了高可用,部署了 3 台自建的 vLLM 实例(Worker A、B、C),并在前面挂了一个普通的 Nginx 轮询(Round-Robin)。

1
2
3
用户请求 1 (Turn 1) ---> Nginx ---> Worker A (生成了 KV Cache 并保存在 A 的显存)
用户请求 2 (Turn 2) ---> Nginx ---> Worker B (没有 A 的缓存,全新 Prefill)
用户请求 3 (Turn 3) ---> Nginx ---> Worker C (再次 Miss,全新 Prefill)

用户明明在同一个会话窗口里持续追问,但由于轮询网关把连续的请求随机分发给了不同机器,导致每台机器都在重复创建缓存,命中率惨不忍睹。

应对方案:引入会话粘滞(Sticky Session)或基于 Prefix Hash 的一致性路由。

在网关层,我们提取请求中的 conversation_id(或者静态前缀的 SHA256 哈希),使用一致性哈希算法(Consistent Hashing)把同一个会话的请求固定路由到同一台 Worker 节点上。

坑四:多轮对话历史的非幂等裁剪

在长对话中,为了避免超出上下文窗口,前端通常会做滑动窗口截断(比如只保留最近 10 轮对话)。

常见的朴素实现是:

1
2
3
4
// 当数组长度超过 20 时,直接把头部 slice 掉
if (messages.length > 20) {
messages = messages.slice(-20);
}

直觉上看似乎很正常,但仔细推敲:

  • 第 19 轮:发送的是第 1~19 轮消息,前 18 轮有缓存。
  • 第 20 轮:发送的是第 1~20 轮消息,前 19 轮有缓存。
  • 第 21 轮:触发截断,发送变成了第 2~21 轮消息!

第一条消息被切掉后,从原本第 2 轮开始的位置起,所有 token 在整串上下文里的绝对位置全都往前偏移了!Transformer 的位置编码(Positional Encoding)完全错位,导致此前缓存在显存里的整条对话历史彻底失效,又得重新跑一遍大段的 Prefill。

应对方案:块状归档与分段截断。
不要逐条消息滑窗。通常的做法是保留前置第一轮和系统 Prompt,中间历史以一个较大的块(例如每 10 轮)为单位进行聚合或摘要,只有跨越块边界时才做清理,最大限度维持前序骨架的持久稳定。

改造前后的真实压测数据

我们在一个典型的知识库答疑场景下做了实测对比:

  • 前置上下文:包括产品操作手册、FAQ 和 8 个 API Schema,合计约 6,200 tokens。
  • 模拟测试:10 个虚拟并发用户,每个用户连续发起 5 轮业务提问,单轮问题长度 50~150 tokens。
  • 模型选择:Claude 3.5 Sonnet 与 DeepSeek-V3。

测量指标主要看两个核心维度:首字延迟(TTFT)与输入 Token 费用。

1
2
3
4
5
6
指标项                        未开启 Cache           开启 Cache(第 2~5 轮平均)    收益幅度
-------------------------------------------------------------------------------------------------
Claude TTFT 2,450 ms 460 ms -81.2%
DeepSeek TTFT 1,820 ms 310 ms -82.9%
5 轮总输入计费 Tokens 31,000 tokens 8,680 计费等效 tokens -72.0%
首字打字机等待体感 明显停顿 (转圈 2 秒+) 按下回车后几百毫秒秒弹字 体验质变

在没有缓存前,多轮对话的体验极其笨重:用户每问一句话,服务端都要把前头那本 6,000 字的“手册”逐字重新读一遍,前端界面往往要挂着 loading 状态转圈两三秒。

开启并理顺了缓存结构之后,除了第一问需要消耗 2 秒左右建立初始缓存,后续第 2 轮到第 5 轮的 TTFT 直接压缩到了 300~400 毫秒以内。用户一敲回车,打字机几乎是瞬间开始往外吐字。

更可观的是账单:由于输入 token 占了我们整体 token 消耗的 80% 以上,在命中率达到 85% 之后,单月的 API 支出直接腰斩。

写在最后

在这一波大语言模型应用落地的浪潮里,很多人一开始都把注意力放在模型微调(Fine-tuning)、RAG 切分算法或者 Agent 自主规划上。但当产品真正要进入生产环境接受检验时,工程落地的基本功往往决定了产品能走多远。

Prompt Caching 表面看只是云厂商给的一个接口参数,但它要求前端、中间层和推理后端对上下文数据的生命周期有极强的掌控力。就像多年前做静态资源 CDN 缓存和 HTTP 协商缓存一样——把静态的留给基础设施,把动态的收敛到边界,无论底层技术怎么变,优秀的工程架构逻辑始终是相通的。

------ 有问题请 留言给我哦! 也欢迎入群讨论! 点我呀! ------

评论加载中…

0%