LangChain入门学习(四)

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的工作流程

    • 收集搜索排名
    • 合并排名
    • 汇总排名
    python 复制代码
    from 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 降序出结果
    python 复制代码
    from 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、小结
相关推荐
特立独行的猫A9 小时前
别再用 nohup 了:让应用在后台常驻的正确姿势与 systemd 服务详解
java·后端·python
吃我一窝jio11 小时前
Python与Go线程模型深度对比
java·开发语言·python
zwd200512 小时前
Manim 怎么放大画面的某一部分?
python·动画·可视化·manim·数学动画
屿华AI13 小时前
AUTOSAR 实战-诊断工具 | UDS 0x27 安全访问的配置化实现:种子密钥算法插件化设计
python·测试工具·汽车
RobinDevNotes13 小时前
Claude Code 剪视频,不上传、不要 API Key
人工智能·python·音视频·开发工具·ipython
如夏倾城14 小时前
VRRP(虚拟路由器冗余协议Virtual Router Redundancy Protocol)
网络·python·网络协议·安全·智能路由器·负载均衡·信息与通信
IvanCodes15 小时前
LangChain(04):Runnable 与 LCEL 的执行与组合机制
python·langchain·agent
特创数字科技15 小时前
纯本地离线运行的文档脱敏工具(技术分享)
前端·驱动开发·python
东莞市云毅网络有限公司16 小时前
用 Playwright 搭一套问答平台引用监测的最小骨架
python·数据清洗·rag·企业知识库·文档解析