Documentation
¶
Overview ¶
Package reranker 提供高级重排序算法
Package reranker 提供文档重排序功能 ¶
Package reranker 提供文档重排序功能 ¶
Package reranker 提供文档重排序功能 ¶
Package reranker 提供辅助函数 ¶
Package reranker 提供文档重排序功能 ¶
Package reranker 提供文档重排序功能 ¶
Reranker 用于对检索到的文档进行二次排序，提高结果质量：
- 提升最相关文档的排名
- 增加结果多样性
- 优化上下文利用
Package reranker 提供文档重排序功能 ¶
Package reranker 提供文档重排序功能 ¶
Package reranker 提供文档重排序功能的类型定义
Index ¶
- type ChainOption
- type ChainReranker
- func (c *ChainReranker) Add(reranker Reranker) *ChainReranker
- func (c *ChainReranker) Len() int
- func (c *ChainReranker) Name() string
- func (c *ChainReranker) Prepend(reranker Reranker) *ChainReranker
- func (c *ChainReranker) Rerank(ctx context.Context, query string, docs []rag.Document) ([]rag.Document, error)
- func (c *ChainReranker) Rerankers() []Reranker
- type CohereOption
- type CohereReranker
- type CompressionOption
- type ContextualCompressionReranker
- type CrossEncoderOption
- type CrossEncoderReranker
- type DiversityOption
- type DiversityReranker
- type Embedder
- type LLMProvider
- type LLMReranker
- type LLMRerankerOption
- type LostInTheMiddleOption
- type LostInTheMiddleReranker
- type MMROption
- type MMRReranker
- type RRFOption
- type RRFReranker
- type RankedDocument
- type RankedDocuments
- type Reranker
- type ScoreOption
- type ScoreReranker
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type ChainOption ¶
type ChainOption func(*ChainReranker)
ChainOption ChainReranker 选项函数
func WithChainRerankers ¶
func WithChainRerankers(rerankers ...Reranker) ChainOption
WithChainRerankers 添加重排序器
参数：
- rerankers: 要添加的重排序器列表
type ChainReranker ¶
type ChainReranker struct {
// contains filtered or unexported fields
}
ChainReranker 链式组合重排序器
将多个重排序器串联执行，每个重排序器的输出作为下一个的输入。 常用于组合多种重排序策略：
- 先过滤低分文档
- 再用高质量模型精排
- 最后限制返回数量
使用示例：
reranker := NewChainReranker(
NewScoreReranker(WithScoreMin(0.5)), // 先过滤低分
NewCohereReranker("api-key"), // 再用 Cohere 精排
NewScoreReranker(WithScoreTopK(5)), // 最后取 Top 5
)
result, err := reranker.Rerank(ctx, "query", docs)
func NewChainReranker ¶
func NewChainReranker(rerankers ...Reranker) *ChainReranker
NewChainReranker 创建链式重排序器
参数：
- rerankers: 按执行顺序排列的重排序器
返回：
- 配置好的 ChainReranker 实例
使用示例：
r := NewChainReranker(
NewScoreReranker(WithScoreMin(0.3)),
NewLLMReranker(llm, WithLLMRerankerTopK(10)),
)
func (*ChainReranker) Add ¶
func (c *ChainReranker) Add(reranker Reranker) *ChainReranker
Add 向链中添加重排序器
参数：
- reranker: 要添加的重排序器
返回：
- 返回自身，支持链式调用
func (*ChainReranker) Name ¶
func (c *ChainReranker) Name() string
Name 返回重排序器名称
返回格式：ChainReranker(A -> B -> C)
func (*ChainReranker) Prepend ¶
func (c *ChainReranker) Prepend(reranker Reranker) *ChainReranker
Prepend 在链头部添加重排序器
参数：
- reranker: 要添加的重排序器
返回：
- 返回自身，支持链式调用
func (*ChainReranker) Rerank ¶
func (c *ChainReranker) Rerank(ctx context.Context, query string, docs []rag.Document) ([]rag.Document, error)
Rerank 按顺序执行所有重排序器
参数：
- ctx: 上下文
- query: 查询字符串
- docs: 待重排序的文档列表
返回：
- 重排序后的文档列表
- 错误信息（遇到第一个错误即返回）
func (*ChainReranker) Rerankers ¶
func (c *ChainReranker) Rerankers() []Reranker
Rerankers 返回链中所有重排序器的副本
type CohereOption ¶
type CohereOption func(*CohereReranker)
CohereOption CohereReranker 选项函数
func WithCohereAPIKey ¶
func WithCohereAPIKey(key string) CohereOption
WithCohereAPIKey 设置 API 密钥（可覆盖构造函数中的密钥）
参数：
- key: Cohere API 密钥
func WithCohereBaseURL ¶
func WithCohereBaseURL(url string) CohereOption
WithCohereBaseURL 设置 API 基础地址（用于测试或私有部署）
参数：
- url: API 基础地址
func WithCohereModel ¶
func WithCohereModel(model string) CohereOption
WithCohereModel 设置使用的模型
参数：
- model: 模型名称，如 "rerank-english-v3.0" 或 "rerank-multilingual-v3.0"
可选模型：
- rerank-english-v3.0: 英文专用模型
- rerank-multilingual-v3.0: 多语言模型
- rerank-english-v2.0: 旧版英文模型
- rerank-multilingual-v2.0: 旧版多语言模型
func WithCohereTimeout ¶
func WithCohereTimeout(timeout time.Duration) CohereOption
WithCohereTimeout 设置请求超时时间
参数：
- timeout: 超时时间
func WithCohereTopK ¶
func WithCohereTopK(k int) CohereOption
WithCohereTopK 设置返回数量
参数：
- k: 返回的最相关文档数量
type CohereReranker ¶
type CohereReranker struct {
// contains filtered or unexported fields
}
CohereReranker 使用 Cohere API 进行重排序
Cohere Rerank API 是一个高质量的商业重排序服务：
- 支持多语言（100+ 语言）
- 高精度的语义相关性评估
- 简单易用的 REST API
API 文档：https://docs.cohere.com/reference/rerank
使用示例：
reranker := NewCohereReranker("your-api-key",
WithCohereModel("rerank-multilingual-v3.0"),
WithCohereTopK(10),
)
result, err := reranker.Rerank(ctx, "query", docs)
func NewCohereReranker ¶
func NewCohereReranker(apiKey string, opts ...CohereOption) *CohereReranker
NewCohereReranker 创建 Cohere 重排序器
参数：
- apiKey: Cohere API 密钥
- opts: 可选配置项
返回：
- 配置好的 CohereReranker 实例
使用示例：
r := NewCohereReranker("your-api-key",
WithCohereModel("rerank-multilingual-v3.0"),
WithCohereTopK(10),
)
type CompressionOption ¶
type CompressionOption func(*ContextualCompressionReranker)
CompressionOption ContextualCompressionReranker 选项
func WithCompressionMinLength ¶
func WithCompressionMinLength(length int) CompressionOption
WithCompressionMinLength 设置最小保留长度
func WithCompressionRate ¶
func WithCompressionRate(rate float32) CompressionOption
WithCompressionRate 设置压缩率
func WithCompressionTopK ¶
func WithCompressionTopK(k int) CompressionOption
WithCompressionTopK 设置返回数量
type ContextualCompressionReranker ¶
type ContextualCompressionReranker struct {
// contains filtered or unexported fields
}
ContextualCompressionReranker 上下文压缩重排序器
通过 LLM 提取文档中与查询最相关的部分，压缩上下文：
- 减少 token 使用
- 提高信息密度
- 去除无关内容
func NewContextualCompressionReranker ¶
func NewContextualCompressionReranker(llm LLMProvider, opts ...CompressionOption) *ContextualCompressionReranker
NewContextualCompressionReranker 创建上下文压缩重排序器
func (*ContextualCompressionReranker) Name ¶
func (r *ContextualCompressionReranker) Name() string
Name 返回重排序器名称
type CrossEncoderOption ¶
type CrossEncoderOption func(*CrossEncoderReranker)
CrossEncoderOption CrossEncoderReranker 选项函数
func WithCrossEncoderBatchSize ¶
func WithCrossEncoderBatchSize(size int) CrossEncoderOption
WithCrossEncoderBatchSize 设置批处理大小
参数：
- size: 每批处理的文档数量，默认 32
func WithCrossEncoderModel ¶
func WithCrossEncoderModel(url string) CrossEncoderOption
WithCrossEncoderModel 设置模型服务地址
参数：
- url: 模型服务的完整 URL，例如 "http://localhost:9000/rerank"
func WithCrossEncoderTimeout ¶
func WithCrossEncoderTimeout(timeout time.Duration) CrossEncoderOption
WithCrossEncoderTimeout 设置请求超时时间
参数：
- timeout: 超时时间，默认 30 秒
func WithCrossEncoderTopK ¶
func WithCrossEncoderTopK(k int) CrossEncoderOption
WithCrossEncoderTopK 设置返回数量
参数：
- k: 返回的最相关文档数量，默认 10
type CrossEncoderReranker ¶
type CrossEncoderReranker struct {
// contains filtered or unexported fields
}
CrossEncoderReranker 跨编码器重排序器
跨编码器（Cross-Encoder）是一种高精度的相关性评估模型：
- 将查询和文档同时输入模型，计算相关性分数
- 精度高于双塔模型（Bi-Encoder），但速度较慢
- 适合在检索后对少量候选文档进行精排
使用方式：
- 需要部署支持 Cross-Encoder 的模型服务（如 sentence-transformers/cross-encoder）
- 通过 HTTP API 调用外部模型服务
使用示例：
reranker := NewCrossEncoderReranker(
WithCrossEncoderModel("http://localhost:9000/rerank"),
WithCrossEncoderTopK(10),
)
result, err := reranker.Rerank(ctx, "query", docs)
func NewCrossEncoderReranker ¶
func NewCrossEncoderReranker(opts ...CrossEncoderOption) *CrossEncoderReranker
NewCrossEncoderReranker 创建跨编码器重排序器
参数：
- opts: 可选配置项
返回：
- 配置好的 CrossEncoderReranker 实例
使用示例：
r := NewCrossEncoderReranker(
WithCrossEncoderModel("http://localhost:9000/rerank"),
WithCrossEncoderBatchSize(16),
WithCrossEncoderTopK(5),
)
type DiversityOption ¶
type DiversityOption func(*DiversityReranker)
DiversityOption DiversityReranker 选项
func WithDiversityBalance ¶
func WithDiversityBalance(factor float32) DiversityOption
WithDiversityBalance 设置平衡因子
func WithDiversityThreshold ¶
func WithDiversityThreshold(threshold float32) DiversityOption
WithDiversityThreshold 设置相似度阈值
type DiversityReranker ¶
type DiversityReranker struct {
// contains filtered or unexported fields
}
DiversityReranker 多样性重排序器
确保结果集具有多样性，避免返回过于相似的文档。 使用贪心算法选择：
- 与查询相关
- 与已选文档不太相似
func NewDiversityReranker ¶
func NewDiversityReranker(embedder Embedder, opts ...DiversityOption) *DiversityReranker
NewDiversityReranker 创建多样性重排序器
type Embedder ¶
type Embedder interface {
EmbedOne(ctx context.Context, text string) ([]float32, error)
Embed(ctx context.Context, texts []string) ([][]float32, error)
}
Embedder 向量嵌入器接口
type LLMProvider ¶
type LLMProvider interface {
// Complete 完成文本生成
//
// 参数：
// - ctx: 上下文
// - prompt: 提示词
//
// 返回：
// - 生成的文本
// - 错误信息
Complete(ctx context.Context, prompt string) (string, error)
}
LLMProvider LLM 提供者接口（简化版）
用于重排序器中需要调用 LLM 的场景
type LLMReranker ¶
type LLMReranker struct {
// contains filtered or unexported fields
}
LLMReranker 使用 LLM 进行重排序
通过让 LLM 评估查询与文档的相关性来实现重排序：
- 灵活性高，可以理解复杂的语义关系
- 成本较高，适合少量候选文档的精排
- 支持并发处理提高效率
注意：为避免过多 LLM 调用，默认最多处理 50 个文档。 可通过 WithLLMRerankerMaxDocuments 调整。
使用示例：
reranker := NewLLMReranker(llm,
WithLLMRerankerTopK(10),
WithLLMRerankerConcurrency(5),
)
result, err := reranker.Rerank(ctx, "query", docs)
func NewLLMReranker ¶
func NewLLMReranker(llm LLMProvider, opts ...LLMRerankerOption) *LLMReranker
NewLLMReranker 创建 LLM 重排序器
参数：
- llm: LLM 提供者实例
- opts: 可选配置项
返回：
- 配置好的 LLMReranker 实例
使用示例：
r := NewLLMReranker(llm,
WithLLMRerankerTopK(5),
WithLLMRerankerConcurrency(3),
)
type LLMRerankerOption ¶
type LLMRerankerOption func(*LLMReranker)
LLMRerankerOption LLMReranker 选项函数
func WithLLMRerankerConcurrency ¶
func WithLLMRerankerConcurrency(c int) LLMRerankerOption
WithLLMRerankerConcurrency 设置并发数
参数：
- c: 并发处理的文档数量
func WithLLMRerankerMaxDocuments ¶
func WithLLMRerankerMaxDocuments(max int) LLMRerankerOption
WithLLMRerankerMaxDocuments 设置最大处理文档数
超过此数量的文档将被截断（保留前 N 个）。 这是为了避免过多 LLM 调用导致成本过高。
参数：
- max: 最大文档数，默认 50
func WithLLMRerankerPromptTemplate ¶
func WithLLMRerankerPromptTemplate(template string) LLMRerankerOption
WithLLMRerankerPromptTemplate 设置评分提示词模板
模板中可使用的占位符：
- {{query}}: 查询字符串
- {{document}}: 文档内容
参数：
- template: 提示词模板
func WithLLMRerankerTopK ¶
func WithLLMRerankerTopK(k int) LLMRerankerOption
WithLLMRerankerTopK 设置返回数量
参数：
- k: 返回的最相关文档数量
type LostInTheMiddleOption ¶
type LostInTheMiddleOption func(*LostInTheMiddleReranker)
LostInTheMiddleOption LostInTheMiddleReranker 选项
func WithLostInTheMiddleStrategy ¶
func WithLostInTheMiddleStrategy(strategy string) LostInTheMiddleOption
WithLostInTheMiddleStrategy 设置重排策略
func WithLostInTheMiddleTopK ¶
func WithLostInTheMiddleTopK(k int) LostInTheMiddleOption
WithLostInTheMiddleTopK 设置返回数量
type LostInTheMiddleReranker ¶
type LostInTheMiddleReranker struct {
// contains filtered or unexported fields
}
LostInTheMiddleReranker "中间丢失"重排序器
研究表明，LLM 在处理长上下文时，对开头和结尾的信息关注度更高， 而中间部分的信息容易被忽略（Lost in the Middle）。
该重排序器将最重要的文档放在开头和结尾，次重要的放在中间：
位置分布: [最重要, 次重要, ..., 最不重要, ..., 次重要, 重要]
例如，输入 [1, 2, 3, 4, 5, 6] (按相关性降序) 输出: [1, 3, 5, 6, 4, 2]
func NewLostInTheMiddleReranker ¶
func NewLostInTheMiddleReranker(opts ...LostInTheMiddleOption) *LostInTheMiddleReranker
NewLostInTheMiddleReranker 创建"中间丢失"重排序器
func (*LostInTheMiddleReranker) Name ¶
func (r *LostInTheMiddleReranker) Name() string
Name 返回重排序器名称
type MMRReranker ¶
type MMRReranker struct {
// contains filtered or unexported fields
}
MMRReranker 最大边际相关性重排序器
MMR (Maximal Marginal Relevance) 是一种平衡相关性和多样性的算法：
- 选择与查询最相关的文档
- 同时确保文档之间具有多样性（避免冗余）
- 使用 lambda 参数控制相关性和多样性的权重
算法：
- 选择相关性最高的文档加入结果
- 对于剩余文档，计算 MMR 分数： MMR = λ × Sim(Doc, Query) - (1-λ) × max(Sim(Doc, Selected))
- 选择 MMR 分数最高的文档加入结果
- 重复直到达到 TopK
缓存机制：
- 相似度缓存仅在单次 Rerank 调用期间有效
- 每次调用 Rerank 时会清空缓存，避免内存无限增长
func NewMMRReranker ¶
func NewMMRReranker(embedder Embedder, opts ...MMROption) *MMRReranker
NewMMRReranker 创建 MMR 重排序器
type RRFOption ¶
type RRFOption func(*RRFReranker)
RRFOption RRFReranker 选项函数
type RRFReranker ¶
type RRFReranker struct {
// contains filtered or unexported fields
}
RRFReranker 倒数排名融合（Reciprocal Rank Fusion）重排序器
RRF 是一种简单有效的排名融合算法，常用于混合检索场景：
- 融合来自不同检索系统的结果（如向量检索 + 关键词检索）
- 不依赖原始分数，只使用排名位置
- 对异常分数不敏感
算法公式：
RRF(d) = Σ 1/(k + rank(d))
其中 k 是常数（通常为 60），rank(d) 是文档 d 在某个排名列表中的位置。
使用示例：
reranker := NewRRFReranker(
WithRRFK(60),
WithRRFTopK(10),
)
// 融合多个排名列表
result := reranker.FuseRankings(vectorResults, keywordResults)
func NewRRFReranker ¶
func NewRRFReranker(opts ...RRFOption) *RRFReranker
NewRRFReranker 创建 RRF 重排序器
参数：
- opts: 可选配置项
返回：
- 配置好的 RRFReranker 实例
使用示例：
r := NewRRFReranker(
WithRRFK(60),
WithRRFTopK(10),
)
func (*RRFReranker) FuseRankings ¶
func (r *RRFReranker) FuseRankings(rankings ...[]rag.Document) []rag.Document
FuseRankings 融合多个排名列表
这是 RRF 的主要用途：融合来自不同检索系统的结果。
参数：
- rankings: 多个排名列表，每个列表应该已按相关性降序排列
返回：
- 融合后的文档列表，按 RRF 分数降序排列
使用示例：
vectorResults := vectorRetriever.Retrieve(ctx, query) keywordResults := keywordRetriever.Retrieve(ctx, query) fusedResults := reranker.FuseRankings(vectorResults, keywordResults)
func (*RRFReranker) Rerank ¶
func (r *RRFReranker) Rerank(ctx context.Context, query string, docs []rag.Document) ([]rag.Document, error)
Rerank 对单个文档列表进行 RRF 重排序
注意：单个列表的 RRF 重排序实际上就是按原始分数排序后应用 RRF 分数。 对于融合多个列表，请使用 FuseRankings 方法。
参数：
- ctx: 上下文
- query: 查询字符串（RRF 不使用）
- docs: 待重排序的文档列表
返回：
- 重排序后的文档列表
- 错误信息
type RankedDocument ¶
type RankedDocument struct {
// 嵌入原始文档
rag.Document
// RelevanceScore 与查询的相关性得分
// 由重排序器计算，范围通常为 [0, 1]
RelevanceScore float32
// OriginalRank 原始排名（从 1 开始）
// 表示文档在重排序前的位置
OriginalRank int
// NewRank 新排名（从 1 开始）
// 表示文档在重排序后的位置
NewRank int
}
RankedDocument 带排名信息的文档
扩展了 rag.Document，添加了重排序相关的元信息：
- RelevanceScore: 与查询的相关性得分
- OriginalRank: 原始排名（重排序前）
- NewRank: 新排名（重排序后）
使用场景：
- 追踪文档在重排序过程中的排名变化
- 调试和分析重排序效果
- 评估重排序算法的性能
func (RankedDocument) ToDocument ¶
func (rd RankedDocument) ToDocument() rag.Document
ToDocument 将 RankedDocument 转换为普通 Document
注意：转换后会丢失排名信息
type RankedDocuments ¶
type RankedDocuments []RankedDocument
RankedDocuments 是 RankedDocument 的切片类型
func FromDocuments ¶
func FromDocuments(docs []rag.Document) RankedDocuments
FromDocuments 从普通文档列表创建 RankedDocuments
使用原始索引作为 OriginalRank，使用文档 Score 作为 RelevanceScore
func (RankedDocuments) ToDocuments ¶
func (rds RankedDocuments) ToDocuments() []rag.Document
ToDocuments 批量转换为普通文档列表
type Reranker ¶
type Reranker interface {
// Name 返回重排序器名称
Name() string
// Rerank 重排序文档
//
// 参数：
// - ctx: 上下文
// - query: 查询字符串
// - docs: 待重排序的文档列表
//
// 返回：
// - 重排序后的文档列表
// - 错误信息
Rerank(ctx context.Context, query string, docs []rag.Document) ([]rag.Document, error)
}
Reranker 文档重排序器接口
所有重排序器都实现此接口，提供统一的重排序能力
type ScoreOption ¶
type ScoreOption func(*ScoreReranker)
ScoreOption ScoreReranker 选项函数
func WithScoreMin ¶
func WithScoreMin(min float32) ScoreOption
WithScoreMin 设置最小分数阈值
参数：
- min: 最小分数，低于此分数的文档将被过滤。默认 0（不过滤）
注意：如果同时使用 normalize=true，过滤在归一化之前进行
func WithScoreNormalize ¶
func WithScoreNormalize(normalize bool) ScoreOption
WithScoreNormalize 设置是否归一化分数
参数：
- normalize: 是否将分数归一化到 [0, 1] 范围
归一化公式：
normalized = (score - min) / (max - min)
其中 min 和 max 是当前结果集中的最小和最大分数
type ScoreReranker ¶
type ScoreReranker struct {
// contains filtered or unexported fields
}
ScoreReranker 分数过滤重排序器
基于文档原有分数进行过滤和排序：
- 过滤低于阈值的文档
- 可选分数归一化
- 限制返回数量
使用场景：
- 过滤低相关性结果
- 统一不同检索系统的分数范围
- 简单快速的重排序
使用示例：
reranker := NewScoreReranker(
WithScoreMin(0.5),
WithScoreTopK(10),
WithScoreNormalize(true),
)
result, err := reranker.Rerank(ctx, "query", docs)
func NewScoreReranker ¶
func NewScoreReranker(opts ...ScoreOption) *ScoreReranker
NewScoreReranker 创建分数过滤重排序器
参数：
- opts: 可选配置项
返回：
- 配置好的 ScoreReranker 实例
使用示例：
r := NewScoreReranker(
WithScoreMin(0.5),
WithScoreTopK(10),
WithScoreNormalize(true),
)
Source Files