6.6 Rerank 重排序：精排提升准确性

承前：从检索策略到精排

在上一节（6.5 节）中，我们系统讨论了 RAG 系统中的检索策略。从稠密向量检索（Dense Retrieval）到稀疏检索（BM25），再到混合检索（Hybrid Search），我们解决了"如何从海量文档中快速找到相关内容"的核心问题。这些方法的共同特点是：以速度为先，在百万级文档库中以毫秒级响应完成检索。

然而，速度的追求不可避免地带来了精度的妥协。无论是基于 Embedding 的稠密检索，还是基于关键词的 BM25，它们在排序相关性上都存在明显不足——经常出现"提到了关键词但语义不相关"的文档被排在前列的情况。本节将介绍的 Rerank 重排序技术，正是为了解决这一问题：在初筛检索的基础上，增加一个精确的"精选"阶段，将真正最相关的文档排到最前面。

为什么需要 Rerank：初筛后精选

理解 Rerank 最直观的方式，是借助"初筛后精选"这一生活类比。

想象你是一位图书编辑，需要从图书馆百万册藏书中找到关于"Transformer 注意力机制"的资料。你会怎么做？

• 第一步：初筛（快速粗选）——你不会逐页翻阅每一本书。你会先用图书馆的检索系统，输入关键词，快速获得一批候选书目（比如 100 本）。这一步追求的是"快"和"全"——宁可多选，不可遗漏。对应 RAG 中的一轮检索（Embedding 检索 / BM25 检索）。

• 第二步：精选（精确排序）——你拿到了 100 本候选书。这时你会翻阅每本书的目录和摘要，仔细判断哪几本最切题。这一步追求的是"准"——从 100 本中挑出最相关的 3-5 本。对应 RAG 中的 Rerank 重排序。

这种"两步走"的策略，正是 Rerank 的设计哲学：初筛求快，精选求精。

RAG 检索管道的两阶段架构：

海量文档库（百万级）
    │
    ▼
┌───────────────────────────────────────┐
│  阶段 1：初筛检索（Bi-Encoder）        │
│  - 目标：快速召回，宁多勿漏            │
│  - 方式：向量相似度 / BM25             │
│  - 召回：100-200 条候选                 │
│  - 耗时：毫秒级                        │
└───────────────────────────────────────┘
    │
    ▼
┌───────────────────────────────────────┐
│  阶段 2：Rerank 精排（Cross-Encoder）  │
│  - 目标：精准排序，优中选优            │
│  - 方式：深度交互打分                  │
│  - 输出：Top-5 文档                    │
│  - 耗时：秒级                          │
└───────────────────────────────────────┘
    │
    ▼
    LLM 基于精排后的 Top-5 文档生成答案

一个具体场景：用户查询"Transformer 的注意力机制如何工作？"

一轮检索（初筛）返回 Top-5：

排名	文档内容摘要	实际相关性
1	Transformer 架构由 Vaswani 提出...	高
2	注意力机制最早用于机器翻译...	高
3	BERT 使用 Transformer 编码器...	中
4	GPT-3 拥有 1750 亿参数...	低（偏题）
5	Transformer 在 CV 领域也有应用...	中

问题出在第 4 条：虽然提到了"Transformer"这个词，但内容讲的是模型参数量，与"注意力机制"毫无关系。但由于 Embedding 相似度较高，它被排在了第 4 位。

Rerank 后的排序：

排名	文档内容摘要	实际相关性
1	Transformer 架构由 Vaswani 提出，核心是自注意力...	最高
2	注意力机制允许模型关注输入的不同部分...	最高
3	Transformer 在 CV 领域也有应用，如 ViT...	中
4	BERT 使用 Transformer 编码器...	中
5	GPT-3 拥有 1750 亿参数...	低 ← 被降级

偏题的文档被正确降到了最后，最相关的内容浮到了最前面。这就是 Rerank 的价值：让真正的"精选"文档排在前面，减少 LLM 被无关信息干扰的风险。

Cross-Encoder vs Bi-Encoder：两种编码范式的本质差异

理解 Rerank，必须讲清楚两种编码器的本质区别。这是 Rerank 技术的理论基础。

Bi-Encoder（双塔模型）

Bi-Encoder 的核心思想是：将查询和文档分别独立编码成向量，然后通过向量相似度（如余弦相似度）计算相关性。

         ┌───────────────┐
文档 ───▶│   Encoder     │──▶ 文档向量 ─┐
         │ (Transformer)  │              │
         └───────────────┘              ├──▶ 余弦相似度
         ┌───────────────┐              │
查询 ───▶│   Encoder     │──▶ 查询向量 ─┘
         │ (Transformer)  │
         └───────────────┘

关键特征：
  ✅ 查询和文档独立编码，文档向量可预先计算并存储
  ✅ 检索速度快——仅需一次向量相似度计算
  ✅ 适合海量文档的快速召回
  ❌ 查询和文档之间没有交互，无法捕捉细粒度语义关系
  ❌ 精度受限——"提到了关键词"和"语义相关"是两回事

Embedding 模型（如 text-embedding-3、bge-m3）本质上就是 Bi-Encoder。它们的优势在于速度：文档向量在离线时预先计算好，查询时只需对查询编码一次，然后与数据库中的文档向量做相似度比对即可。

比喻：Bi-Encoder 就像给每本书贴一个标签（文档向量），给查询需求也贴一个标签（查询向量），然后比较标签的相似度。速度快，但标签是提前贴好的，不能根据具体查询动态调整。

Cross-Encoder（交叉编码器）

Cross-Encoder 的核心思想是：将查询和文档拼接在一起，作为一个整体输入到 Transformer 中进行联合编码，直接输出相关性分数。

         ┌─────────────────────────────────────┐
查询 ───▶│                                     │
         │  [CLS] 查询 [SEP] 文档 [SEP]         │──▶ 相关性得分（0-1）
文档 ───▶│         →  Transformer  →            │
         │      深度交互编码（Cross-Attention）  │
         └─────────────────────────────────────┘

关键特征：
  ✅ 查询和文档同时输入，进行深度交互（Cross-Attention）
  ✅ 精度显著高于 Bi-Encoder——能捕捉细粒度语义关系
  ✅ 能判断"提到关键词"和"真正相关"的区别
  ❌ 无法预先计算——每次查询都需要重新编码所有候选文档
  ❌ 速度慢——计算量是 Bi-Encoder 的 10-100 倍

Rerank 模型（如 Cohere Rerank、bge-reranker）本质上就是 Cross-Encoder。它们的优势在于精度：通过查询与文档的深度交互，能够精确判断相关性。

比喻：Cross-Encoder 就像一位专家审稿人，将你的查询和每一篇候选论文放在一起仔细对比，逐字阅读后才给出评分。精度极高，但每审一篇都要花时间。

两者对比一览

维度	Bi-Encoder（双塔）	Cross-Encoder（交叉）
编码方式	查询和文档分别编码	查询和文档拼接后联合编码
交互程度	无交互（仅最后做相似度计算）	深度交互（每层都有 Cross-Attention）
文档向量预计算	✅ 支持（离线计算，在线检索）	❌ 不支持（必须在线计算）
检索速度	快（毫秒级，百万级文档可行）	慢（秒级，仅适合百条候选）
排序精度	中等	高
适用场景	一轮检索（从海量文档中召回）	Rerank 精排（从候选中精选）
代表模型	text-embedding-3, bge-m3	Cohere Rerank, bge-reranker

两阶段检索范式

将 Bi-Encoder 和 Cross-Encoder 结合，就构成了经典的"两阶段检索"范式：

阶段 1：Bi-Encoder 粗筛
  输入：百万级文档库
  输出：100 条候选文档
  模型：text-embedding-3 / bge-m3
  耗时：毫秒级
  精度：中等（追求召回率，宁多勿漏）

        ↓

阶段 2：Cross-Encoder 精排
  输入：100 条候选文档
  输出：Top-5 文档
  模型：Cohere Rerank / bge-reranker
  耗时：秒级
  精度：高（追求精确排序，优中选优）

        ↓

最终结果：Top-5 精排文档 → 送入 LLM 生成答案

这种设计的精妙之处在于各取所长：Bi-Encoder 负责"又快又全"地从百万文档中召回候选，Cross-Encoder 负责"又准又精"地从候选中选出最优。两个阶段各司其职，在速度和精度之间取得平衡。

主流 Rerank 方案

目前业界主流的 Rerank 方案分为两类：商业 API 和开源模型。

方案一：Cohere Rerank（商业 API）

Cohere 提供的 Rerank API 是目前最流行的商业方案。无需部署模型，调用 API 即可完成重排序。

核心特点：

• API 调用，无需本地部署
• 多语言支持，中文表现优秀
• 支持 max_chunks_per_doc 参数，适合长文档分块处理
• 返回 relevance_score（0-1 归一化分数）

# ============================================================
# Cohere Rerank 基础用法
# ============================================================
import cohere  # 导入 Cohere 官方 SDK

# 创建客户端，需要有效的 API Key
# 注册地址：https://dashboard.cohere.com/
co = cohere.Client("your-api-key")  # 替换为你的 API Key

# 调用 rerank 接口
results = co.rerank(
    query="Transformer 的注意力机制是什么？",  # 用户查询
    documents=[  # 候选文档列表（来自一轮检索）
        "Transformer 架构由 Vaswani 在 2017 年提出，用于机器翻译。",
        "自注意力机制是 Transformer 的核心，允许模型关注所有位置。",
        "GPT-3 是一个大型语言模型，拥有 1750 亿参数。",
        "多头注意力通过并行计算多个注意力头来捕获不同语义。",
    ],
    model="rerank-v3.5",  # 使用最新模型
    top_n=3,  # 只返回前 3 条最相关的文档
)

# 遍历输出重排序结果
for r in results.results:  # results.results 是排序后的文档列表
    # r.index 是原列表中的索引
    # r.relevance_score 是相关性分数（0-1，越高越相关）
    # r.document['text'] 是文档原文
    print(f"  [{r.relevance_score:.4f}] {r.document['text'][:60]}...")

方案二：bge-reranker（BAAI 开源方案）

由智源研究院（BAAI）开源，中文能力极强，是中文场景下的首选开源方案。

核心特点：

• 完全开源，可本地部署，数据不出域
• 中文效果优异
• 支持多种尺寸：base、large、v2-m3
• 免费使用

模型	参数量	最大输入长度	特点
bge-reranker-base	278M	512	轻量快速，适合实时场景
bge-reranker-large	560M	512	精度更高，适合离线处理
bge-reranker-v2-m3	568M	8192	多语言 + 长文本，推荐首选

# ============================================================
# bge-reranker 本地部署基础用法
# ============================================================
from sentence_transformers import CrossEncoder  # Cross-Encoder 推理框架

# 加载 bge-reranker-v2-m3 模型
# 首次运行会自动从 HuggingFace 下载模型（约 2.2GB）
model = CrossEncoder(
    "BAAI/bge-reranker-v2-m3",  # 模型名称
    max_length=8192,  # 最大支持 8K 上下文
)

# 构建查询-文档对（Cross-Encoder 要求成对输入）
pairs = [
    # 第一对：查询 vs 文档1
    ["Transformer 的注意力机制是什么？",
     "Transformer 架构由 Vaswani 在 2017 年提出。"],
    # 第二对：同一查询 vs 文档2
    ["Transformer 的注意力机制是什么？",
     "自注意力机制是 Transformer 的核心创新。"],
    # 第三对：同一查询 vs 文档3（偏题）
    ["Transformer 的注意力机制是什么？",
     "GPT-3 是一个大型语言模型。"],
]

# 计算相关性得分
# scores 是一个数组，每个元素是对应查询-文档对的相关性分数
# 分数越高表示越相关，但没有固定范围（非归一化）
scores = model.predict(pairs)
for i, score in enumerate(scores):
    print(f"  文档 {i+1}: score={score:.4f}")

其他主流方案

方案	类型	特点
Cohere Rerank v3.5	商业 API	多语言，简单易用，零部署成本
bge-reranker-v2-m3	开源	中文最强，多语言，8K 长文本
mxbai-rerank-large	开源	英文优化，2B 参数，MTEB 高分
Jina Reranker v2	开源	8K 长度，多语言，轻量
Qwen3 Reranker	开源	2025 年 SOTA，基于 Qwen3

实战代码：完整的 RAG + Rerank 管道

下面通过一个完整的示例，展示 RAG 系统中 Rerank 的完整集成方式。

示例一：LangChain + Cohere Rerank

# ============================================================
# LangChain 集成 Cohere Rerank 完整示例
# 安装依赖：
#   pip install langchain langchain-openai langchain-chroma
#   pip install chromadb cohere langchain-cohere
# ============================================================

from langchain_openai import OpenAIEmbeddings, ChatOpenAI  # OpenAI Embedding 和 LLM
from langchain_chroma import Chroma  # Chroma 向量数据库
from langchain.retrievers import ContextualCompressionRetriever  # 压缩检索器（用于挂载 Rerank）
from langchain_cohere import CohereRerank  # Cohere Rerank 组件
from langchain_core.documents import Document  # 文档对象

# ====== 第 1 步：准备文档并创建向量存储 ======

documents = [
    # 每个文档包含 page_content（文本内容）和 metadata（元数据）
    Document(
        page_content="Transformer 是一种基于自注意力机制的神经网络架构。"
                      "它由 Vaswani 等人在 2017 年的论文《Attention Is All You Need》中提出。"
                      "Transformer 的核心组件包括多头注意力、位置编码和前馈神经网络。",
        metadata={"id": "doc_1"}  # 元数据用于标识文档来源
    ),
    Document(
        page_content="自注意力机制（Self-Attention）是 Transformer 的核心创新。"
                      "它允许模型在处理序列中的每个元素时，动态地关注所有其他元素。"
                      "自注意力的计算涉及 Query、Key、Value 三个矩阵。",
        metadata={"id": "doc_2"}
    ),
    Document(
        page_content="GPT-3 是 OpenAI 开发的大型语言模型，拥有 1750 亿参数。"
                      "它基于 Transformer 解码器架构，展示了强大的少样本学习能力。"
                      "GPT-3 可以执行翻译、问答、代码生成等多种任务。",
        metadata={"id": "doc_3"}  # 这篇文档偏题，Rerank 应将其降级
    ),
    Document(
        page_content="多头注意力（Multi-Head Attention）是自注意力的扩展。"
                      "它通过并行运行多个注意力头，让模型从不同表示子空间学习信息。"
                      "每个注意力头可以关注不同的语义关系，提高模型的表达能力。",
        metadata={"id": "doc_4"}
    ),
    Document(
        page_content="残差连接（Residual Connection）和层归一化（Layer Normalization）"
                      "是 Transformer 中的重要技术。残差连接解决了深层网络的梯度消失问题，"
                      "层归一化加速了训练过程并提高了模型稳定性。",
        metadata={"id": "doc_5"}
    ),
]

# 创建 Embedding 模型（Bi-Encoder，用于初筛）
embedding = OpenAIEmbeddings(model="text-embedding-3-small")

# 将文档存入 Chroma 向量数据库（自动完成向量化）
vectorstore = Chroma.from_documents(documents, embedding)

# 基础检索器：召回 k=10 条文档（宁多勿漏，为 Rerank 提供充足候选）
base_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# ====== 第 2 步：创建 Rerank 组件并挂载到检索器 ======

# 创建 Cohere Rerank 压缩器
# 需要设置环境变量 COHERE_API_KEY
compressor = CohereRerank(
    model="rerank-v3.5",  # 使用最新模型
    top_n=3,  # Rerank 后只保留 Top-3 最相关文档
)

# 用 ContextualCompressionRetriever 将 Rerank 挂载到基础检索器
# 工作流程：base_retriever 先召回 10 条 → compressor 精排保留 3 条
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,   # Rerank 组件
    base_retriever=base_retriever, # 基础检索器
)

# ====== 第 3 步：对比测试（有无 Rerank 效果差异）======

query = "Transformer 中的注意力机制是如何工作的？"

print("=" * 60)
print(f"查询: {query}")

# --- 无 Rerank：直接使用基础检索器 ---
print("\n--- 无 Rerank（向量检索 Top-3）---")
no_rerank_docs = base_retriever.invoke(query)  # 召回 Top-K
for i, doc in enumerate(no_rerank_docs[:3]):
    print(f"  {i+1}. [{doc.metadata['id']}] {doc.page_content[:80]}...")

# --- 有 Rerank：使用带 Rerank 的检索器 ---
print("\n--- 有 Rerank（Cohere Rerank Top-3）---")
# 以下两行需要有效的 COHERE_API_KEY 才能运行
reranked_docs = compression_retriever.invoke(query)  # 先召回再精排
for i, doc in enumerate(reranked_docs):
    print(f"  {i+1}. [{doc.metadata['id']}] {doc.page_content[:80]}...")

示例二：bge-reranker 本地部署（含性能分析）

# ============================================================
# bge-reranker 本地完整部署 + 性能基准测试
# 安装依赖：pip install sentence-transformers numpy
# ============================================================

from sentence_transformers import CrossEncoder
import numpy as np
import time  # 用于性能计时

# ====== 第 1 步：加载模型 ======
# 首次运行自动从 HuggingFace 下载（约 2.2GB）
model = CrossEncoder(
    "BAAI/bge-reranker-v2-m3",  # 模型名
    max_length=8192,  # 最大输入 token 长度
    device="cpu",     # CPU 推理；如有 GPU 改为 "cuda" 可大幅加速
)
print("bge-reranker-v2-m3 模型加载完成")

# ====== 第 2 步：模拟 RAG 检索 + Rerank 完整流程 ======

# 模拟一轮检索返回的候选文档（5 条）
candidates = [
    "Transformer 是一种基于自注意力机制的神经网络架构，由 Vaswani 等人在 2017 年提出。"
    "它完全摒弃了循环神经网络的结构，通过自注意力机制实现并行计算。",

    "自注意力机制允许模型在处理序列中的每个位置时，关注输入序列中的所有其他位置。"
    "这通过计算 Query、Key 和 Value 的加权和来实现。",

    "GPT-4 是 OpenAI 在 2023 年发布的多模态大模型，支持文本和图像输入。"
    "它在多个基准测试上取得了人类水平的表现。",  # 偏题文档

    "多头注意力通过并行运行多个注意力函数来扩展自注意力。"
    "每个注意力头可以学习不同的表示，增强了模型的表达能力。",

    "位置编码用于在 Transformer 中注入序列顺序信息。"
    "常见的包括正弦位置编码、可学习位置编码和旋转位置编码。",
]

query = "请详细解释 Transformer 的注意力机制"

# 构建查询-文档对列表
# Cross-Encoder 要求输入格式为 [query, document] 的成对列表
pairs = [[query, doc] for doc in candidates]  # 5 个查询-文档对

# 批量计算相关性得分
scores = model.predict(pairs)  # 返回 numpy 数组，每项一个得分

# 按得分降序排列（分数越高越相关）
ranked = sorted(
    zip(candidates, scores),  # 将文档与分数配对
    key=lambda x: x[1],      # 按分数排序
    reverse=True              # 降序（从高到低）
)

print(f"\n查询: {query}")
print(f"\nRerank 结果 (共 {len(candidates)} 条候选):\n")
for i, (doc, score) in enumerate(ranked):
    print(f"排名 {i+1}: [score={score:.4f}]")
    print(f"  内容: {doc[:100]}...")
    print()

# ====== 第 3 步：性能基准测试 ======
# 测试不同候选数量下的 Rerank 耗时
# 这有助于在工程实践中决定 top_n 的取值

batch_sizes = [10, 50, 100, 200]  # 模拟不同候选数量
for batch_size in batch_sizes:
    # 构造测试数据
    test_pairs = [[query, f"测试文档 {i}"] for i in range(batch_size)]

    start = time.time()
    _ = model.predict(test_pairs)  # 执行 Rerank
    elapsed = time.time() - start  # 计算耗时

    print(f"Rerank {batch_size:3d} 条候选: {elapsed:.3f}s "
          f"(平均 {elapsed/batch_size*1000:.1f}ms/条)")

示例三：LlamaIndex 集成 Rerank

# ============================================================
# LlamaIndex 集成 Cohere Rerank
# 安装依赖：pip install llama-index llama-index-postprocessor-cohere-rerank
# ============================================================

from llama_index.core import VectorStoreIndex, Settings  # 索引构建与全局配置
from llama_index.embeddings.openai import OpenAIEmbedding   # OpenAI Embedding
from llama_index.llms.openai import OpenAI                 # OpenAI LLM
from llama_index.postprocessor.cohere_rerank import CohereRerank  # Cohere Rerank 后处理器
from llama_index.core import Document                       # 文档对象

# 全局配置：Embedding 模型和 LLM
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
Settings.llm = OpenAI(model="gpt-4o-mini", temperature=0)

# 准备文档库
documents = [
    Document(text="RAG 是检索增强生成技术，它结合了检索器和生成器。"),
    Document(text="Embedding 模型将文本转换为向量表示。"),
    Document(text="向量数据库如 Chroma 和 Milvus 用于存储和检索向量。"),
    Document(text="Rerank 重排序通过 Cross-Encoder 对检索结果进行精排。"),
    Document(text="Agent 是能够使用工具进行推理和行动的 AI 系统。"),
    Document(text="RAG 的三个核心步骤：文档分块、向量化、相似度检索。"),
]

# 创建向量索引
index = VectorStoreIndex.from_documents(documents)

# 创建查询引擎（带 Rerank 后处理器）
query_engine = index.as_query_engine(
    similarity_top_k=10,  # 先召回 10 条候选
    node_postprocessors=[
        # Rerank 作为后处理器，在检索后对结果进行重排序
        CohereRerank(
            api_key="your-cohere-api-key",  # 替换为你的 API Key
            model="rerank-v3.5",
            top_n=3,  # Rerank 后保留 3 条
        )
    ],
)

# 查询
response = query_engine.query("RAG 是什么？它的核心步骤有哪些？")
print(f"回答: {response}")

# 输出引用来源（Rerank 后的文档及其得分）
print(f"\n引用来源:")
for node in response.source_nodes:  # source_nodes 包含最终使用的文档
    # node.score 是 Rerank 后的相关性分数
    print(f"  [score={node.score:.4f}] {node.text[:80]}...")

常见误区

在实际使用 Rerank 时，开发者容易陷入以下几个误区。

误区一：认为 Rerank 可以替代一轮检索

有人认为 Cross-Encoder 精度高，直接用它检索所有文档即可。这是错误的。Cross-Encoder 速度极慢，对百万级文档逐一打分可能需要数小时甚至更久。Rerank 是第二阶段精排，必须配合第一阶段（Bi-Encoder 粗筛）使用。正确做法是：先用 Embedding 检索召回 100 条候选，再用 Rerank 精排。

误区二：Rerank 后的 top_n 设置过大

有些开发者将 top_n 设为 50 甚至 100，认为"多给 LLM 一些上下文总比少好"。实际上，过多的上下文不仅增加 LLM 的 Token 消耗和延迟，还可能引入噪声，反而降低答案质量。经验值是 3-5 条，即 top_n=3 或 top_n=5。

误区三：一轮检索召回太少就做 Rerank

如果一轮检索只召回 5 条文档，Rerank 的价值有限——候选池太小，精排的空间不大。推荐做法是：一轮检索召回 50-100 条，然后 Rerank 精排到 3-5 条。候选池足够大，Rerank 才能发挥"从众多候选中精选"的价值。

误区四：忽视 Rerank 模型的语言和领域适配

不同的 Rerank 模型在不同语言和领域上的表现差异很大。例如 bge-reranker 在中文上表现优异，但在某些英文专业领域可能不如 mxbai-rerank。选择模型时应根据自己的语言和领域需求进行评测，而不是盲目跟随排行榜。

误区五：以为 Rerank 分数是绝对概率

不同模型输出的分数含义不同。Cohere Rerank 返回的是 0-1 之间的归一化分数，而 bge-reranker 输出的是 logits（可能是任意实数，甚至为负）。不能跨模型比较绝对分数，只能在同一模型内部比较相对排序。

本节小结

本节围绕 Rerank 重排序技术展开，核心要点如下：

要点	说明
Rerank 的本质	初筛后精选——在 Bi-Encoder 快速召回的基础上，用 Cross-Encoder 精确排序
Bi-Encoder（双塔）	查询和文档独立编码，速度极快但精度有限，适合海量文档的粗筛
Cross-Encoder（交叉）	查询和文档联合编码，深度交互，精度高但速度慢，适合少量候选的精排
两阶段范式	Bi-Encoder 粗筛（百万→百条）+ Cross-Encoder 精排（百条→Top-5）
Cohere Rerank	商业 API，无需部署，多语言支持好，适合快速上手和验证
bge-reranker	开源方案，中文最强，可本地部署，适合生产环境
top_n 经验值	推荐设为 3-5 条，既保证相关性又避免噪声
候选池大小	一轮检索建议召回 50-100 条，给 Rerank 足够的精选空间

一句话总结：Rerank 是 RAG 检索管道的"第二道关卡"，用 Cross-Encoder 的深度交互弥补 Bi-Encoder 粗筛的精度不足，让最相关的文档浮到最前面，从而显著提升最终生成答案的准确性。

启后：从 Rerank 到高级 RAG

通过本节的学习，我们掌握了 Rerank 重排序的原理和实现方法。至此，我们已经构建了一条完整的"标准 RAG"管道：文档分块 → 向量化 → 一轮检索 → Rerank 精排 → LLM 生成。

然而，现实中的应用场景远比标准管道复杂。当文档需要复杂推理才能找到答案时，当单一查询无法覆盖多跳问题时，当需要在查询时动态改写用户意图时——标准 RAG 就显得力不从心了。

下一节（6.7 节）将介绍高级 RAG 技术，包括查询改写（Query Rewriting）、多跳检索（Multi-hop Retrieval）、自我纠错（Self-correction）等进阶策略，帮助 RAG 系统应对更复杂的真实场景。

参考资料

1. Cohere Rerank 官方文档 — Cohere Rerank API 使用指南与模型选择
2. bge-reranker GitHub — BAAI 开源 Rerank 模型及教程
3. Sentence-Transformers Cross-Encoder 文档 — 使用 Cross-Encoder 进行 Rerank 的完整教程
4. LangChain Cohere Rerank 集成 — LangChain 中 Rerank 的使用指南