提示词缓存的成本账:钱不是省在“缓存”上,是省在“命中”上
前言
一个客服问答机器人,system prompt 里塞了三样东西:产品手册摘要(约 6000 token)、20 个工具的定义(约 4000 token)、十几条 few-shot 示例(约 2000 token)。加起来一万两千多 token,而用户真正的提问平均只有 30 token。
这个比例很荒唐:为了回答 30 个 token 的问题,每次都要重新读 12000 个 token。
于是给请求加了缓存标记。按官方文档的折扣算,这部分输入的价格能降到原价的十分之一,账面上应该省下九成。但第一个月的账单出来,输入 token 的计费几乎没变。
排查发现缓存命中数是 0。原因不是"缓存没生效",而是每一万个请求里没有一个能和上一个请求共享前缀。system prompt 开头写了一句:
当前时间:2026-11-01 07:41:33
每次请求时间戳都不一样,从第一个 token 开始就不匹配,后面一万两千个 token 全部作废。
这个坑很典型。提示词缓存不是"把内容存起来下次能用",而是"从这个位置往前的 token 序列完全一致,才能复用"。 差一个字符,整段失效。
一、命中条件:严格的 token 前缀匹配
1.1 是按 token 前缀切,不是按语义
先纠正一个最常见的误解:提示词缓存和语义缓存是两回事。
| 提示词缓存 | 语义缓存 | |
|---|---|---|
| 匹配方式 | 请求前缀的 token 序列完全一致 | 请求 embedding 相似度超阈值 |
| 命中单位 | token 前缀 | 整个问答对 |
| 能省什么 | 输入 token 的计费 | 整次推理(连输出都不用生成) |
| 风险 | 无,命中即等价 | 有,错误命中会返回错答案 |
| 谁负责 | 推理服务端自动 | 应用自己实现 |
提示词缓存是无损的:命中的那段前缀,和你重新发一遍完全等价,不存在"缓存过期导致答案错"的问题。它省的是计算,不是逻辑。所以它的唯一敌人是"前缀不一致"。
前缀匹配意味着一个链式关系:前缀里第 N 个 token 变了,第 N 个之后的所有缓存全部失效,但第 N 个之前仍然有效。
这个性质很关键,它决定了内容该怎么排序——越稳定的越靠前,越易变的越靠后。
[ system: 角色设定 ] ← 几乎永不变,最值得缓存 [ system: 工具定义 ] ← 版本级变化,值得缓存 [ system: few-shot 示例 ] ← 版本级变化,值得缓存 [ system: 长文档 / 知识片段 ] ← 每请求可能不同,能否缓存看场景 [ user: 本轮问题 ] ← 每请求必变,永远命不中
1.2 最小长度门槛与计量粒度
缓存不是免费的记账动作,服务端要为每个前缀维护 KV 状态,所以都有门槛:
- 低于最小长度(业界常见是 512~2048 token,具体看模型)的段落不会被缓存,标了也不生效
- 计量按固定粒度向上取整(比如 128 token 一段),所以 1100 token 的前缀可能按 1152 计
这条门槛有个直接推论:别给零碎的小段落加缓存标记。 一个 300 token 的模板加标记,除了增加请求体的复杂度,什么都不会发生。
1.3 TTL 与计费倍率:写和读不是一个价
这是最容易算错的地方。缓存不是"存下来免费读",而是:
- 缓存写入(cache write):比正常输入贵,常见倍率 1.25x(短 TTL)或 2x(长 TTL)
- 缓存读取(cache read):比正常输入便宜很多,常见 0.1x
- 未命中:按正常价格算,如果这次本该写缓存却没写成功,那 1.25x 也白花了
把这个关系写成一个式子。假设一段前缀正常价格是 1 个单位,后面跟着 N 次读取:
不缓存: 1 × (1 + N) = 1 + N 缓存(5min TTL): 1.25 + 0.1N 两者相等时: 1.25 + 0.1N = 1 + N → N ≈ 0.28
也就是说,只要这段前缀在 5 分钟内被读到一次,就已经回本了。 换成 2x 写、1 小时 TTL:
2 + 0.1N = 1 + N → N ≈ 1.11
两次读取回本。
这个结论有点反直觉:盈亏平衡点低到不需要讨论。所以真正的问题从来不是"缓存划不划算",而是"它到底会不会命中"。命中率是 0 的时候,你多付的是 1.25 倍的写成本,纯亏。
二、哪些内容值得放进可缓存段
2.1 工具定义:最值得缓存,也最容易被自己搞坏
20 个工具的 JSON Schema,序列化出来 4000 token 很常见。这部分内容在一个版本内完全稳定,是最理想的缓存对象。
但它有个隐藏问题:工具列表经常是运行时动态拼的。 比如按用户权限过滤:
# 反例:每次请求都重新拼,顺序还依赖字典遍历
tools = []
for name, spec in ALL_TOOLS.items():
if user.has_permission(spec["scope"]):
tools.append(spec)
payload = {"system": BASE_PROMPT, "tools": tools, "messages": msgs}
ALL_TOOLS 是个 dict,不同进程/不同 Python 版本遍历顺序可能不同;即使顺序稳定,用户 A 有 15 个工具、用户 B 有 18 个,两人的前缀就是两棵不同的树,谁也命中不了谁。
如果工具数量多、用户权限差异大,缓存会被切成很多互不相交的小块,每块命中率都很低。
改法:把工具定义按固定顺序全量下发,权限在执行层拦,不在定义层删。
# 正例:定义全量、顺序固定、内容稳定 → 全体用户共享同一段前缀
TOOL_SPECS = sorted(ALL_TOOLS.values(), key=lambda s: s["name"])
TOOL_BLOCK = json.dumps(TOOL_SPECS, ensure_ascii=False, sort_keys=True)
# 权限在执行时校验,不参与 prompt 构造
def execute(tool_name, args, user):
spec = ALL_TOOLS[tool_name]
if not user.has_permission(spec["scope"]):
return {"error": "permission_denied", "tool": tool_name}
return spec["fn"](args)
代价是模型能看到它无权调用的工具,可能白调一次。但这个代价比"每个用户一棵独立缓存树"小得多——而且从安全角度看,把权限判断放在执行层本来就是更正确的做法,因为 prompt 层的隐藏从来不是安全边界。
2.2 长文档 / 知识片段
文档问答场景里,同一份文档会被反复问。这种"同一文档、不同问题"的流量模式,是缓存最理想的形态:
[ 文档全文 8000 token ] ← 缓存这一段 [ 用户问题 ] ← 变化
前提是文档内容必须逐字节一致。这里有个坑:如果文档是从数据库读出来再拼接的,中间可能夹带了 更新于 2026-11-01 03:12、文档 ID: 8823 这类元数据,而它们本该放在问题侧。
2.3 多轮对话历史
多轮是缓存收益最大的场景,因为历史只增不减。第 10 轮时前缀可能有 8000 token,其中 7900 是前面九轮的累积。
做法是在历史末尾打一个断点,下一轮这个断点之前的内容全部命中:
轮次 1: [system][u1][a1] 写入缓存至 a1 轮次 2: [system][u1][a1][u2][a2] 命中 system~a1,新写 a2 轮次 3: [system][u1][a1][u2][a2][u3][a3] 命中至 a2,新写 a3
注意断点数量是有限的(常见 4 个)。如果同时想要"system 一个断点 + 文档一个断点 + 历史一个断点",就已经用掉三个。多轮场景下通常把断点全给历史的最新位置,让长尾自然滑动。
2.4 哪些不该进缓存段
| 内容 | 为什么不该缓存 |
|---|---|
| 每请求都不同的短片段 | 低于最小长度,标了也不生效 |
| 用户个性化的开头 | 把共享前缀切成 N 份,命中率按用户数倒数衰减 |
| 时间戳、请求 ID、trace ID | 一个字符就让后面全部失效 |
| 随机排序的检索结果 | 顺序一变就不匹配,且本来就不该期望命中 |
| 温度采样参数拼接进 prompt | 参数应该走 API 字段,不该进文本 |
最后一条值得单独说:把 temperature=0.7 这类参数写进 system prompt 文本里,是个常见但不必要的做法,它让你每次调参都在改前缀。
三、把命中率搞坏的四种写法
3.1 时间戳进了 system
就是开头那个例子。修法很简单:需要时间信息就放到用户消息侧,或者用 API 提供的独立字段。
# 反例
system = f"你是客服助手。当前时间 {now()}。\n{BASE_PROMPT}"
# 正例:稳定部分在前,易变部分在后
system = BASE_PROMPT
user_msg = f"[当前时间 {now()}]\n{question}"
如果确实需要模型知道当前时间,也可以让模型自己调一个 get_current_time 工具——这样时间不进 prompt,前缀永远稳定。
3.2 JSON 序列化键序抖动
json.dumps 默认按插入顺序输出,键序取决于字典怎么构造的。同一个 schema 从 YAML 加载和从数据库加载,键序可能不同:
# 不稳定 TOOL_BLOCK = json.dumps(spec, ensure_ascii=False) # 稳定 TOOL_BLOCK = json.dumps(spec, ensure_ascii=False, sort_keys=True)
sort_keys=True 加一个参数,命中率可能从 0 变成 90%。这类问题特别隐蔽,因为肉眼看两段 prompt 内容完全一样,只有序列化后的字节序不同。
更彻底的写法是干脆不走运行时序列化——把拼好的 prompt 存成文件或常量,版本管理,直接读。
3.3 冷启动并发击穿
这个坑更偏工程。缓存在第一个请求时才写入。如果服务刚扩容,50 个请求同时到达,50 个都看到"还没缓存",于是50 个都付了 1.25 倍的写入成本,49 个纯亏。
# 粗糙但有效的做法:单飞
import threading
_warm_lock = threading.Lock()
_warmed = set()
def ensure_warm(prefix_key, build_request):
if prefix_key in _warmed:
return
with _warm_lock:
if prefix_key in _warmed: # 双检
return
build_request() # 发一个最小请求把 cache 写进去
_warmed.add(prefix_key)
更实际的做法是在扩容/发版后,先由一个后台任务发一个小的预热请求(哪怕让它回答一个无意义的问题),把缓存写进去,再放开流量。
3.4 检索结果直接拼进 system
RAG 场景里,如果把检索到的文档拼进 system prompt 的开头,那就等于每个问题一棵新的前缀树:
system = f"{BASE_PROMPT}\n\n参考资料:\n{retrieved_docs}\n\n请回答"
同一份文档如果被两个问题检索到,只要拼接格式和顺序不同,仍然不匹配。
修法是顺序反转:稳定资产在前,检索结果在后,且检索结果按固定规则排序(比如按文档 ID 升序,而不是按相似度分数排序——分数是浮动的)。
[ system: 角色 + 工具 + 示例 ] ← 缓存 [ system: 检索结果(按 doc_id 排序) ] ← 可能命中,取决于是否同批文档 [ user: 问题 ]
如果文档集本身固定(比如就 200 份产品文档),还有个更极端的做法:把全部文档一次性塞进去,靠缓存摊平成本。8000 token×0.1 的读成本,可能比每次都走检索+拼接更便宜也更简单。这个做法只在文档集总量能塞进上下文、且更新频率低时成立。
四、怎么量:把 write 和 read 拆开
很多人只看输入 token 总数,看到"总量没降"就以为缓存没生效。实际上应该看三个数:
| 指标 | 含义 | 正常值参考 |
|---|---|---|
cache_creation_input_tokens | 本次写入缓存的 token | 冷启动时高,稳定后应接近 0 |
cache_read_input_tokens | 本次命中读取的 token | 应接近"前缀长度",越高越好 |
普通 input_tokens | 未命中部分 | 应接近"仅变化部分" |
判断方法:如果 cache_read 长期为 0 而 cache_creation 一直很高,说明每次都在写从来没被读到——典型的"前缀每请求都变"。
def cache_report(usage):
"""从一次响应的 usage 里拆出缓存三件套,用于埋点"""
created = getattr(usage, "cache_creation_input_tokens", 0) or 0
read = getattr(usage, "cache_read_input_tokens", 0) or 0
plain = getattr(usage, "input_tokens", 0) or 0
total = created + read + plain
return {
"total": total,
"hit_ratio": round(read / total, 3) if total else 0.0,
"write_ratio": round(created / total, 3) if total else 0.0,
# 每次请求平均命中多少 token —— 这个数应该趋近于前缀长度
"read_tokens": read,
}
埋点之后按小时聚合 hit_ratio,比按天看账单灵敏得多。发版、改 prompt、改工具定义这几种操作如果打坏了前缀,一小时内就能从 hit_ratio 掉到 0 上看出来。
做了什么
我没有大规模集群可以压测,所以这篇的成本结论是按公开计费倍率做的推导,不是实测账单。盈亏平衡那两个式子是纯代数,只要倍率假设成立,结论就成立;实际倍率以你用的平台为准,不同模型、不同 TTL 档位不一样。
文章里三种"把前缀搞坏"的写法,我在本地用两个脚本对照验证过序列化字节:同一个 schema 用默认 json.dumps 和 sort_keys=True 输出,长度相同、内容等价,但字节序列不同;把时间戳插到开头后,两段 prompt 的公共前缀长度直接从 12000+ 掉到个位数。这个对比很直观——前缀匹配看的是字节,不是你眼里的"内容一样"。
并发击穿那段没有实测,是读文档 + 按缓存"首次请求写入"的语义推的。如果你的服务入口流量平稳、没有突发扩容,这个问题可能一直不会暴露;反过来,有自动扩缩容的服务几乎必然会遇到。
一些体会
一、"缓存"这个词误导了很多人。 它让人以为是个 Map,key 是内容、value 是计算结果。实际上它更像个"续写检查点":只有从头开始一字不差地重来一遍,才能用上。所有精力应该花在"让前缀稳定"上,而不是"想办法缓存更多"。
二、先量 cache_read,再谈优化。 我建议任何接了大 prompt 的应用,第一件事就是把这个字段打到日志里。没有这个数,你根本不知道自己在省还是在多付。看着总 token 数、猜缓存有没有生效,是最浪费时间的做法。
三、系统提示的稳定性是一种架构资产。 把时间、用户 ID、AB 实验分组这些易变信息从 system 里赶出去,不只是为了缓存——它同时让 prompt 可测试、可版本管理、可 diff。一个 prompt 里混着三个变量的系统,出问题时你连"变的是哪一处"都定位不了。
四、盈亏平衡算完,问题就转移了。 一旦算出"读一次就回本",你会发现决策变得非常简单:只要能命中,就一定加。剩下的全是命中率工程。这类"把判断题变成工程题"的推导,比拍脑袋估个百分比有用得多。
五、别为了缓存牺牲正确性。 有一个诱人的做法是把用户个性化内容全部挪到最后、甚至干脆不告诉模型——这让命中率高得漂亮,但答案质量会掉。缓存是成本优化,不是产品目标;省下来的钱如果换来了答错,这笔账是负的。
- 点赞
- 收藏
- 关注作者
评论(0)