CAG 与长上下文

CAG 是什么

CAG（Cache-Augmented Generation，缓存增强生成）由 Chan 等人在 WWW '25 论文 "Don't Do RAG: When Cache-Augmented Generation is All You Need"（arXiv:2412.15605）中提出。它的思路简单到让人怀疑——

对比一下三种范式的"知识进入模型"的方式：

KV Cache：CAG 的物理基础

要理解 CAG 为什么能成立，必须先理解 Transformer 推理的一个关键事实：同样的前缀 token，每次推理时算出来的 KV 张量是完全一样的。

┌─────────────────────────────────────────────────┐
│  Transformer 推理过程（自回归生成）              │
│                                                  │
│  prompt = [SYSTEM_PROMPT] + [文档库] + [用户问题] │
│              ↓                                   │
│         逐层 Attention                            │
│              ↓                                   │
│   每个 token 算出 K, V 张量（QKV 中的 K 和 V）    │
│              ↓                                   │
│   生成下一个 token                                │
│                                                  │
│  关键：[SYSTEM_PROMPT] + [文档库] 这部分的       │
│  K, V 张量与"用户问什么"完全无关。               │
│  → 算一次，存下来，之后所有查询直接复用。         │
└─────────────────────────────────────────────────┘

这就是 Prompt Caching（提示词缓存）。Anthropic、OpenAI、Google、DeepSeek 在 2024 年陆续上线了这个能力。Anthropic API 教程第 6 章 完整覆盖了 Anthropic 的 Caching API，本章只取其中和 CAG 最相关的部分。

Prompt Caching 实战（Anthropic）

from anthropic import Anthropic

client = Anthropic()

# 假设我们有一份 50 页的产品手册，约 80K tokens
with open("product_manual.txt") as f:
    manual = f.read()

def cag_query(question: str) -> str:
    """CAG 风格查询：整本手册放进 system，缓存它"""
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        system=[
            {
                "type": "text",
                "text": "你是产品客服，根据下面的完整手册回答问题。",
            },
            {
                "type": "text",
                "text": manual,
                # 关键：标记这一段为可缓存
                "cache_control": {"type": "ephemeral"},
            },
        ],
        messages=[{"role": "user", "content": question}],
    )
    return response.content[0].text

# 第一次调用：写入缓存（写入比正常贵 25%）
cag_query("产品的保修期是多久？")

# 后续 5 分钟内的所有调用：缓存命中，输入 token 价格 1/10
cag_query("如何重置出厂设置？")
cag_query("支持哪些蓝牙协议？")
cag_query("国际版和国行版有什么区别？")

CAG vs RAG：成本回本公式

"用了 CAG 真的更便宜吗？" 这个问题的答案完全取决于查询频率。我们把它写成可计算的公式。

设：

• K = 知识库 token 数（如 80,000）
• Q = 单次查询的问题 token 数（如 50）
• A = 单次答案 token 数（如 300）
• p_in = 输入价格（如 Sonnet 4.6 = $3 / 1M tokens）
• p_cache_write = 写缓存价格（1.25 × p_in）
• p_cache_read = 命中价格（0.1 × p_in）
• p_out = 输出价格
• N = TTL 内的查询次数

纯 RAG 成本（N 次查询）：每次送 5 个 chunk × 200 token = 1000 token 上下文：

cost_RAG = N × (1000 × p_in + A × p_out)
        ≈ N × (1000 × $3/1M + 300 × $15/1M)
        ≈ N × $0.0075

CAG 成本（N 次查询，命中同一缓存）：

cost_CAG = K × p_cache_write              # 一次性写入
         + N × (K × p_cache_read           # 每次缓存命中
              + Q × p_in                    # 用户问题（小）
              + A × p_out)                  # 输出
        ≈ 80000 × $3.75/1M                  # = $0.30 写入费
         + N × (80000 × $0.30/1M            # = $0.024 / 次命中
              + 50 × $3/1M                   # ≈ $0.00015
              + 300 × $15/1M)                # ≈ $0.0045
        ≈ $0.30 + N × $0.0287

那么 CAG 真正的价值是什么

论文给出的实验结果在 SQuAD 和 HotpotQA 上 CAG 准确率高于 RAG。但仔细看会发现：CAG 真正的杀手锏不是省钱，是"消除检索错误"。

长上下文：从 CAG 推到极致

CAG 的天花板就是上下文窗口本身。2025 年初的窗口现状：

CAG 的工程实践要点

1. 缓存命中调试

# Anthropic 响应里会返回 usage 字段
response = client.messages.create(...)
print(response.usage)
# Usage(
#   input_tokens=50,                        ← 用户问题部分
#   cache_creation_input_tokens=0,          ← 没有写缓存
#   cache_read_input_tokens=80000,          ← 命中了 80K 缓存
#   output_tokens=300
# )

# 如果 cache_read 一直是 0，检查：
# ① system 内容是否完全字节匹配（甚至空格、换行符）
# ② cache_control 是否打在了正确的 block
# ③ 距离上次命中是否超过 5 分钟 TTL

2. 多层 Cache Breakpoints

# 不同变化频率的内容分层缓存，最大化命中率
system = [
    {"type": "text", "text": STABLE_INSTRUCTIONS},        # 永不变
    {"type": "text", "text": PRODUCT_MANUAL,
     "cache_control": {"type": "ephemeral"}},          # breakpoint 1
    {"type": "text", "text": USER_PROFILE,
     "cache_control": {"type": "ephemeral"}},          # breakpoint 2
]
# 用户切换时：profile 缓存 miss，但 manual 缓存仍命中

3. CAG + RAG 混合架构

实际生产系统经常这样组合："核心稳定知识用 CAG，海量长尾知识用 RAG"——

def hybrid_query(question: str) -> str:
    # Step 1: 用关键词路由判断走哪条路
    if is_core_product_question(question):
        # 核心产品手册（80K）直接 CAG，命中率高
        return cag_query(question, manual=PRODUCT_MANUAL)

    # Step 2: 长尾知识走 RAG
    chunks = vector_store.search(question, top_k=5)
    return rag_query(question, chunks)

CAG 不适合什么场景

本章小结