深度解读：LlamaIndex 实现 RAG 重排序的关键要点

重排序就是在初始检索（Initial Retrieval）得到的一批候选文档（通常是 Top-k）中，再进行一次更精细的排序，以便把最相关的内容排在最前面。

瓦罗兰特顶级C位

368人浏览 · 2025-12-01 08:15:00

瓦罗兰特顶级C位 · 2025-12-01 08:15:00 发布

一、什么是重排序？

重排序就是在初始检索（Initial Retrieval）得到的一批候选文档（通常是 Top-k）中，再进行一次更精细的排序，以便把最相关的内容排在最前面。

这通常是一个二阶段检索流程中的第二阶段：

用户查询 → 初始检索（Faiss/Chroma） → Top-k候选文档 → 重排序模型 → 最终排序 → 输入给LLM


“重排序就是让模型在初步找到可能答案后，再认真地判断哪个最相关。” 它是提升 RAG 系统精度的“放大镜”，也是拉开好系统与一般系统差距的关键一环。

二、为什么需要重排序？

初始检索（如基于向量的最近邻）虽然快，但它的匹配能力较弱，可能：

把相似但不相关的文档排在前面
错过真正高度相关但表面不那么“近”的文档

重排序的目标是：

精细理解用户查询和文档之间的语义匹配
剔除无关或次相关的文档
提升最终生成内容的准确性、上下文性、相关性

三、重排序方法分类

1、传统方法（弱匹配）

基于规则（如关键词匹配、位置偏好）
BM25 再排序（与初始检索一样，只是重新打分排序）

2、语义方法（强匹配）

双塔模型（Dual Encoder）：

查询和文档分别编码，再计算相似度（快速，但略粗糙）

交叉编码器（Cross Encoder）：

把 Query 和 Document 作为一对输入，喂入一个 BERT/Transformer 模型中，输出一个相关性得分。
更精细（因为能看到全文交互），但计算慢，适合只在少量候选文档中使用

四、常用重排序模型

cross-encoder/ms-marco-MiniLM-L-6-v2（huggingface）
BAAI/bge-reranker-large（BAAI推出，中文和英文都很强，也有多语言版）
ColBERT（高效交叉建模）

五、LlamaIndex实现重排序的代码

前提:chroma向量数据库里已有大量关于劳动法相关的数据，可以直接进行查询。

1、初始化重排序模型

from llama_index.indices.postprocessor import SentenceTransformerRerank
# 初始化重排序器
reranker = SentenceTransformerRerank(
model=r"D:\Test\LLMTrain\testllm\llm\BAAI\bge-reranker-v2-m3",
top_n=3
)

2、构建查询引擎

question="劳动合同试用期最长多久?"
# 创建查询引擎
query_engine = index.as_query_engine(
similarity_top_k=10,  # 初始向量召回数量
text_qa_template=response_template,
node_postprocessors=[reranker]  # 重排序阶段
)
# 执行查询
response = query_engine.query(question)
# 显示结果
print(f"\n智能助手回答：\n{response.response}")
print("\n支持依据：")
for idx, node in enumerate(response.source_nodes, 1):
meta = node.metadata
print(f"\n[{idx}] {meta['full_title']}")
print(f"  来源文件：{meta['source_file']}")
print(f"  法律名称：{meta['law_name']}")
print(f"  条款内容：{node.text[:100]}...")
print(f"  相关度得分：{node.score:.4f}")

3、完整的示例代码

import json
import time
from pathlib import Path
from typing import List, Dict
import chromadb
from llama_index.core import VectorStoreIndex, StorageContext, Settings, get_response_synthesizer,PromptTemplate
from llama_index.core.schema import TextNode
from llama_index.llms.huggingface import HuggingFaceLLM
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core.postprocessor import SentenceTransformerRerank
# ================== 配置区 ==================
QA_TEMPLATE = (
"<|im_start|>system\n"
"您是中国劳动法领域专业助手，必须严格遵循以下规则：\n"
"1.仅使用提供的法律条文回答问题\n"
"2.若问题与劳动法无关或超出知识库范围，明确告知无法回答\n"
"3.引用条文时标注出处\n\n"
"可用法律条文（共{context_count}条）：\n{context_str}\n<|im_end|>\n"
"<|im_start|>user\n问题：{query_str}<|im_end|>\n"
"<|im_start|>assistant\n"
)
response_template = PromptTemplate(QA_TEMPLATE)
class Config:
RERANK_MODEL_PATH = r"D:\Test\LLMTrain\testllm\llm\BAAI\bge-reranker-v2-m3"  # 新增重排序模型路径
EMBED_MODEL_PATH = r"D:\Test\LLMTrain\testllm\llm\BAAI\bge-m3"
LLM_MODEL_PATH = r"D:\Test\LLMTrain\testllm\llm\Qwen\Qwen2___5-3B-Instruct"
DATA_DIR = r"D:\Test\LLMTrain\day23\data"
VECTOR_DB_DIR = r"D:\Test\LLMTrain\day23\chroma_db"
PERSIST_DIR = r"D:\Test\LLMTrain\day23\storage"
COLLECTION_NAME = "chinese_labor_laws"
TOP_K = 10  # 扩大初始检索数量
RERANK_TOP_K = 3  # 重排序后保留数量
# Embedding模型
embed_model = HuggingFaceEmbedding(
model_name=Config.EMBED_MODEL_PATH,
)
# LLM
llm = HuggingFaceLLM(
model_name=Config.LLM_MODEL_PATH,
tokenizer_name=Config.LLM_MODEL_PATH,
model_kwargs={
"trust_remote_code": True,
},
tokenizer_kwargs={"trust_remote_code": True},
generate_kwargs={"temperature": 0.3}
)
# 初始化重排序器（新增）
reranker = SentenceTransformerRerank(
model=Config.RERANK_MODEL_PATH,
top_n=Config.RERANK_TOP_K
)
Settings.embed_model = embed_model
Settings.llm = llm
chroma_client = chromadb.PersistentClient(path=Config.VECTOR_DB_DIR)
chroma_collection = chroma_client.get_or_create_collection(
name=Config.COLLECTION_NAME,
metadata={"hnsw:space": "cosine"})
print("从chromadb中加载索引...")
index = VectorStoreIndex.from_vector_store(ChromaVectorStore(chroma_collection=chroma_collection))
question="劳动合同试用期最长多久?"
# 创建查询引擎
query_engine = index.as_query_engine(
similarity_top_k=Config.TOP_K,  # 初始向量召回数量
text_qa_template=response_template,
node_postprocessors=[reranker]  # 重排序阶段
)
# 执行查询
response = query_engine.query(question)
# 显示结果
print(f"\n智能助手回答：\n{response.response}")
print("\n支持依据：")
for idx, node in enumerate(response.source_nodes, 1):
meta = node.metadata
print(f"\n[{idx}] {meta['full_title']}")
print(f"  来源文件：{meta['source_file']}")
print(f"  法律名称：{meta['law_name']}")
print(f"  条款内容：{node.text[:100]}...")
print(f"  相关度得分：{node.score:.4f}")

说明：

在其他 RAG 框架（如 LangChain、Haystack）中看到显式的 retriever 对象，但在 LlamaIndex 中，这个检索器是 “内嵌” 在 QueryEngine 里的，一般不需要手动创建 retriever。

比如以下代码：

query_engine = index.as_query_engine(
similarity_top_k=15,
node_postprocessors=[reranker],
llm=OpenAI(model="gpt-3.5-turbo")
)

其实做了 3 件事：

（1）内部构造了一个 Retriever：

similarity_top_k=15 就指定了初始召回的文档数
默认使用 VectorIndexRetriever（内部使用向量进行 ANN 检索）

（2）将结果送入 Re-Ranker（Postprocessor）处理

由你传入的 SentenceTransformerRerank 重新排序

（3）最终传给 LLM 回答问题

当然你也可以显示的使用retriever ，比如以下代码：

question="劳动合同试用期最长多久?"
# 0-创建检索器
retriever = index.as_retriever(
similarity_top_k=Config.TOP_K  # 扩大初始检索数量
)
# 0-创建响应合成器
response_synthesizer = get_response_synthesizer(
text_qa_template=response_template,
verbose=True
)
# 1. 初始检索
initial_nodes = retriever.retrieve(question)
# 保存初始分数到元数据
for node in initial_nodes:
node.node.metadata['initial_score'] = node.score
# 2. 重排序
reranked_nodes = reranker.postprocess_nodes(
initial_nodes,
query_str=question
)
# 3. 合成答案
response = response_synthesizer.synthesize(
question,
nodes=reranked_nodes
)
# 显示结果（修改显示逻辑）
print(f"\n智能助手回答：\n{response.response}")
print("\n支持依据：")
for idx, node in enumerate(reranked_nodes, 1):
# 兼容新版API的分数获取方式
initial_score = node.metadata.get('initial_score', node.score)  # 获取初始分数
rerank_score = node.score  # 重排序后的分数
meta = node.node.metadata
print(f"\n[{idx}] {meta['full_title']}")
print(f"  来源文件：{meta['source_file']}")
print(f"  法律名称：{meta['law_name']}")
print(f"  初始相关度：{node.node.metadata['initial_score']:.4f}")
print(f"  重排序得分：{node.score:.4f}")
print(f"  条款内容：{node.node.text[:100]}...")

六、过滤掉低质量文档

在 LlamaIndex 中使用重排序器（Re-Ranker）后，如果你想要进一步基于得分过滤掉低质量文档（例如 score < 0.5），你需要写一个自定义的 NodePostprocessor，因为内置的 SentenceTransformerRerank 本身不会主动做过滤 —— 它只是重排。

1、创建过滤器模块

文件：score_threshold_filter.py

from typing import List, Optional
from pydantic import Field
from llama_index.core.schema import NodeWithScore, QueryBundle
from llama_index.core.postprocessor.types import BaseNodePostprocessor
class ScoreThresholdFilter(BaseNodePostprocessor):
"""
自定义节点后处理器：根据得分阈值过滤节点，并在所有节点得分过低时提供回退机制。
参数:
threshold (float): 过滤的得分阈值，默认值为 0.5。
verbose (bool): 是否打印详细的过滤信息，默认值为 False。
"""
threshold: float = Field(default=0.5, description="过滤的得分阈值")
verbose: bool = Field(default=False, description="是否打印详细的过滤信息")
def _postprocess_nodes(
self,
nodes: List[NodeWithScore],
query_bundle: Optional[QueryBundle] = None,
) -> List[NodeWithScore]:
if self.verbose:
print(f"[ScoreThresholdFilter] 原始节点数: {len(nodes)}")
for idx, node in enumerate(nodes):
score_display = f"{node.score:.4f}" if node.score is not None else "None"
print(f"  节点 {idx + 1}: 得分 = {score_display}")
# 过滤得分低于阈值的节点
filtered_nodes = [
node for node in nodes
if node.score is None or node.score >= self.threshold
]
# 如果过滤后节点数少于1
if len(filtered_nodes) < 1:
if self.verbose:
print(f"[ScoreThresholdFilter] 所有节点得分均低于阈值 {self.threshold}，")
return filtered_nodes
if self.verbose:
print(f"[ScoreThresholdFilter] 过滤后节点数: {len(filtered_nodes)}，阈值: {self.threshold}")
for idx, node in enumerate(filtered_nodes):
score_display = f"{node.score:.4f}" if node.score is not None else "None"
print(f"  保留节点 {idx + 1}: 得分 = {score_display}")
return filtered_nodes

请注意以下几点：

BaseNodePostprocessor 是 LlamaIndex 提供的用于自定义节点后处理（Postprocessing）逻辑的基类。
使用了 pydantic 的 Field 来声明类字段，并提供了默认值和描述。
重写了 _postprocess_nodes 方法，这是 BaseNodePostprocessor 要求实现的抽象方法，用于处理节点列表。

2、使用过滤器

查询检索的主方法中调整如下代码：

from  score_threshold_filter import ScoreThresholdFilter
# 导入自定义过滤器，分数低于0.6将会被移除
score_filter = ScoreThresholdFilter(threshold=0.6, verbose=True)
# 创建查询引擎
query_engine = index.as_query_engine(
similarity_top_k=Config.TOP_K,  # 初始向量召回数量
text_qa_template=response_template,
node_postprocessors=[reranker,score_filter]  # 重排序+过滤低分
)

效果说明：

第一个后处理器（Re-ranker）会将召回的文档排序并附加 score
第二个后处理器（Filter）会把打分太低的文档剔除
最终剩下的文档会被拼接到 Prompt 里喂给 LLM

score 是 Re-ranker 打出来的，不是 similarity score（相似度）或 embedding 距离。

3、完整的示例代码

import json
import time
from pathlib import Path
from typing import List, Dict
import chromadb
from llama_index.core import VectorStoreIndex, StorageContext, Settings, get_response_synthesizer,PromptTemplate
from llama_index.core.schema import TextNode
from llama_index.llms.huggingface import HuggingFaceLLM
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core.postprocessor import SentenceTransformerRerank
from  score_threshold_filter import ScoreThresholdFilter
# ================== 配置区 ==================
QA_TEMPLATE = (
"<|im_start|>system\n"
"您是中国劳动法领域专业助手，必须严格遵循以下规则：\n"
"1.仅使用提供的法律条文回答问题\n"
"2.若问题与劳动法无关或超出知识库范围，明确告知无法回答\n"
"3.引用条文时标注出处\n\n"
"可用法律条文（共{context_count}条）：\n{context_str}\n<|im_end|>\n"
"<|im_start|>user\n问题：{query_str}<|im_end|>\n"
"<|im_start|>assistant\n"
)
response_template = PromptTemplate(QA_TEMPLATE)
class Config:
RERANK_MODEL_PATH = r"D:\Test\LLMTrain\testllm\llm\BAAI\bge-reranker-v2-m3"  # 新增重排序模型路径
EMBED_MODEL_PATH = r"D:\Test\LLMTrain\testllm\llm\BAAI\bge-m3"
LLM_MODEL_PATH = r"D:\Test\LLMTrain\testllm\llm\Qwen\Qwen2___5-3B-Instruct"
DATA_DIR = r"D:\Test\LLMTrain\day23\data"
VECTOR_DB_DIR = r"D:\Test\LLMTrain\day23\chroma_db"
PERSIST_DIR = r"D:\Test\LLMTrain\day23\storage"
COLLECTION_NAME = "chinese_labor_laws"
TOP_K = 10  # 扩大初始检索数量
RERANK_TOP_K = 3  # 重排序后保留数量
# Embedding模型
embed_model = HuggingFaceEmbedding(
model_name=Config.EMBED_MODEL_PATH,
)
# LLM
llm = HuggingFaceLLM(
model_name=Config.LLM_MODEL_PATH,
tokenizer_name=Config.LLM_MODEL_PATH,
model_kwargs={
"trust_remote_code": True,
},
tokenizer_kwargs={"trust_remote_code": True},
generate_kwargs={"temperature": 0.3}
)
# 初始化重排序器（新增）
reranker = SentenceTransformerRerank(
model=Config.RERANK_MODEL_PATH,
top_n=Config.RERANK_TOP_K
)
Settings.embed_model = embed_model
Settings.llm = llm
chroma_client = chromadb.PersistentClient(path=Config.VECTOR_DB_DIR)
chroma_collection = chroma_client.get_or_create_collection(
name=Config.COLLECTION_NAME,
metadata={"hnsw:space": "cosine"})
print("从chromadb中加载索引...")
index = VectorStoreIndex.from_vector_store(ChromaVectorStore(chroma_collection=chroma_collection))
#question="劳动合同试用期最长多久?"
question="什么是xtuner?"
# 导入自定义过滤器，分数低于0.6将会被移除
score_filter = ScoreThresholdFilter(threshold=0.6, verbose=True)
# 创建查询引擎
query_engine = index.as_query_engine(
similarity_top_k=Config.TOP_K,  # 初始向量召回数量
text_qa_template=response_template,
node_postprocessors=[reranker,score_filter], # 重排序+过滤低分
)
# 执行查询
response = query_engine.query(question)
if not response.response or response.response.strip() == "" or response.response.strip().lower() == "empty response":
print("未找到相关数据")
else:
# 显示结果
print(f"\n智能助手回答：\n{response.response}")
print("\n支持依据：")
for idx, node in enumerate(response.source_nodes, 1):
meta = node.metadata
print(f"\n[{idx}] {meta['full_title']}")
print(f"  来源文件：{meta['source_file']}")
print(f"  法律名称：{meta['law_name']}")
print(f"  条款内容：{node.text[:100]}...")
print(f"  相关度得分：{node.score:.4f}")

执行结果如下：

七、在 LlamaIndex 中，RAG 的流程

流程如下：

1️⃣ 用户输入 Query
↓
2️⃣ Retriever 召回相关文档（向量/BM25/多模态）
↓
3️⃣ NodePostprocessor 对召回结果进行处理
- 语义重排序
- 去重、过滤
- 分段、合并
↓
4️⃣ ResponseSynthesizer 拼接上下文并构造 Prompt
- response_mode: compact / refine / tree / summarize
↓
5️⃣ LLM 生成回答（基于 prompt + 文档）

想入门 AI 大模型却找不到清晰方向？备考大厂 AI 岗还在四处搜集零散资料？别再浪费时间啦！2025 年 AI 大模型全套学习资料已整理完毕，从学习路线到面试真题，从工具教程到行业报告，一站式覆盖你的所有需求，现在全部免费分享！

👇👇扫码免费领取全部内容👇👇