很多人第一次做 RAG，流程都长这样：把文档按字切一刀。丢进向量库，使用者提问时取 Top‑k，塞进 Prompt，交给大模型。

demo 跑通那天很爽。上线一周后就开始收到反馈：

• "我明明写了这段，它说没有查到。"
• "答案里的数字是编的。"
• "一样的问题，换个说法结果完全不一样。"

问题几乎从来不在大模型，而在检索。这篇文章不讲概念，直接把一套能用的 RAG 检索链路拆开：分块 → 向量召回 → BM25 召回 → RRF 融合 → 重排 → Prompt 约束每一步都给出可直接跑的 Python 代码和踩坑说明。

一、先认清：RAG 的瓶颈在召回。不在生成

一个简化但残酷的公式：

最终答案质量 ≈ 检索命中率 × 模型忠实度

如果正确答案压根没进上下文，再强的模型也只能靠"想象力"补全，也就是我们常说的幻觉。调整顺序应该是：

下面按这个顺序来。

二、分块：固定长度切分是万恶之源

固定长度切分最大的问题是切断语义。一个函数说明被拦腰截断，前半段进了 chunk A。后半段进了 chunk B，两个 chunk 单独看都答不了问题。

更稳的做法是结构感知 + 重叠切分优先按标题、段落等自然边界切。超长再退化为按句子切，并保留一定重叠。

import re
from dataclasses import dataclass,field
from typing import List
@dataclass
class Chunk:
text的观点是。str
doc_id的观点是，str
heading_path: str = "" # 所属标题链，如 "部署教程> 环境变量"
至于meta，dict = field
def split_sentences -> List:
"""中英文混合断句：在句末标点后切开，标点保留在前一句。"""
parts = re.split'。text)
return
def pack_sentences -> List:
"""把句子按上限打包成块，块之间保留 overlap 个字符的重叠。"""
chunks,buf =,""
for sent in sentences:
# 单句本身就超长，先冲掉缓冲区，再按硬长度切
if len> max_chars:
if buf:
chunks.append
buf = ""
for i in range。max_chars):
chunks.append
continue
if len + len <= max_chars:
            buf += sent
        else:
            chunks.append
            buf =  + sent
    if buf:
        chunks.append
    return chunks
# 以下为完整示例
lines = md.split
heading_stack: List = 
buckets =             # 
current: List = 
def flush:
    if current:
        buckets.append, "
".join))
for line in lines:
    m = re.match\s+$', line)
    if m:
        flush
        current = 
        level = len)
        heading_stack = heading_stack
        heading_stack.append.strip)
    else:
        current.append
flush
chunks: List = 
for heading_path, body in buckets:
    body = body.strip
    if not body:
        continue
    for piece in pack_sentences, max_chars=1000, overlap=200):
        prefixed = f"{heading_path}
{piece}" if heading_path else piece
        chunks.append)
return chunks

三个容易被忽略的细节：

1. 把标题链拼进 chunk 正文。
2. 重叠不要开太大。
3. 代码块、表格单独成块。

三、向量检索：先把最小可用版本写清楚

不依赖任何向量数据库，用 numpy 就能把原理跑通。生产环境换成 pgvector / Milvus / Qdrant，接口是一样的。

import numpy as np
EmbedFn = Callable],np.ndarray] # 输入文本列表，返回 矩阵
class VectorIndex:
def __init__:
self.embed_fn = embed_fn
self.chunks: List =
self.matrix: np.ndarray | None = None #，已 L2 归一化
@staticmethod
def _l2_normalize -> np.ndarray:
norms = np.linalg.norm
norms = 1e-8 # 防止零向量除零
return m / norms
def build -> None:
self.chunks = chunks
vectors=
for i in range,batch_size):
batch=]
vectors.append。dtype=np.float32))
self.matrix=self._l2_normalize)
def search->List]:
if self.matrix is None:
raise RuntimeError
q_vec=self._l2_normalize,dtype=np.float32))
scores=self.matrix @ q_vec # 已归一化，点积即余弦相似度
k=min)
idx=np.argpartition
idx=idx
return



*必须先归一化再点积，否则得到的是内积而不是余弦相似度*

*Top‑K 用 argpartition*，十万级向量下比 argsort`快一个量级。


四、只用向量检索大概率会翻车


说到"错误码。" ERR_CONN_1053 

"型号 / 版本号：" v2.-娱乐a 

"人名、内部项目代号：" Project Kelpie 

"精确 API 名：" onBeforeUnmount 


至于原因很直白，


*embedding 把文本压成几百维稠密向量，低频字符串的信息在压缩中被抹掉了*。这些查询几乎必挂，


方法的观点是。


*关键词检索兜底*，BM25 是性价比最高的选择。


import math
from collections import Counter
class BM25:
"""标准 BM25 实现。tokenize 中文建议用 jieba，英文按空格+小写即可。"""
def __init__:
self.k1,self.b=k1,b
self.docs=corpus_tokens
self.n=len
self.doc_len=
self.avgdl=sum/self.n if self.n else 0
self.tf=
df=Counter
for d in corpus_tokens:
for term in set: df+=1
# 带平滑的 IDF，保证非负
self.idf={t:math.log/)for t,c in df.items}
 def search->List]:
scores=*self.n
for i。in enumerate):
s=0.
for term,freq_in_q in Counter.items:
f=tf_i.get
if f==0 :continue
denom=f+self.k1*
s+=self.idf.get*f*/denom
scores=s
ranked=list)
ranked.sort
return>10]


五、RRF 融合：不用调权重的混合检索 


*两路分数量纲完全不同*。其实，余弦相似度在 ~，BM25可能是 …随语料变化，权重调好了换个知识库就失效。

'RRF':只用排名，不用分数。至于使用示例，python
def rrf_fuse(rank_lists,List]],k:int=60,weights=None)->List]:
weights=w or *len
fused={}
for w,rlist in zip:
for rank。in enumerate:
fused=fused.get+w/
return sorted,key=lambda kv:-kv)



*RRF 的好处是免调参、跨量纲、抗异常值*。一路召回把某个 chunk 排在第?，另一路排在第，，融合后它自然浮到最前面；只有一路命中的结果也不会被完全淹没。



演示代码片段的观点是，
def hybrid_search(query:str,vec_index:,bm25:,tokenize_func。top_k:int=20)->List:
vec_hits=&vec_index.search&
bkm_hits=&b&m25.search,top_k=&k_top_k)&
rff=&rrf_fuse&
return for i,if idx\t||
_>
_>
],>

六、重排：召回放宽，精排收紧 

。其实现方式通常是将 query 与 candidate 文本拼接后送入同一个 transformer 模型，接下来得到每条候选文本与 query 的相关性得分；随后根据得分对候选进行排序，并返回 top‑N 条给最终 Prompt)。如果你对该过程有任何疑问，请随时提问！)