在基于 LangChain 构建 RAG（检索增强生成）系统时，一个常见痛点是：检索器返回的文档数量过多，导致输入 LLM 的上下文超出 token 限制，进而影响生成效果。本文将从检索优化、文档处理、结果精筛等六个维度，分享经过实战验证的解决方案，帮助开发者平衡信息完整性与上下文长度。

---

一、检索器参数优化：从源头控制信息量

1. 精准设置返回文档数量（k 值调节）

直接通过检索器的 k 参数控制召回文档数量，是最直接的优化手段。

代码示例：

from langchain.vectorstores import FAISS

# 将默认k=5调整为k=3，减少60%的检索结果
retriever = FAISS.from_documents(documents, embeddings).as_retriever(k=3)

适用场景： 当文档内容密度较高（如技术手册、法律条文）时，较小的 k 值即可覆盖关键信息。

2. 引入最大边际相关性（MMR）算法

传统检索侧重相关性，可能返回大量重复文档。MMR 通过 fetch_k 和 k 的配合，先召回更多文档（如 5 个），再筛选出最相关且最不重复的子集（如 2 个），平衡"精准"与"多样"。

代码实现：

retriever = vectorstore.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 2, "fetch_k": 5}  # 先选5个，再挑2个差异最大的
)

效果： 在保持关键信息的同时，减少冗余内容达 40%。

3. 基于元数据的智能过滤

利用文档元数据（如来源、时间、类型）精准过滤无效结果。例如只检索 2023 年的行业报告，或排除非技术类文档。

过滤示例：

retriever = vectorstore.as_retriever(
    search_kwargs={"filter": {"source": "whitepaper", "year": 2023}}
)

最佳实践： 在文档加载阶段（如 Document 对象）提前标注完整元数据，为后续过滤提供丰富维度。

---

二、文档分块策略：提升内容密度的核心

1. 智能分块算法选择

递归字符分块（推荐默认方案）

使用 RecursiveCharacterTextSplitter 避免切断句子，通过 chunk_size（建议 500-1000 tokens）和 chunk_overlap（50-100 tokens）平衡完整性与独立性。

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,  # 单个分块大小
    chunk_overlap=50,  # 相邻分块重叠量
    length_function=lambda x: len(tokenizer.encode(x))  # 基于token数计算长度
)

语义分块

结合句子嵌入模型（如 SBERT）检测语义边界，确保每个分块属于同一主题，减少跨主题内容干扰。

2. 上下文感知的分块增强

在分块时记录相邻内容的元数据，检索时可动态合并相关切片，避免单一分块信息孤立。

实现技巧：

docs = text_splitter.split_documents(documents)

for i, doc in enumerate(docs):
    doc.metadata["prev_chunk"] = docs[i-1].page_content if i > 0 else ""
    doc.metadata["next_chunk"] = docs[i+1].page_content if i < len(docs)-1 else ""

优势： 在保持分块独立性的同时，保留上下文关联，使单文档检索结果更完整。

---

三、结果精筛与摘要：压缩上下文的关键

1. 检索结果摘要化处理

通过 LLM 对检索结果进行摘要，将冗长内容转化为关键信息集合。推荐使用 map_reduce 链处理多文档摘要：

from langchain.chains.summarize import load_summarize_chain

# 加载摘要链，支持批量处理多个文档
summarize_chain = load_summarize_chain(llm, chain_type="map_reduce")

# 将1000 tokens的原始内容压缩为200 tokens的摘要
summary = summarize_chain.run(retrieved_docs)

注意： 选择摘要模型时，优先使用专为压缩设计的模型（如 T5-small、DistilBART），减少计算开销。

2. 重排序模型提升相关性

在向量检索基础上，通过独立重排序模型（如 BGE-Reranker、Cohere Rerank）对结果进行二次排序，剔除低相关文档。

集成方案：

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

# 先通过向量检索召回，再用LLM筛选最相关内容
compressor = LLMChainExtractor.from_llm(llm)

retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=vectorstore.as_retriever(k=5)
)

数据验证： 结合重排序后，Top-3 文档的相关性平均提升 30%。

---

四、高级检索技术：多维度优化召回质量

1. 多路召回融合（Multi-Query Retrieval）

同时使用向量检索（处理语义匹配）和关键词检索（处理精确匹配），通过 MultiVectorRetriever 合并结果，减少单一检索方式的偏差。

典型应用：

from langchain.retrievers import MultiQueryRetriever

retriever = MultiQueryRetriever(
    vectorstore=vectorstore,
    llm=llm,
    num_queries=3  # 生成3个变体查询进行检索
)

# 合并不同查询视角的结果，提升召回全面性
retrieved_docs = retriever.get_relevant_documents(query)

适用场景： 复杂查询（如包含多实体、模糊表述）时效果显著。

2. 层级结构自动合并（Llamaindex 集成）

利用 Llamaindex 的树状索引结构，自动识别并合并属于同一父节点的子分块，避免零散内容堆砌。

操作流程：

# 转换为Llamaindex文档并构建层级索引
from llamaindex import GPTSimpleVectorIndex

llama_docs = [Document(doc.page_content, metadata=doc.metadata) for doc in docs]
index = GPTSimpleVectorIndex.from_documents(llama_docs)

# 通过树状摘要模式合并相关节点
response = index.query(query, response_mode="tree_summarize")

核心价值： 将碎片化分块转化为逻辑完整的段落，减少无效上下文。

---

五、模型与流程优化：适配长上下文的底层调整

1. 切换长上下文 LLM 模型

若业务允许，直接使用支持更大 token 限制的模型（如 Anthropic Claude-2-100k 支持 100k tokens，GPT-4-128k 支持 128k tokens），从底层扩展上下文容量。

成本提示： 长上下文模型单价通常较高，建议仅在关键流程（如最终生成）使用，中间环节（如摘要）使用基础模型。

2. 分批次生成策略

将超长上下文拆分为多个批次（如每 2000 tokens 一批），逐次输入模型并合并结果，避免单次调用超出限制。

实现逻辑：

def process_long_context(contexts, query, batch_size=2000):
    results = []
    for i in range(0, len(contexts), batch_size):
        batch = contexts[i:i+batch_size]
        # 对每个批次单独生成，降低单次输入长度
        result = llm(f"Context: {batch}\nQuery: {query}")
        results.append(result)
    return "\n".join(results)

注意事项： 批次间需保留 100-200 tokens 的重叠，避免切断语义关联。

3. 嵌入结果缓存机制

通过 CacheBackedEmbeddings 缓存文档嵌入向量，避免重复计算，提升检索效率（尤其适用于频繁查询场景）。

from langchain.embeddings import CacheBackedEmbeddings
from langchain.vectorstores import InMemoryStore

# 使用内存或Redis缓存嵌入结果
cache = InMemoryStore()

cached_embeddings = CacheBackedEmbeddings.from_bytes_store(
    underlying_embedder=embeddings,
    document_embedding_cache=cache
)

性能提升： 重复文档的嵌入速度提升 90% 以上。

---

六、实战调优指南：从经验到数据驱动

1. 分块参数动态调整

根据不同文档类型调整参数：

• 技术文档： chunk_size=1000（完整保留章节结构），chunk_overlap=100（确保公式/图表关联）
• 新闻资讯： chunk_size=500（符合段落长度），chunk_overlap=50（避免跨事件内容）
• 对话记录： chunk_size=300（按对话轮次分块），chunk_overlap=30（保留上下文逻辑）

2. 效果评估体系搭建

使用 LangChain 内置的 RagEvaluator 评估分块质量，重点关注：

• 相关性得分： 检索结果与查询的语义匹配度（推荐 > 0.7）
• 冗余度指标： 重复内容占比（理想 < 15%）
• token 利用率： 有效信息占总输入的比例（目标 > 60%）

3. 持续迭代优化

建立「检索→生成→反馈」闭环：

1. 收集用户反馈的错误案例
2. 分析是否因上下文过长导致信息丢失
3. 针对性调整 k 值、分块策略或摘要模型
4. 重新评估关键指标并固化最优参数

---

结语：在信息完整与效率间找到平衡

解决 RAG 上下文过长问题，本质是在「信息完整性」与「模型处理效率」之间寻找最优解。通过检索器的精准控制（如 MMR、元数据过滤）、分块策略的智能设计（如语义分块、上下文关联）、结果的深度处理（如摘要、重排序），配合长上下文模型和分批次处理等底层优化，可构建既高效又准确的 RAG 系统。

建议实施路径：

1. 从基础的 k 值调整和元数据过滤入手，快速降低上下文长度
2. 逐步引入 MMR、重排序等进阶技术提升质量
3. 通过分块策略优化和模型适配，实现系统的长期稳定运行

记住，持续的效果评估和参数迭代，是应对复杂业务场景的关键。

如果你在实践中遇到具体问题，欢迎在评论区留言，我们一起探讨更精细的解决方案！