RAG 检索增强生成
1、RAG概述
1.1 什么是RAG?

1.2 RAG优缺点
1.3 RAG vs 其它方案

1.4 RAG应用场景

1.5 完整流程总览
典型的RAG的两个阶段:索引阶段(离线)和检所生成阶段(在线)
**索引阶段:**从各种数据源加载数据--->将文档切分成小块--->对文本块进行Embedding嵌入--->存储嵌入向量库;
**检索生成阶段:**根据用户输入,使用检索器从存储中检索相关文件块--->大模型使用包含问题和检索结果的提示词生成回答。

2、文档加载
2.1 为什么要加载文档
2.2 Document对象
为什么要加载文档?
RAG的核心是"先检索,再生成"。但检索的前提是------系统里得先有数据。企业的知识散落在各种格式的文件中:TXT、Markdown、Word、PDF、CSV、网页......这些原始文件格式各异,大模型无法直接使用。
因此,RAG的第一步就是把这些异构数据统一加载为标准格式 ,为后续的切分、嵌入、检索做好准备。LangChain实现和集成了众多文档加载器,方便从不同格式的文件中加载数据。可在 LangChain Document Loaders 查看所有集成的加载器。

2.3 加载器类型概览
2.4 加载Makedown
Markdown是一种半结构化、机器可读的文本标记格式,通过特定语法标记标题、段落、有序列表、无序列表等结构信息。
可以通过Unstructured文档加载器来加载Markdown文件,Unstructured.io对Markdown的解析流程大致为:
- 按照Markdown语法结构进行切分:标题、列表等会被切分成单独的element;
- 对统一标题下的正文,再按照段落进行切分:不同段落(通过空行或\n区分)会被拆成多个element.
python
# uv add makedown langchain-community "unstructured[md]"
from langchain_community.document_loaders import UnstructuredMarkdownLoader
def markdown_loader_demo(file_path: str):
"""
使用 UnstructuredMarkdownLoader加载Markdown文件
并按照elements模式打印切分后的内容
"""
loader = UnstructuredMarkdownLoader(
file_path,
encoding="utf-8",
mode="elements", # elements:按标题、段落等元素切分
)
docs = loader.load()
for i, doc in enumrate(docs):
print(f"======Elements {i}=====")
print(doc.page_content)
print("metadata:", doc.metadata)
print(f"==========\n")
markdown_loader_demo("./assets/sample.md")
2.5 加载Docx
python
# uv add langchain-community "unstructured[docx]"
from pathlib import Path
from langchain_community.document_loaders import UnstructuredWordDocumentLoader
def word_loader_demo(file_path: str, start: int = 0, end: int = 20):
file_path = Path(file_path)
if not file_path.exists():
raise FileNotFoundError(f"文件不存在:{file_path.resolve()}")
loader = UnstructuredWordDocumentLoader(
file_path = str(file_path),
mode = "elements", # 不会根据标题文档加载多个文档对象(按行加载)
)
docs = loader.load()
print(f"总共解析得到{len(docs)}个元素\n")
for i doc enumrate(docs[start:end], start = start):
print(f"======Elements {i}=====")
print(doc.page_content)
print("metadata:", doc.metadata)
print(f"==========\n")
word_loader_demo("./asset/demo.docx")
2.6 加载PDF
MinerU介绍
将PDF转化为机器可读可读格式(如Markdown、JSON)的工具,偏于后续按任意结构进行抽取处理。


MinerU 支持对 PDF、Word、PPT、照片等进行解析,涵盖图像提取、OCR、公式和表格解析等功能 。项目已完全开源,支持本地 Docker 部署(仓库地址:https://github.com/opendatalab/MinerU
),也可通过官网 API 调用服务,使用前需申请 API_KEY 并配置到环境变量。

单个在线文件解析
接口说明
适用于通过 API 创建解析任务的场景,用户需在 Header 中填写 Token(可在 API 管理页面自定创建)。 注意:
- 单个文件大小不能超过 200MB,文件页数不超出 200 页
- 每个账号每天享有 1000 页最高优先级解析额度,超过 1000 页的部分优先级降低
- 因网络限制,github、aws 等国外 URL 会请求超时
- 该接口不支持文件直接上传
- header头中需要包含 Authorization 字段,格式为 Bearer + 空格 + Token
python
import requests # 第三方
# 1.申请令牌
token = "API管理页面自定创建的token"
# 2.端点(不支持本地文件)
url = "https://mineru.net/api/v4/extract/task"
# 3.构建请求头(key:Authorization value: Bearer taken)
header = {
"Content-Type": "application/json", #文本类型
"Authorization": f"Bearer {token}"
}
# 4.请求体中的数据
data = {
# 在线pdf地址(必选)
"url": "https://cdn-mineru.openxlab.org.cn/demo/example.pdf",
# vlm or pipeline(非必须参数)
"model_version": "vlm"
}
# 5.发送post请求,得到响应
res = requests.post(url,headers=header,json=data)
print(res.status_code) # 响应状态码
print(res.json()) #响应完整信息
print(res.json()["data"]) #响应完整信息中获取数据部分 task_id
本地文件上传解析
接口说明
适用于本地文件上传解析的场景,可通过此接口批量申请文件上传链接,上传文件后,系统会自动提交解析任务 注意:
- 申请的文件上传链接有效期为 24 小时,请在有效期内完成文件上传
- 上传文件时,无须设置 Content-Type 请求头
- 文件上传完成后,无须调用提交解析任务接口。系统会自动扫描已上传完成文件自动提交解析任务
- 单次申请链接不能超过 50 个
- header头中需要包含 Authorization 字段,格式为 Bearer + 空格 + Token
python
import requests
from pathlib import Path
def mineru_upload_file_demo():
if not token:
raise RuntimeError("环境变量 MINERU_TAKEN 未配置")
# 1.申请上传URL
url = "https://mineru.net/api/v4/file-urls/batch"
# 2.定义请求头
header = {
"Content-Type": "application/json",
"Authorization": f"Bearer {token}"
}
#3. 本地文件路径列表(可扩展多个文件)
file_paths = [
r"assets\simaple.pdf"
]
files_info = []
for i p in enumrate(file_paths):
p = Path(p)
if not p.exits():
raise FileNotFoundError("文件不存在:{p}")
files_info.append(
{
"name": p.name,
"data_id": f"data_{i}" # 给每一个文件一个data_id标识
}
)
# 4.构建
data = {
"files": files_info,
"model_version": "vlm"
}
# 5.发送post请求,得到响应
res = requests.post(url,headers=header,json=data)
if res.status_code != 200:
print(f"申请上传 URL 失败,状态码:{res.status_code},
响应内容:{res.text}")
return None
result = res.json()
if result.get("code") != 0:
print(f"申请上传 RUL 失败,reason: {result.get("msg")}")
return None
print(result)
batch_id = result["data"]["batch_id"]
urls = result["data"]["file_urls"]
print(f"申请上传 RUL 成功,batch_id:{batch_id}")
print("file_urls:", urls)
# 6.逐个上传本地文件到对应的urls
for i upload_url in enumrate(urls):
path = Path(file_paths[i])
with path.open("rb") as f:
res_upload = request.put(upload_url, data=f)
if res_upload.status_code, 响应:{}.status_code == 200:
print(f"{path.name} 上传成功")
else:
print(f{"path.name"} 上传失败,状态码:
{res_upload.status_code, 响应:{res_upload.text}})
return batch_id, files_info
# 本地文件上传
mineru_upload_file_demo()
# 解析上传的文件
def mineru_check_result_demo(batch_id: str, max_retries: int = 30, interval: int = 3):
"""
轮询 MinerU 批量解析结果,直到人物完成或超过重试机会
:param batch_id: 调用/extract/task时返回的batch_id
:param max_retries: 最大轮询次数
:param interval: 每次轮询间隔秒数
"""
import os
import time
import requests
token = os.getenv("MINERU_TOKEN")
load_dotenv()
if not token:
raise RuntimeError("环境变量 MINERU_TAKEN 未配置")
# 1.申请上传URL
url = "https://mineru.net/api/v4/file-urls/batch"
# 2.定义请求头
header = {
"Content-Type": "application/json",
"Authorization": f"Bearer {token}"
}
for i in range(max_retries):
resp = requests.get(url, headers=header)
if resp.status_code != 200:
print(f"请求失败,状态码:{resp.status_code},
响应内容: {resp.text}")
return None
data = resp.json()
# 结构示例:data["data"]["extract_result"] 是列表
extract_list = data.get("data", {}).get("extract_result", [])
if not extract_list:
print("返回结果中没有 extract_result 字段,", data)
return None
item = extract_list[0]
state = item.get("state")
print(f"第 {i+1} 次查询,当前状态:{state}")
if state == "done":
full_zip_url = item.get("full_zip_url")
print("任务已完成,结果 zip 下载地址:", full_zip_url)
return full_zip_url
elif stats in ("failed", "error"):
print("任务失败,返回信息:", item)
#还未完成,等待后重试
time.sleep(interval)
print(f"超过最大重试次数{}, 任务未完成,请稍后重试。")
return None
mineru_check_result_demo("batch_id")
3、文档切分
3.1 为什么切分?
获取 Document 对象后,需要将其切分成 Chunk(文本块),以 Chunk 为基本单位进行存储和检索。

3.2 切分的核心考量
既然要切分,那么怎么切、在哪儿切就成了关键问题。切分需要平衡三个维度:

3.3 切分策略对比

3.4 递归字符切分器
工作原理
核心思想:定义分隔符优先级列表(如 "\\n\\n", "\\n", " ", ""),按优先级依次尝试切分:
- 先用最高优先级分隔符(如 \n\n)切分整段文本
- 检查每个切分块是否超过 chunk_size
- 若超限,对该块降级使用下一级分隔符继续切分
- 递归直到所有块都不超限,或降级到字符级切分("")
分隔符优先级的语义含义:

RecursiveCharacterTextSplitter切分器
python
# uv add langchain-text-splitters
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.document_loaders
import UnstructuredWordDocumentLoader
# 加载文档
docs = UnstructuredWordDocumentLoader(
file_path="assets/sample.docx",
mode="single"
).load()
# 切分为文本块
rc_text_splitter = RecursiveCharacterTextSplitter(
separators=["\n\n", "\n", "。", "!", "?", "......", " ", ""],
# 分隔符优先级列表
chunk_size=400, # 每个块的最大长度
chunk_overlap=0, # 相邻块重叠长度
length_function=len, # 长度计算函数
)
# 切分器切分
rc_text_splitter.split_text()
rc_text_splitter.split_documents(docs)
# 统计块数量
print(f"切分得到 {len(chunks)} 个文本块\n")
# 可选:查看前几个块内容和元数据
for i, chunk in enumerate(chunks[:5]): # 只看前 5 个
print(f"=== Chunk {i} ===")
print(chunk.page_content)
print("metadata:", chunk.metadata)
print("==========\n")
4、文本嵌入
4.1 为什么要嵌入
4.2 常用的嵌入模型

4.3 Embedding抽象接口
python
@abstractmethod
def embed_documents(self, texts: list[str]) -> list[list[float]]:
"""将多段文档文本嵌入为向量列表"""
@abstractmethod
def embed_query(self, text: str) -> list[float]:
"""将单条查询文本嵌入为向量"""
4.4 HuggingFace嵌入
python
# uv install sentence-transformers langchain_huggingface
from langchain_huggingface import HuggingFaceEmbeddings
def embedding_demo():
# 1. 实例化嵌入模型
embed_model = HuggingFaceEmbeddings(
model_name=r'D:\ai_models\huggingface_cache\bge-base-zh-v1.5'
)
# 单文本嵌入
query = "你好,世界"
query_result = embed_model.embed_query(query) # list[float]
print(len(query_result)) # 768
print(query_result[0:10])
# 多文本嵌入
docs = ["你好,世界", "你好,世界"]
res = embed_model.embed_documents(docs)
print(type(res)) # list[list[float]]
embedding_demo()
4.5 OpenAI嵌入
4.6 BGE-M3:同时生成稠密与稀疏向量
BGE-M3 是 BAAI 推出的多语言嵌入模型,最大的特点是一次编码,同时输出稠密向量和稀疏向量:
- **稠密向量:**由 Transformer Encoder 生成,捕捉整体语义,输出固定维度向量,适合语义相似度匹配
- **稀疏向量:**同样由 Transformer Encoder 生成,但方式不同:对每个 token 分别计算重要性权重,只保留权重较高的 token 及其分数,输出"关键词-权重"的字典。同时补充了稀疏向量从早期 TF-IDF 统计方法到如今深度学习方法的演进脉络。

对比分析:

BGE-M3 基础用法就一件事:用 BGEM3FlagModel 把文本编码成向量。默认只出稠密向量,想要稀疏/多向量要手动开开关 。
return_sparse = True # 打开稀疏向量
return_dense = True # 打开稠密向量
python
# 最小可跑:只要稠密向量
from FlagEmbedding import BGEM3FlagModel
# use_fp16=True 只在 CUDA 上加速,CPU 可省略
model = BGEM3FlagModel("BAAI/bge-m3", use_fp16=True)
sentences_1 = ["如何重置路由器密码?", "BGE-M3 是什么?"]
sentences_2 = [
"Step by step to reset your router password.",
"BGE-M3 is a multilingual embedding model.",
]
emb1 = model.encode(sentences_1)["dense_vecs"] # (2, 1024)
emb2 = model.encode(sentences_2)["dense_vecs"] # (2, 1024)
sim = emb1 @ emb2.T # 此时内积 == 余弦
print(sim)
# 行=sentences_1,列=sentences_2,跨语言也能对齐
python
# 三路全开 (BGE-3M的真正价值)
out = model.encode(
sentences_1,
return_dense=True,
return_sparse=True,
return_colbert_vecs=True, # 多向量
)
dense = out["dense_vecs"] # (batch, 1024) 稠密向量
sparse = out["lexical_weights"] # List[{token_id: weight}] 词权重
colbert = out["colbert_vecs"] # List[np.ndarray] 每 token 一个向量
三个开关默认是 dense=True / sparse=False / colbert=False,用不到就别开,省算力 。
稠密 = 归一化后的内积(即余弦),稀疏 = 原始权重点积(禁止归一化),ColBERT = token 级归一化内积取 MaxSim。 三路分数各自归一化后再加权融合。
5、向量存储
5.1 什么是向量数据库?

5.2 主流选型

5.3 Milvus向量数据库

Milvus是一款云原生向量数据库,它具备高可用、高性能、易扩展的特点,用于海量向量数据的实时召回。整体采用共享存储架构 ,存储计算完全分离,计算节点可横向扩展。从架构上来看,Milvus遵循数据流和控制流分离,分为四个层次,分别是:
-
接入层(access layer)
由无状态 Proxy 组成,负责接收客户端请求、验证、路由和结果聚合。
-
协调服务(coordinator service)
系统"大脑",包含 Root、Query、Data、Index Coordinator,负责元数据管理、任务调度和集群协调。
- Root负责处理数据定义语言(DDL)和数据控制语言(DCL)请求。比如,创建或删除 collection、partition、index 等,同时负责维护中心授时服务 TSO 和时间窗口的推进;
- Query负责管理 query node 的拓扑结构和负载均衡以及从增长的 segment 移交切换到密封的 segment。
- Data负责管理 data node 的拓扑结构,维护数据的元信息以及触发 flush、compact 等后台数据操作。
- Index Coordinator负责管理 index node 的拓扑结构,构建索引和维护索引元信息。
-
执行节点(worker node)
实际干活的节点,Query Node 处理查询,Data Node 管理数据持久化,Index Node 构建向量索引。
- Query node 通过订阅消息存储(log broker)获取增量日志数据并转化为 growing segment,基于对象存储加载历史数据,提供标量 + 向量的混合查询和搜索功能。
- Data node 通过订阅消息存储获取增量日志数据,处理更改请求,并将日志数据打包存储在对象存储上实现日志快照持久化。
- Index node 负责执行索引构建任务。Index node 不需要常驻于内存,可以通过 serverless 的模式实现。
-
存储层(storage)
etcd 存元数据,Pulsar 或 Kafka 存消息日志,MinIO/S3 存对象文件。
存储服务是系统的骨骼,负责 Milvus 数据的持久化,分为元数据存储(meta store)、消息存储(log broker)和对象存储(object storage)三个部分。
- 元数据存储meta store负责存储元信息的快照;
- 对象存储object storage负责存储日志的快照文件、标量 / 向量索引文件以及查询的中间处理结果;
- 消息存储是一套支持回放的发布订阅系统,用于持久化流式写入的数据,以及可靠的异步执行查询、事件通知和结果返回。执行节点宕机恢复时,通过回放消息存储保证增量数据的完整性。
Milvus应用场景
- 图片检索系统:以图搜图,从海量数据库中即时返回与上传图片最相似的图片。
- 视频检索系统:将视频关键帧转化为向量并插入 Milvus,便可检索相似视频,或进行实时视频推荐。
- 音频检索系统:快速检索海量演讲、音乐、音效等音频数据,并返回相似音频。
- 分子式检索系统:超高速检索相似化学分子结构、超结构、子结构。
- 推荐系统:根据用户行为及需求推荐相关信息或商品。
- 智能问答机器人:交互式智能问答机器人可自动为用户答疑解惑。
- DNA 序列分类系统:通过对比相似 DNA 序列,仅需几毫秒便可精确对基因进行分类。
- 文本搜索引擎:帮助用户从文本数据库中通过关键词搜索所需信息。
5.4 Milvus核心概念
对比关系型数据库:

5.4.1 Collection与数据类型
Collection通过Schema定义有哪些字段及其类型,Milvus支持三大类型:

5.4.2 索引--加速搜索的关键
稠密向量索引 - HNSW

另一种稠密向量索引是FLAT,采用暴力搜索,每个查询直接与所有向量比较,能保证100%召回率,但速度最慢,仅适合小数据量或对精度要求极高的场景。
举例理解 HNSW------"在全国找餐厅"
假设你要在全中国几百万家餐厅中,找到和你口味最接近的那一家(口味 = 向量,口味的相似度 = 向量距离)。
- 暴力搜索(FLAT):拿着全国餐厅名录,从第一家挨个比到最后一家,几百万家全走一遍,速度极慢。
- HNSW 的做法:事先准备三张不同比例的地图,搜索时从粗到细、逐层下降:

对应到向量搜索的关键点:
- 每个"餐厅"就是数据库里的一个向量,"口味的相似度"就是向量之间的距离
- 顶层节点少、连接跨度大,可以用很少的步数跨越大范围,快速缩小搜索空间
- 逐层下降,每层贪婪搜索:在当前层的邻居中找离目标最近的节点,然后跳到下一层继续
- 底层包含所有节点,保证最终能找到真正最近的向量
- 搜索时间复杂度从暴力遍历的 O(n) 降到 O(log n)------就像你不需要走遍全国每条街,只需要"全国→城市→街区→街道"几步就到
稀疏向量索引 - SPARSE_INVERTED_INDEX
Milvus 里稠密和稀疏是两种字段类型、两套索引,混合检索就是两个字段各建索引、各搜一次再融合。


5.4.4 相似度度量
建立索引时必须指定度量方式,检索时也要支持。Milvus支持三种主要度量方式:



5.5 基本操作流程

5.5.1 定义Schemea
python
# pip install -U pymilvus
from pymilvus import MilvusClient
from pymilvus import DataType
# 1、方式一:连接远程Milvus服务
client = MilvusClient(urI="http://localhost:19530", token="root:Milvus")
# 2、方式二:本地文件,无需起服务(原型/单侧用)Milvus Lite
# client = MilvusClient("milvus_demo.db")
# 3、建Schema + 建集合 + 建索引
DIM = 1024 # 必须和你的embedding输出维度一致
schema = client.create_schema(auto_id=True)
# 自动建立索引
schema.add_field("id", DataType.Int64, is_primary=True)
# 建立标量
schema.add_field("text", DataType.VarChar, max_length=65536)
# 建立稠密向量:用于语义检索,维度与嵌入模型一致
schema.add_field("vector", DataType.FLOAT_VECTOR, dim=DIM)
# 建立稀疏向量:用于关键词检索
schema.add_field("sparse_vector", DataType.SPARSE_FLOAT_VECTOR)
# 建立元数据:存储来源、页码等信息,支持过滤
schema.add_field("metadata", DataType.JSON)
5.5.2 配置索引
python
# 配置索引
index_params = client.prepare_index_params()
# 稠密向量索引:使用HNSW + COSINE
index_params.add_index(
field_name="vector",
index_type="HNSW",
metric_type="COSINE", #未归一化,优选cosine
params={"M": 16, "efConstruction": 200}
)
# 稀疏向量:使用倒排索引 + IP度量
index_params.add_index(
field_name="sparse_vector",
index_type="SPARSE_INVERTED_INDEX",
metric_type="IP"
)
5.5.3 创建Collection
python
client.create_collection(
collection_name="docs",
schema=schema,
index_params=index_params,
)
把 index_params 传给 create_collection 时,Milvus 会建完索引并自动 load ;否则要手动 create_index + load_collection。
5.5.4 插入数据
将前面讲的串起来:加载文档--->切分--->嵌入--->插入Milvus
python
from langchain_community.document_loaders import UnstructuredWordDocumentLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from FlagEmbedding import BGEM3FlagModel
def insert_data(client: MilvusClient, collection_name: str):
# 1、加载文件
doc_list = UnstructuredWordDocumentLoader(
"assets/sample.docx", mode="single"
).load()
# 2、切分文件
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500, chunk_overlap=0
)
splitted_doc_list = text_splitter.split_documents(doc_list)
# 3、构建向量(同时生成稠密和稀疏向量)
model = BGEM3FlagModel("assets/models/bge-m3")
all_vectors = model.encode(
[doc.page_content for doc in splitted_doc_list],
return_dense=True, return_sparse=True
)
# 4、准备数据:组装成List[Dict],每个Dict对应Schema中的字段
insert_data_list = []
for doc, dense_vector, sparse_vector in zip(
splitted_doc_list,
all_vectors["dense_vecs"],
all_vectors['lexical_weights']
):
insert_data_list.append({
"vector": dense_vector,
"sparsevector": sparse_vector,
"metadata": doc.metadata,
"text": doc.page_content
})
# 5、插入数据
res = client.insert(collection_name=collection_name, data=insert_data_list)
print(res)
5.5.5 删除数据
python
def delete_demo(client):
res = client.delete(
collection_name="demo_collection",
# 通过ID删除,也可通过其他字段过滤
filter = "id in [id1,id2]",
)
print(res) # {'delete_count': 2}
5.5.6 完整案例
6. 检索
6.1 检索方式
Milvus支持多种检索方式:对向量字段支持精确检索(KNN)和近似近邻检索(ANN) ;对标量字段提供条件过滤,主要配合向量检索进行结果筛选。

Milvus检索体系全景图

6.2 稠密向量检索
python
def dense_vector_search_example(client, query: str, limit: int = 5):
model = get_bge_m3_model()
# 提出问题向量
dense_vec, _ = encode_query(model, query)
# search与query区别,前者偏向于向量,后者偏向于标量
results = client.search(
collection_name=COLLECTION_NAME,
data=[dense_vec], # 提出问题向量
anns_field="vector", # 稠密向量
limit=limit, # 最相似的向量(Top-k)
search_params={"metric_type": "COSINE"},
output_fields=["id", "text", "metadata"]
)
return results[0]
6.3 稀疏向量检索
python
def sparse_vector_search_example(client, query: str, limit: int = 5):
model = get_bge_m3_model()
_, sparse_vec = encode_query(model, query)
results = client.search(
collection_name=COLLECTION_NAME,
data=[sparse_vec],
anns_field="sparse_vector",
limit=limit,
search_params={"metric_type": "IP"},
output_fields=["id", "text", "metadata"]
)
return results[0]
代码简要说明:
- BGE-M3 模型:该模型支持同时生成稠密(Dense)和稀疏(Sparse)向量。
- 稠密检索 :使用
anns_field="vector",距离度量采用余弦相似度(COSINE)。 - 稀疏检索 :使用
anns_field="sparse_vector",距离度量采用内积(IP)。 - 两者均通过
output_fields指定了需要返回的字段(id、text、metadata)。
6.4 混合检索与重排序
混合检索将稠密向量(语义匹配)和稀疏向量(关键词匹配)结合,并通过重排序器(Reranker)对两路召回结果进行融合排序。
**重排序(Reranker)**是指在初步检索完成后,对候选结果进行二次排序优化。其目标不是扩大召回范围,而是在已有候选集内提升排序质量和结果相关性。
-
RRFRanker重排序
对某个文档 d,在每一路召回里的排名
rank_i(d)取倒数再求和:RRF_score(d) = Σ 1 / (k + rank_i(d))-
rank_i(d):d 在第 i 路结果里的位次(第 1 名 = 1,第 2 名 = 2...)
-
k:平滑常数,Milvus 默认 60
-
某路没召回 d → 那一路贡献 0
例:k=60 时
-
第1名:1/61 ≈ 0.0164
-
第 10 名:1/70 ≈ 0.0143
-
第 60 名:1/120 ≈ 0.0083
RRFRanker的工作流程
- 收集搜索排名
- 合并排名
- 汇总排名
pythonfrom pymilvus import MilvusClient, AnnSearchRequest, RRFRanker client = MilvusClient(uri="http://localhost:19530") dense_req = AnnSearchRequest( data=[query_dense_vec], anns_field="vector", param={"metric_type": "COSINE", "params": {"ef": 64}}, limit=50, # 粗召回留大一点,RRF 后再截 ) sparse_req = AnnSearchRequest( data=[query_sparse_vec],# bge-m3 稀疏 / BM25 函数产出 anns_field="sparse_vector", param={"metric_type": "IP"}, limit=50, ) res = client.hybrid_search( # hybrid_search混合检索 collection_name="rag_kb", reqs=[dense_req, sparse_req], ranker=RRFRanker(k=60), # 默认 60,可省略 limit=10, output_fields=["text", "source", "updated_at"], )稠密用
COSINE、稀疏用IP也完全没关系------RRF 根本不比较原始分,所以量纲不一致反而是它最舒服的场景。 -
-
加权排序器
加权排序器的工作流程:
- **Collections搜索得分:**收集向量搜索个路径的结果和分数:score
- **分数归一化:**用 arctan 把每路归一到 0, 1(COSINE 已在 -1,1 内做线性映射)
- **分配权限:**final = w1 * norm1 + w2 * norm2 + ...
- **合并分数:**按 final 降序出结果
pythonfrom pymilvus import ( AnnSearchRequest, WeightedRanker, MilvusClient ) dense_req = AnnSearchRequest( data=[query_dense_vec], anns_field="vector", param={"metric_type": "COSINE", "params": {"ef": 64}}, limit=50, ) sparse_req = AnnSearchRequest( data=[query_sparse_vec], # bge-m3 稀疏 / BM25 函数产出的稀疏向量 anns_field="sparse_vector", param={"metric_type": "IP"}, limit=50, ) # 稠密 0.7,稀疏 0.3 ------ 语义优先 ranker = WeightedRanker(0.7, 0.3) res = client.hybrid_search( collection_name="rag_kb", reqs=[dense_req, sparse_req], ranker=ranker, limit=10, output_fields=["text", "source", "updated_at"], )**一句话:**不知道哪路强 → 先用 RRF;有评测集证明某路该压过另一路 → 换 WeightedRanker。
典型反例:电商里"商品编码精确匹配"必须压过语义,这时候 WeightedRanker 把 sparse 权重拉到 0.7+ 才合理;普通客服问答两路旗鼓相当,RRF 更稳。
6.5 标量检索
python
client.load_collection("rag_kb")
res = client.query(
collection_name="rag_kb",
filter='tenant_id == 7 and source like "policy%" and updated_at >= "2024-01-01"',
output_fields=["id", "text", "doc_title", "updated_at"],
limit=100,
offset=0,
)
要点:
query()是精确匹配,返回所有满足条件的记录,不走 ANN- 不给
filter就是全表扫描(有limit兜底) offset支持,但深分页很慢 → 大数据量用query_iterator
7. 生成
python
def rag_demo(client: MilvusClient, query):
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
# 检索相关数据
retrieval_res = hybrid_vector_search_example_rrf(client=client, query=query)
# 构建上下文
context = "\n".join([data["entity"]["text"] for data in retrieval_res])
message_list = [
{
"role": "system",
"content": "你是一个专业的法律问答机器人,请根据上下文回答问题,"
"当上下文无法回答问题时,请回答'根据上下文无法回答该问题'"
},
{
"role": "user",
"content": f"根据以下上下文回答:{context}\n问题:{query}"
}
]
res = llm.invoke(message_list)
print(res.content)
8、小结
