语义缓存:把重复的提问变成可复用的推理结果

一、为什么精确缓存不够用

任何做过线上 LLM 应用的人都知道,用户的问题高度重复。一个客服机器人,60%~80% 的请求集中在少数几十个意图上。所以最直觉的优化就是加缓存:hash(prompt) → response。

但精确缓存(Exact Match Cache)的命中率往往低得令人失望。原因在于自然语言的表达多样性:

  • “怎么退款” / “退款流程是什么” / “我要退货怎么操作” / “如何申请退钱”
    • “帮我查一下订单 12345 的物流” / “订单12345到哪了”
      这四句话语义上高度一致,但字符串哈希完全不同。实测下来,精确缓存在真实客服场景的命中率通常只有 15%~25%,剩下的 75% 都是"语义重复但字面不同"。

语义缓存(Semantic Cache)就是为了解决这个问题:用向量相似度判断"是否等价",而不是字符串相等。

二、基本原理与最小实现

核心思路很简单:把用户 query 编码成向量,在缓存库里做 ANN 检索,如果最近邻的相似度超过阈值,直接返回缓存结果。

import hashlib, json, time
import numpy as np

class SemanticCache:
    def __init__(self, embed, store, threshold: float = 0.92, ttl: int = 86400):
            self.embed = embed
                    self.store = store          # 支持 add / search 的向量库
                            self.threshold = threshold
                                    self.ttl = ttl
    def get(self, query: str, namespace: str = "default"):
            vec = self.embed(query)
                    hits = self.store.search(vec, top_k=1, filter={"namespace": namespace})
                            if not hits:
                                        return None
                                                doc, score = hits[0]
                                                        if score < self.threshold:
                                                                    return None
                                                                            if time.time() - doc["created_at"] > self.ttl:
                                                                                        return None
                                                                                                return doc["response"]
    def put(self, query: str, response: str, namespace: str = "default", meta: dict | None = None):
            self.store.add(
                        id=hashlib.md5(f"{namespace}:{query}".encode()).hexdigest(),
                                    vector=self.embed(query),
                                                payload={
                                                                "query": query,
                                                                                "response": response,
                                                                                                "namespace": namespace,
                                                                                                                "created_at": time.time(),
                                                                                                                                **(meta or {}),
                                                                                                                                            },
                                                                                                                                                    )
                                                                                                                                                    ```
代码只有 30 行,但**真正难的是那三个参数:阈值、TTL、命名空间。** 下面逐个拆。

## 三、阈值:一个被严重低估的超参数

### 3.1 阈值决定了"错"和"慢"的平衡

- 阈值太低(如 0.80):大量不相关问题被误判为命中,用户得到**答非所问**的结果。这是最糟糕的失败模式,因为用户不知道系统错了,会直接不信任产品。
- - 阈值太高(如 0.98):几乎不命中,缓存形同虚设,白付了向量检索的成本。
实践中,`0.92~0.95` 是常见起点,但**这个数字高度依赖 Embedding 模型**。不同模型的相似度分布差异很大,不能直接套用。

### 3.2 正确的定阈值方法

不要拍脑袋,用数据定。方法如下:

1. 从日志采样 500 条 query,人工聚类出"语义等价组"。
2. 2. 计算所有组内 pair 的相似度,得到**正样本分布**。
3. 3. 计算跨组 pair 的相似度,得到**负样本分布**。
4. 4. 找让 `F1` 最大的阈值点。
```python
import numpy as np

def find_threshold(pos_sims, neg_sims):
    best_t, best_f1 = 0, 0
        for t in np.arange(0.80, 0.999, 0.005):
                tp = sum(s >= t for s in pos_sims)
                        fp = sum(s >= t for s in neg_sims)
                                fn = len(pos_sims) - tp
                                        precision = tp / (tp + fp) if tp + fp else 0
                                                recall = tp / (tp + fn) if tp + fn else 0
                                                        f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0
                                                                if f1 > best_f1:
                                                                            best_t, best_f1 = t, f1
                                                                                return best_t, best_f1
                                                                                ```
一个真实案例:某电商客服场景下,正样本相似度中位数 0.94,负样本中位数 0.81,但负样本的 95 分位到了 0.91。这意味着**如果阈值设 0.92,会有 5% 的误命中**。此时正确的做法不是把阈值提到 0.95(召回骤降),而是**引入第二道校验**。

### 3.3 双阈值 + LLM 仲裁

两级判断能大幅提升精度:

```python
async def cached_answer(query, cache, llm, high=0.96, low=0.90):
    hits = cache.store.search(cache.embed(query), top_k=1)
        if not hits:
                return None, "miss"
                    doc, score = hits[0]
    if score >= high:
            return doc["response"], "hit_exact"
    if score >= low:
            # 灰区:让 LLM 判断是否同一问题
                    verdict = await llm.classify(
                                f"问题A:{doc['query']}\n问题B:{query}\n这两个问题是否在问同一件事?只回答 是/否"
                                        )
                                                if "是" in verdict:
                                                            return doc["response"], "hit_arbitrated"
    return None, "miss"
    ```
灰区仲裁的成本极低(一个 20 Token 的分类请求),但能把误命中率压到 1% 以下。这是**投入产出比最高的一步优化**。

## 四、TTL 与失效:缓存的"新鲜度"问题

LLM 应用的答案会随时间失效,但失效速度差异极大:

| 内容类型 | 失效速度 | 建议 TTL |
| --- | --- | --- |
| 通用知识("什么是 RAG") | 极慢 | 7~30 天 |
| 产品功能说明 | 慢(随版本) | 3~7 天 |
| 价格、库存、活动 | 快 | 1~60 分钟 |
| 用户个人数据(订单、余额) | 实时 | **不缓存** |

**最关键的一条规则:涉及用户私有数据的查询绝对不能跨用户缓存。** 这不是性能问题,是安全漏洞。一个"我的订单到哪了"的缓存,可能会把 A 的订单信息返回给 B。

实现上必须做**缓存键隔离**:`cache_key = hash(user_id + query)`,或者用向量库的 `namespace` 做租户隔离。两者都要做,前者防止语义碰撞,后者防止检索越界。

```python
def cache_namespace(user_id: str, scene: str) -> str:
    return f"{scene}:{user_id}"
    ```
## 五、命中率优化:从 20% 到 60%

### 5.1 查询归一化

缓存前先做轻量归一化,能显著提升命中率:

```python
import re, unicodedata

def normalize_query(q: str) -> str:
    q = unicodedata.normalize("NFKC", q)      # 全角转半角
        q = q.lower()
            q = re.sub(r"[ \t]+", " ", q).strip()
                q = re.sub(r"[,。!?、;:]+$", "", q)    # 去尾部标点
                    q = re.sub(r"^(请问|你好|麻烦问一下)[,, ]*", "", q)  # 去客套前缀
                        return q
                        ```
这个函数看起来平平无奇,但在真实数据上通常能带来 10~15 个百分点的命中率提升——因为用户的客套话和标点差异,占了"字面不同"的很大一部分。

### 5.2 意图聚类后缓存

更激进的做法是:先做意图分类(可以用小模型或规则),把 query 映射到意图 ID,然后**按意图缓存**。这样"怎么退款"和"我要退货怎么操作"会命中同一条缓存。

代价是意图分类本身有误差,且需要维护意图体系。适合意图空间有限、稳定的场景(如 IVR 语音导航)。

### 5.3 分层缓存

L1:精确缓存(内存,< 1ms) → 命中率 15%
L2:语义缓存(向量库,10~30ms) → 额外命中 30%
L3:LLM 生成(1~5s) → 剩余 55%


L1 用 LRU + 布隆过滤器做前置,能挡掉最热的那批请求,几乎零成本。L2 才是语义缓存。这个分层结构比"只做语义缓存"更经济,因为 L1 的命中不需要任何向量计算。

## 六、什么时候不该用语义缓存

这一点很少被讨论,但很重要。

**第一,高度个性化的问题。** 如果每个答案都依赖用户的具体上下文("帮我改一下这段代码"),缓存几乎没有价值,反而增加复杂度。

**第二,需要严格一致性的场景。** 金融、医疗类问答,即使语义相同,也需要重新推理以确保合规。此时缓存不是优化,是风险。

**第三,低频长尾查询。** 如果查询分布极其分散(Zipf 系数很低),缓存命中率上不去,只会白付向量检索的成本。上缓存前先统计一下 query 的重复率,低于 30% 就别做了。

**第四,答案短但推理成本低的场景。** 如果答案本来就生成得很快(< 500ms),缓存的收益不足以抵消"可能答错"的风险。

## 七、我的判断

语义缓存是 LLM 应用里**性价比最高的工程优化之一**,但它有一个致命前提:**你必须能容忍错**。

所以我的建议是,把语义缓存当成一个**分级的产品能力**,而不是一个全局开关:

- 对"通用知识型"问题,激进缓存(阈值 0.90)。
- - 对"业务操作型"问题,保守缓存(阈值 0.96 + LLM 仲裁)。
- - 对"个人数据型"问题,完全不缓存。
同时必须建立**缓存效果监控**:命中率、误命中率(通过人工抽检)、平均节省延迟、平均节省 Token 成本。这四个指标决定了缓存是否值得继续投入。

最后一个经验:**语义缓存的收益会随时间衰减。** 上线初期命中率可能到 60%,但因为知识库更新、用户问题演化,半年后可能只剩 35%。所以要定期重跑阈值标定,而不是设一次就不管。


Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐