RAG 系统搭完之后,两个问题始终悬着:

  1. 怎么知道它搜得全不全?——召回率
  2. 能不能让重复的问题别每次都从头算一遍?——缓存命中率

这两个问题看似无关,实则构成 RAG 系统效率的互补双引擎。这篇文章把召回、召回率、缓存命中率各自的定义、优化手段、所处环节,以及它们之间的关系,一次讲清楚。

四个概念的位置图

先搞清楚谁包含谁、谁在哪一环。

概念是什么在哪一环
RAG检索增强生成,整体架构全局
召回(Recall)检索阶段的第一步——粗筛RAG 的 R(检索)内部
召回率(Recall Rate)衡量召回质量的指标评价指标(质量维度)
缓存命中率(Cache Hit Rate)衡量系统效率的指标评价指标(效率维度),位于召回之前

RAG 包含三个环节:检索(Retrieval)→ 增强(Augmented)→ 生成(Generation)。召回是检索环节的第一步——从百万数据中粗筛出 Top 20~50 条候选。召回率衡量这一步做得全不全。缓存则位于召回之前——Query 进来先查缓存,命中就直接返回,不触发召回。

一条流水线把四个概念的位置说清楚:

User Query
    │
    ▼
┌──────────────┐
│   缓存层      │ ──命中──► 返回缓存结果(跳过全部后续)
└──────┬───────┘
       │ 未命中
       ▼
┌───────────────────────────────────┐
│        RAG 检索阶段                 │
│                                    │
│  召回:FTS + Vector → RRF 融合     │
│         ↓                          │
│  重排:Cross-Encoder 精筛 Top-K    │
│                                    │
└───────────────┬───────────────────┘
                ▼
          LLM 生成回答
                │
                ▼
          写入缓存 ◄────────────────
                │
                ▼
            返回用户

缓存在召回之前,召回在重排之前。缓存命中 → 召回不触发;缓存未命中 → 走完整检索流水线 → 生成结果回写缓存。

下面逐个拆。

召回率:搜得全不全

定义

召回率(Recall Rate)= 相关文档中被成功捞出来的比例。

知识库里有 100 篇关于”退款”的笔记,用户问退款相关问题时,检索捞出了 80 篇 → 召回率 80%。漏掉的那 20 篇,LLM 永远看不到——这就是召回率不够的代价。

微观与宏观

召回率有两个衡量层级:

  • 微观(单次对话):知识库有”退款流程”和”超时赔付”两条相关规则,检索只捞到一条 → 召回率 50%。衡量的是这一次检索的完整性。
  • 宏观(系统级):在标注好的评测数据集上算平均 Recall@K(K 通常取 3 或 5),综合反映切片策略、检索方式、Embedding 模型等架构层面的能力。

行业说”我们 RAG 召回率 95%“,指的是宏观的 Recall@K。

线上为什么测不准

这里有个工程现实:线上生产环境无法精确计算召回率。

问题出在分母——你不知道知识库里到底有多少篇文档和当前 Query 相关。离线评测时,你有标注好的数据集,分母 N 是已知的。但线上每来一个新 Query,你不知道 N 是多少。

线上只能用代理指标间接判断:

代理指标什么信号
拒答率升高LLM 觉得检索结果不够用,拒绝回答
幻觉率升高LLM 检索结果不够,开始”凑答”
上下文相关度低检索回来的内容和问题相关度低

拒答率上来了、幻觉变多了 → 大概率是召回出了问题。

影响召回率的四大因素

因素问题描述
切片粒度过长 → 一个向量同时含多个主题,信息被稀释;过短 → “它支持增量渲染”,模型不知”它”指谁,上下文断裂
检索方式单一纯向量检索漏专有名词/错误码(useSearchParams 在 1536 维向量里特征太弱);纯全文检索漏同义表达(“性能优化”搜不到”延迟降低”)
向量模型表征能力通用 Embedding 模型在法律、医疗等垂直领域的语义判断失准
Query 与文档的语义鸿沟用户口语化提问(“怎么让页面更快”)和文档规范术语(“首屏渲染优化”)字面差异大,向量距离不够近

四种优化手段

  1. 混合检索:BM25 全文检索 + 向量检索双轨召回,再 RRF 融合。FTS 抓字面,Vector 抓语义,互补盲区。

  2. Query 改写与 HyDE:先让 LLM 对用户 Query 做一步预处理——同义扩展(“怎么让页面更快” → “前端性能优化、首屏渲染”)、指代消解(“它的配置” → “Next.js 的配置”)。更激进的是 HyDE(Hypothetical Document Embeddings)[1]:先让 LLM 生成一个”假设答案”,再用假设答案的向量去检索——答案和文档都是”正文风格”,比”提问”和”文档”的匹配度更高。

  3. 父子切片(Parent-Child Chunking):检索时用细粒度的子切片匹配(精准定位),返回时上溯到父切片(上下文完整)。既保证检索精度,又不丢上下文。

  4. 领域微调 Embedding 模型:通用模型在垂直领域失准时,用领域语料微调。

召回阶段的角色分工:Embedding 模型是先锋探路者,以极低成本在海量文档中筛出 Top-K 候选(判断”像不像”);LLM 是大脑决策者,对候选做推理综合并生成回答(判断”对不对”)。召回是 Embedding 模型的主场——它做不了深度推理,但能用极低成本把百万数据筛到几十条。

外部 Embedding 与 LLM 内部 Embedding 是两个完全隔离的空间。召回阶段用的外部 Embedding 模型(如 text-embedding-3-small)是独立的小型神经网络,输出固定维度的静态向量供检索用。LLM 内部的 Embedding 层是 LLM 网络结构本身的一部分(输入层 + 输出层),负责理解输入和预测输出。两者通过纯文本字符串交接——外部模型检索到的文档只取出原始文本拼入 Prompt,LLM 用自己的 Tokenizer 和 Input Embedding 层重新将文本转为内部向量。不存在坐标校准问题,因为两者的向量空间没有任何数学映射关系。

缓存命中率:算得省不省

定义

缓存命中率(Cache Hit Rate)= 用户 Query 命中缓存、无需走完整检索+生成流程的比例。

命中率越高,系统越省 Token、越低延迟。命中一次缓存 = 跳过 Embedding API 调用 + 向量检索 + Rerank + LLM 生成,直接返回历史结果。

三层缓存体系

缓存不是单一概念,在 RAG 系统中分三个层级,各管一段:

层级缓存什么命中后省掉什么典型实现
语义缓存相似 Query → 历史回答整条检索+生成链路GPTCache[2]、Redis + 向量相似度
检索缓存Query 的 Embedding 向量 + Top-K 结果Embedding API 调用 + 向量检索Redis / 内存
模型层 KV CacheAttention 的 KV 矩阵重复前缀的重复计算vLLM[3]、SGLang 的 Prefix Caching

语义缓存最值得讲。用户问”怎么优化 Next.js 性能”,之前有人问过”Next.js 性能提升方案”——两者语义相似,直接复用历史回答。实现方式:把历史 Query 向量化存入缓存,新 Query 先算向量相似度,超阈值则直接返回历史回答。

核心权衡:阈值高 → 命中率低但答案准确;阈值低 → 命中率高但可能答非所问。

检索缓存粒度更细——不缓存最终答案,只缓存中间产物(Query 的 Embedding 向量和 Top-K 检索结果)。同一 Query 反复出现时,省掉 Embedding API 调用和数据库查询。

模型层 KV Cache 更底层——LLM 推理时,每个 token 要和前面所有 token 做 Attention。多次请求共享相同 System Prompt(前缀)时,这部分 KV 矩阵可缓存复用,降低首 Token 延迟(TTFT)和推理成本。vLLM、SGLang 等推理引擎已原生支持。

Cache Key 设计规范

缓存 Key 不能只用 Query 文本,必须拼接业务上下文:

  • 多租户隔离:cache_key = hash(user_id + tenant_id + normalized_query),否则 A 用户的问题命中 B 用户的缓存 → 越权泄露
  • 时效标记:含时间敏感词的 Query 要设 TTL,过期自动失效

缓存 Key 设计不规范 = 安全漏洞。这不是性能问题,是权限问题。

互补关系:先缓存后召回

现在把两个指标放在一起看。

闭环逻辑

Query 进来后的执行顺序:

  1. 先查缓存——命中?直接返回,不触发召回
  2. 缓存未命中——走召回 → 重排 → 生成
  3. 生成结果回写缓存——下次相似 Query 来了直接命中

先缓存后召回:缓存是第一道闸,拦住高频问题;召回是第二道闸,处理缓存没拦住的长尾问题。

两个方向的相互依赖

这不是简单的”谁先谁后”,而是互相依赖的闭环:

方向一:高质量召回是高质量缓存的前提

召回率低 → 检索到的内容不准 → 基于错误内容生成的回答被缓存 → 后续相似 Query 命中缓存返回错误答案 → 缓存污染。一个召回漏洞会通过缓存放大——一次错误变成多次错误。

方向二:高频靠缓存,长尾靠召回

用户问题的分布是长尾的——80% 的流量集中在 20% 的高频问题上(“怎么退款""如何重置密码”)。高频问题靠缓存秒回,长尾问题靠召回精排处理。缓存覆盖面越大,召回压力越小。

类比:餐厅的现成菜柜与后厨现炒。缓存 = 柜台上的现成套餐(爆款菜提前做好,客人一点就出餐);召回 = 后厨现炒(冷门菜按需做)。爆款菜靠柜台,冷门菜靠厨房——但柜台上的菜必须是好菜,否则一个差评会通过口碑传染给所有后续客人(缓存污染)。

一句话理解互补关系

没有被缓存的部分是召回发挥的重点,召回率高的是缓存可发挥作用的重点。

这句话把互补关系说透了:

  • 缓存没覆盖的 Query → 召回的价值区间(长尾问题必须靠召回兜底)
  • 召回质量高 → 检索结果准 → 缓存写入的内容可靠 → 缓存能放心复用

召回和缓存不是竞争关系,是分工关系。召回管”搜得全”,缓存管”算得省”,两者缺一不可。

陷阱词:同时破坏两个指标的四个坑

有些 Query 特征会同时破坏召回率和缓存命中率,这些词我叫它们”陷阱词”。

1. 时效词(“目前""现在""今天”)

破坏缓存:含”目前”的 Query 被缓存后,明天再命中缓存,返回的是昨天的过期信息。

破坏召回:检索时不过滤时间,可能捞回已失效的旧文档。

应对:

  • Query 规范化:把”今天的退款政策”改写成”2026-08-09 生效的退款政策”再进缓存
  • Bypass 缓存:识别到时效词后直接跳过缓存层
  • SQL 时间硬过滤:WHERE updated_at > NOW() - INTERVAL '7 days'

2. 指代性代词(“它""他""这个”)

破坏召回:用户多轮对话中问”它的配置怎么改”,“它”的向量无意义,召回率断崖式下降。

应对:用 LLM 做指代消解——结合对话历史把”它的配置怎么改” → “Next.js 的配置怎么改”再进检索。

3. 专有名词与错误码

破坏召回:useSearchParams、ERR_404、ECONNREFUSED 在向量空间中被语义稀释,纯向量检索容易漏。

应对:靠 BM25 全文检索兜底。这正是混合检索存在的理由——FTS 负责抓字面,Vector 负责理解语义。

4. 个性化/权限词

破坏缓存:用户问”我的订单”,如果不把 user_id 拼进 Cache Key,A 用户的问题命中 B 用户的缓存 → 越权泄露。

应对:Cache Key = hash(user_id + tenant_id + normalized_query);检索时 SQL 标量过滤先于向量检索执行。

四类陷阱词有一个共同特征:它们不是算法问题,是业务语义问题。这也是为什么框架不会自动处理它们。

框架职责边界

开源 Agent 框架(LangChain、LlamaIndex 等)在这片领域提供的是”乐高积木”,不是”成品”。

框架给什么

  • 混合检索器组件(HybridSearchRetriever、ParentDocumentRetriever)
  • 通用缓存适配器(RedisCache、GPTCache)
  • Prompt 模板变量替换(自动注入当前日期等系统变量)

框架不给什么

  • 业务时效性逻辑:规章制度三年一变、股票行情三秒一变——框架不知道你的数据保质期是多久
  • Query 改写开关:改写消耗额外 LLM 调用,不能默认开启,框架不知道你的延迟预算
  • 多租户权限隔离:依赖业务的 Session 结构和权限模型,框架无法预知
  • 指代消解:需要对话上下文管理,依赖业务的多轮对话设计

生产级 RAG = 框架的通用组件 + 自建的业务控制层。时间词拦截、指代消解、混合检索权重调配、缓存 Key 权限规范——这些防坑机制必须自己搭。框架帮你省掉 80% 的通用代码,剩下 20% 的业务逻辑才是生产级和 demo 级的分界线。

总结

一张表回顾全文:

概念定义优化手段所在环节
RAG检索增强生成—全局架构
召回检索阶段第一步,粗筛 Top 20~50混合检索、Query 改写、父子切片RAG 的 R 内部
召回率相关文档被捞出来的比例四大因素对应四种手段评价指标(质量)
缓存命中率Query 命中缓存的比例三层缓存体系、Cache Key 规范评价指标(效率),位于召回之前

一句话:召回率管”搜得全不全”,缓存命中率管”算得省不省”,先缓存后召回,高频靠缓存秒回,长尾靠召回兜底——但缓存里的菜必须是好菜,否则一个召回漏洞会通过缓存放大成一片错误。


参考来源