【万字长文】RAG系统分块策略完全指南：从基础到高级实践！

脱泥不tony

854人浏览 · 2025-12-15 15:26:21

脱泥不tony · 2025-12-15 15:26:21 发布

简介

本文全面介绍了RAG系统中的文档分块(Chunking)策略，从基础到高级详细解析了各种分块方法及其适用场景。重点讨论了分块对检索质量和生成响应的关键影响，对比了预分块与后分块策略，并详细介绍了固定大小、递归、基于文档、语义、LLM驱动、代理、后期、分层和自适应等多种分块技术。文章提供了选择最佳分块策略的指导原则和工具推荐，帮助开发者根据具体应用场景和数据特征优化RAG系统性能，提高检索准确性和生成质量。

在构建基于大型语言模型（LLM）的AI应用程序时，将生成式文本响应与特定领域数据相结合是获得准确答案的关键。检索增强生成（RAG）技术通过连接大型语言模型与外部知识源（如向量数据库）来实现这一目标。虽然许多开发人员关注向量数据库和嵌入模型的选择，但数据预处理，特别是文档分块（Chunking）策略，往往是影响RAG系统性能的最关键因素。

核心概念框架

时间维度分类

Pre-Chunking（预分块）：文档索引前进行分割
Post-Chunking（后分块）：查询时动态分割

主要分块策略

Fixed-Size（固定大小） → 基于标记/字符的简单分割
Recursive（递归） → 基于分隔符的结构感知分割
Document-Based（基于文档） → 根据标题、代码块、HTML标签分割
Semantic（语义） → 基于嵌入的意义驱动分割
LLM-Based（基于LLM） → 模型定义的智能边界
Agentic（智能代理） → AI代理动态选择最优方法
Late Chunking（后期分块） → 先嵌入后分割，保留完整上下文
Hierarchical（分层） → 多层次块结构
Adaptive（自适应） → 根据内容密度动态调整参数

本文目录

什么是分块

简单来说，分块就是将大型文档分解成更小、更易于管理的部分（称为“块”）的过程。这是准备用于大型语言模型 (LLM) 的数据时至关重要的第一步。

主要原因是LLM****的上下文窗口有限，这意味着它们一次只能关注一定量的文本。如果上下文窗口内的文本过多，重要的细节就会丢失，导致答案不完整或不准确。

分块通过创建更小、更集中的内容片段来解决这个问题，LLM可以使用这些内容片段来回答用户的查询，而不会迷失在无关的信息中。

每个块的大小、内容和语义边界都会影响检索性能，因此决定使用哪种技术会对 RAG 系统的性能产生巨大的下游影响。

为什么分块对于 RAG 如此重要

分块可以说是影响 RAG 性能的最重要因素。文档的拆分方式会影响系统查找相关信息并提供准确答案的能力。当 RAG 系统性能不佳时，问题通常不在于检索器，而在于分块。即使是完美的检索系统，如果搜索准备不足的数据，也会失败。

这就带来了一个根本性的挑战：你的块需要易于矢量搜索找到，同时还要为 LLM****提供足够的上下文来创建有用的答案。

1. 优化检索

第一步是确保你的系统能够在向量数据库中找到正确的信息。向量搜索通过将用户查询与你的块的嵌入进行比较来实现这一点。

过大的块存在以下问题：它们通常会将多个idea混杂在一起，导致子主题丢失或混乱。这就像试图通过平均所有章节来描述一本书。这会创建一个嘈杂的“平均”嵌入，无法清晰地表示任何单个主题，从而使向量检索步骤难以找到所有相关的上下文。
小而集中的块 能够捕捉一个清晰的idea。这会产生精确的嵌入，可以编码内容的所有细微差别。这使得你的系统更容易找到正确的信息。

2. 保留生成的上下文

系统找到最佳词块后，会将其传递给 LLM。在这里，上下文质量决定了输出响应的质量。

这里有一个简单的测试：如果一个片段在你单独阅读时对你来说是有意义的，那么它对 LLM 来说也是有意义的。

太小的块无法通过这项测试。想象一下，阅读一篇研究论文中间的一句话——如果没有更多的上下文，即使是人类也很难理解其中的含义。
过大的块会产生不同的问题。由于注意力稀释和“迷失在中间”效应，LLM 的性能会随着上下文输入的增加而下降。在这种情况下，模型难以访问隐藏在长上下文中间的信息，同时又无法很好地处理开头和结尾。随着上下文长度的增加，模型的注意力会分散到所有输入上，导致其查找相关信息的准确性降低，推理错误增多，并增加出现幻觉反应的可能性。

3. 分块好处

同时创建足够小的块以便精确检索，但又足够完整以便为LLM提供完整的上下文。这是上下文工程的一部分：以一种LLM能够理解并生成准确响应的方式准备输入。

好处：

提高检索质量： 通过创建集中的、语义完整的块，您可以使检索系统精确地找到查询的最精确的上下文。
管理 LLM 的上下文窗口： 有效的分块确保只有相关数据传递给 LLM，有助于避免上下文长度过长而导致模型混乱
减少幻觉： 通过为模型提供小而高度相关的块，您可以根据事实数据为其做出响应，并最大限度地降低其伪造信息的风险。
提高效率并降低成本： 处理较小的块速度更快、计算效率更高，从而缩短响应时间并降低 LLM 使用成本。

如果您正在寻找 Python 动手教程，请查看 Weaviate Academy 中的这个单元：https://docs.weaviate.io/academy/py/standalone/chunking

针对所有自学遇到困难的同学们，我帮大家系统梳理大模型学习脉络，将这份 LLM大模型资料 分享出来：包括LLM大模型书籍、640套大模型行业报告、LLM大模型学习视频、LLM大模型学习路线、开源大模型学习教程等, 😝有需要的小伙伴，可以 扫描下方二维码领取🆓↓↓↓

分块前 vs 分块后

既然我们已经讨论了分块的基本难题，那么我们可以探索在 RAG 流水线中 何时执行分块步骤。这个决定导致了两种主要策略：标准的预分块 和更高级的replace方案—— 后分块。

预分块是最常用的方法。它通过将文档分解成更小的块，然后再嵌入并存储到向量数据库中，从而异步处理文档。这种方法需要预先确定块的大小和边界，但由于所有块都经过预先计算和索引，因此可以在查询时实现快速检索。

后分块则采用了不同的方法，它首先嵌入整个文档，然后在查询时仅对实际检索到的文档进行分块。分块结果可以缓存，因此随着频繁访问的文档逐渐积累缓存的分块，系统速度会随着时间的推移而加快。这种方法避免了对可能永远不会被查询的文档进行分块，同时允许基于特定查询采用更动态、更上下文感知的分块策略。然而，这种方法会在首次访问时引入延迟，并且需要额外的基础设施决策。

分块

最佳的分块策略取决于您处理的文档类型以及 RAG 应用程序的需求。以下方法主要针对基于文本的文档。对于其他格式（例如 PDF），则需要执行其他步骤将其转换为纯文本。

如何处理 PDF？？

在对 PDF 进行分块之前，您需要清晰、结构化的文本。PDF 是一种可视化格式，因此提取文本可能比较棘手。列、表格、页眉或扫描页面可能会使文本提取不可靠。对于扫描文档，需要光学字符识别 (OCR)才能获取任何文本。

专业提示：最可靠的方法是先将 PDF 转换为 Markdown 等结构化格式。此预处理步骤可确保您在应用以下任何分块策略之前获得干净、逻辑有序的文本。建议看下Doling、PaddleOCR、mineru。

简单的分块

固定大小分块或token分块

固定大小的分块是最简单、最直接的方法。它将文本分割成预定大小的块，通常以标记（模型处理的文本片段）或字符来衡量。这种方法易于实现，但不尊重文本的语义结构。因此，它可能会断在句子甚至单词的中间，导致不协调的断句。

一种常见的解决方案是块重叠，即将一个块末尾的一些标记复制到下一个块的开头。这样可以保留在块边界处可能丢失的上下文。

主要考虑因素：

块大小：一个常见的起点是与嵌入模型的上下文窗口对齐的块大小。较小的块可能更适合捕捉细粒度的细节，而较大的块可能更适合理解更广泛的主题。
块重叠：典型的重叠在块大小的 10% 到 20% 之间。

何时使用：

快速构建原型，并评估 RAG 系统的性能基准。这是最容易上手的方法，尤其是在处理结构不一致的文档，或者您不确定要处理什么内容时。只需确保使用适当的重叠度（10-20%），这样当信息被拆分成多个块时，就不会丢失重要的上下文。

代码示例：

from typing import Listimport re# Split the text into units (words, in this case)def word_splitter(source_text: str) -> List[str]:    source_text = re.sub("\s+", " ", source_text)  # Replace multiple whitespces    return re.split("\s", source_text)  # Split by single whitespacedef get_chunks_fixed_size_with_overlap(text: str, chunk_size: int, overlap_fraction: float = 0.2) -> List[str]:    text_words = word_splitter(text)    overlap_int = int(chunk_size * overlap_fraction)    chunks = []    for i in range(0, len(text_words), chunk_size):        chunk_words = text_words[max(i - overlap_int, 0): i + chunk_size]        chunk = " ".join(chunk_words)        chunks.append(chunk)    return chunks

递归

递归分块是一种更细致的方法。它使用按优先级排列的常用分隔符列表来拆分文本，例如双换行符（用于段落）或单换行符（用于句子）。它首先尝试使用优先级最高的分隔符（用于段落）来拆分文本。如果任何生成的块仍然过大，则算法 会递归地 将下一个分隔符（用于句子）应用于该特定块。

该方法能够适应文档的结构，尽可能地保持结构相关的单元在一起。它避免了固定大小分块的突然切换，并确保每个分块保留其原始格式的结构。

推荐用于：非结构化文本文档，例如文章、博客文章和研究论文。这通常是一个可靠的默认选择。

代码示例：

from typing import Listdef recursive_chunking(text: str, max_chunk_size: int = 1000) -> List[str]    # Base case:if text is small enough, returnas single chunk    if len(text) <= max_chunk_size:        return [text.strip()] if text.strip() else []        # Try separators in priority order    separators = ["\n\n", "\n", ". ", " "]        for separator in separators:        if separator in text:            parts = text.split(separator)            chunks = []            current_chunk = ""                        for part in parts:                # Check if adding this part would exceed the limit                test_chunk = current_chunk + separator + part if current_chunk else part                                if len(test_chunk) <= max_chunk_size:                    current_chunk = test_chunk                else:                    # Save current chunk and start new one                    if current_chunk:                        chunks.append(current_chunk.strip())                    current_chunk = part                        # Add the final chunk            if current_chunk:                chunks.append(current_chunk.strip())                        # Recursively process any chunks that are still too large            final_chunks = []            for chunk in chunks:                if len(chunk) > max_chunk_size:                    final_chunks.extend(recursive_chunking(chunk, max_chunk_size))                else:                    final_chunks.append(chunk)                        return [chunk for chunk in final_chunks if chunk]        # Fallback: split by character limit if no separators work    return [text[i:i + max_chunk_size] for i in range(0, len(text), max_chunk_size)]

基于文档的分块

基于文档的分块利用文档的固有结构。它不依赖通用分隔符，而是根据文档特定于格式的元素来解析文档。例如：

Markdown：按标题（#, ##）拆分以捕获章节或小节。
HTML：通过标签（<p>, <div>）拆分以保留逻辑内容块。
PDF：经过预处理（例如，OCR 或转换为 Markdown）后，按标题、段落、表格或其他结构元素进行拆分。
编程代码：按函数或类（例如，def在 Python 中）拆分以维护代码的逻辑单元。

通过这种方法，区块与文档的逻辑组织保持一致，这通常也与语义相关。LangChain 和 LlamaIndex 都为各种文档类型（包括 Markdown、代码和 JSON）提供了专门的分割器。

适用场景： 结构化程度高且格式易于定义逻辑分隔的文档。非常适合 Markdown、HTML、源代码或任何具有清晰结构标记的文档。

代码示例：

from typing import Listimport redef markdown_document_chunking(text: str) -> List[str]:    # Split by markdown headers (# ## ### etc.)    header_pattern = r'^#{1,6}\s+.+$'    lines = text.split('\n')        chunks = []    current_chunk = []        for line in lines:        # Check if this line is a header        if re.match(header_pattern, line, re.MULTILINE):            # Save previous chunk if it has content            if current_chunk:                chunk_text = '\n'.join(current_chunk).strip()                if chunk_text:                    chunks.append(chunk_text)                        # Start new chunk with this header            current_chunk = [line]        else:            # Add line to current chunk            current_chunk.append(line)        # Add final chunk    if current_chunk:        chunk_text = '\n'.join(current_chunk).strip()        if chunk_text:            chunks.append(chunk_text)        return chunks

高级分块

语义分块（上下文感知分块）

语义分块从传统的基于规则的拆分转变为基于含义的分段。这种更先进的技术不再依赖于字符数或文档结构，而是根据文本的语义相似性进行划分。该过程包括：

句子分割：将文本分解成单独的句子
嵌入生成：将每个句子转换为向量嵌入
相似性分析：比较嵌入以检测语义断点（主题发生变化的地方）
块形成：在这些断点之间创建新的块

其结果是一组高度连贯的语义块，每个块都包含一个独立的想法或主题。这种方法非常适合密集、非结构化的文本，尤其适合于保留论点或叙述的逻辑流畅性。

推荐用于： 密集、非结构化的文本，用于保留想法的完整语义上下文。此方法适用于学术论文、法律文件或长篇故事。这些文本通常不会使用段落等清晰的分隔符来显示主题变化。当您处理语义边界与文档结构不完全一致的复杂内容时，此方法非常有用。

基于LLM的分块

基于 LLM 的分块使用大型语言模型 (LLM)来决定如何拆分文本。LLM 不依赖固定规则或基于向量的相似度得分，而是处理文档并生成语义连贯的块，通常还会添加额外的上下文、摘要或其他信息。这可以通过以下方式实现：

识别命题（将文本分解为清晰、合乎逻辑的陈述）
将各个部分概括成更小的、保留意义的块
突出重点，确保捕获最相关的信息

其结果是一组比传统方法更准确地保留语义的组块。这使得基于 LLM 的组块成为检索增强生成 (RAG) 最强大的策略之一。

适用场景： 高价值、复杂文档，检索质量至关重要，且预算不太重要。非常适合法律合同、研究论文、合规性文件或企业知识库。这种方法可以生成概括或突出关键思想的分块，但也存在一些弊端。与其他分块技术相比，它的计算成本最高，速度也最慢。

Agentic分块

Agentic分块技术将基于 LLM 的分块概念更进一步。AI Agent并非采用单一方法，而是动态地决定如何拆分文档。它会查看整个文档，包括其结构、密度和内容。然后，它会决定使用最佳的分块策略或多种策略组合。例如，Agent可能会识别出某个文档是 Markdown 文件。然后，它会根据文件标题拆分文件。它还可能发现，内容更密集的文档需要采用命题式方法。它甚至可以使用元数据标签来丰富分块，以实现更高级的检索。

这些“基于 LLM 的方法”可以创建非常清晰且上下文丰富的词块。然而，它们消耗大量的计算资源，成本也更高。它们通常需要为每个文档多次调用强大的模型。

适用场景： 高风险 RAG 系统，需要尽可能优化的分块，且成本并非关键因素。当您需要根据每个文档的独特特征定制分块策略时，RAG 系统是理想之选。

后期分块

后期分块是一种略有不同的技术，旨在解决其他分块策略中的一个常见问题：上下文丢失。

在其他分块技术中，当你先拆分文档，然后再创建嵌入时，每个块都会变得孤立。这可能会导致文档中先前解释或引用的块内出现歧义或丢失上下文。

后期分块的工作原理与此相反。您无需先进行拆分，而是先将整个文档输入到长上下文嵌入模型中。这会创建详细的、能够理解全貌的标记级嵌入。只有这样，您才能将文档拆分成多个块。

为每个块创建嵌入时，会使用已创建且包含完整上下文的标记嵌入。您只需对该块的相关标记嵌入进行平均即可。这意味着每个块都保留了整个文档的上下文。

何时使用： 在 RAG 系统中使用这种方法，因为检索质量取决于对词块与整个文档之间关系的理解。这对于技术文档、研究论文或法律文本非常有用。这些文档的某些部分会引用其他地方提到的想法、方法或定义。这有助于捕捉文档不同部分之间的联系，而常规的词块划分方法则会忽略这些联系。

分层分块

对于非常庞大且复杂的文档，分层分块可能会带来翻天覆地的变化。其原理非常简单：您可以创建多层级的、细节层次各异的分块。

在顶层，您可以创建大块内容来概括广泛的章节或主题，例如标题和摘要。
在下一层，您将这些部分分成越来越小的块，以捕获更精细的细节，例如论点、示例或定义。

这使得您的 RAG 系统能够从高层次的概览开始，然后在用户需要更多细节时深入到具体细节。LlamaIndexHierarchicalNodeParser让这种方法的实现变得非常简单。

适用场景： 非常庞大且复杂的文档，例如教科书、法律合同或详尽的技术手册。当您既需要回答高层次的、基于摘要的问题，又需要回答高度具体、详细的查询时，此策略是理想的选择。它能够在广泛的上下文和细粒度的访问之间找到一个良好的平衡点，避免了分层分块的复杂性，尽管它比基本的拆分方法更复杂。

自适应分块

自适应分块技术根据文档内容动态调整关键参数（如块大小和重叠）。

该方法并非对整篇文档应用单一固定的规则，而是将文本视为一个变化的场景。它可能会使用机器学习模型来分析不同部分的语义密度和结构。例如，它可以为复杂、信息丰富的段落自动创建更小、更细粒度的块，以捕捉细粒度的细节，而为更概括、更引言的部分使用更大的块。

目标是创建大小和边界根据其所包含的特定内容进行定制的块，从而实现更精确、更符合情境的检索。这与代理分块不同，Agentic分块是指Agent决定 _使用哪种分块策略_，而不是仅仅调整其中一种策略的参数。

适用场景： 内部结构多样且不一致的文档。想象一下，一份长篇报告包含密集的技术段落和稀疏的叙述部分。自适应策略在这方面表现出色，因为它避免了“一刀切”的问题。它可以为复杂的部分创建小的、粒度的块，以捕捉每个细节，并为较简单的文本创建较大的块，以保留上下文，所有这些都在同一文档中完成。

如何选择最佳分块

没有单一的“最佳”分块方法；最佳策略始终取决于您的具体用例。但在深入研究不同的技术之前，最重要的问题是：

“我的数据是否需要分块？”

分块旨在分解长篇非结构化文档。如果您的数据源已经包含简短完整的信息片段，例如常见问题解答、产品描述或社交媒体帖子，通常无需对其进行分块。分块甚至可能会造成问题。目标是创建有意义的语义单元，如果您的数据已经是这种格式，那么您就可以进入嵌入阶段了。

一旦您确认文档足够长，可以从分块中受益，您可以使用以下问题来指导您的策略选择：

我的文档的性质是什么？ 它们是高度结构化的（例如代码或 JSON），还是非结构化的叙述性文本？
我的 RAG 系统需要什么级别的细节？ 它需要检索具体的、细微的事实，还是需要总结更广泛的概念？
我使用哪种嵌入模型？ 输出向量的大小是多少（维度越高，存储更细粒度信息的能力就越强）？
我的用户查询有多复杂？ 它们是需要小块、有针对性的问题，还是需要更多上下文的复杂问题？

分块策略	工作原理	复杂	最适合	示例
固定大小（或令牌）	按标记或字符数拆分。	低的	小型或简单的文档，或速度最重要时	会议记录、简短的博客文章、电子邮件、简单的常见问题解答
递归	通过反复划分来分割文本，直到其适合所需的块大小，通常会保留一些结构。	中等的	需要保留一定结构但速度仍然很重要的文档	研究文章、产品指南、简短报告
基于文档	将每个文档视为单个块或仅在文档边界处分割。	低的	简短、独立的文档集合	新闻文章、客户支持单、短期合同
语义	按照自然含义的边界（主题、想法）分割文本。	中高	技术、学术或叙述性文件	科学论文、教科书、小说、白皮书
LLM	使用语言模型根据上下文、含义或任务需要来决定块边界。	高的	复杂文本中，意义感知分块可改善诸如摘要或问答之类的下游任务	长篇报告、法律意见、医疗记录
Agent	让Agent根据含义和结构决定如何分裂。	非常高	需要定制策略的复杂、细致的文档	监管备案、多部分合同、公司政策
后期分块	首先嵌入整个文档，然后从中派生块嵌入。	高的	需要了解完整文档上下文的用例	案例研究、综合手册、长篇分析报告
分层	将文本分为多个层级（章节 → 段落 → 句子）。保持结构完整。	中等的	大型结构化文档，例如手册、报告或合同	员工手册、政府法规、软件文档
自适应	使用 ML 或启发式方法动态调整块大小和重叠。	高的	具有不同结构和长度的混合数据集	来自多个来源的数据：博客、PDF、电子邮件、技术文档
代码	按逻辑代码块（函数、类、模块）拆分，同时保留语法。	中等的	源代码、脚本或编程文档	Python 模块、JavaScript 项目、API 文档、Jupyter 笔记本

工具和库

在为 RAG 应用程序设置数据提取管道时，您经常会面临分块的经典权衡：您可以依靠专门的库来提高速度和便利性，或者自己构建逻辑以实现完全控制。

框架

幸运的是，你不必从头开始。LLM 社区经常使用两个强大的开源库：LangChain 和 LlamaIndex，它们各自采用不同的分块方法：

LangChain：一个用于构建 LLM 应用程序的框架。其灵活性**TextSplitters****使其能够轻松地将分块集成到更大的系统中，例如多步骤 AI 代理**。

最适合：模块化工作流程，其中分块只是难题的一部分。

LlamaIndex：专为 RAG 管道设计。其先进的NodeParsers“节点”功能，针对数据提取和检索进行了优化。

最适合：高性能、以数据为中心的检索系统。

手动处理

除了使用库之外，您还可以自行实现分块逻辑。固定大小或递归分块等策略在 Python 中编写起来非常简单，让您可以完全掌控数据的处理方式，而无需在项目中添加外部依赖项。

最适合： 您想要避免添加大型库、需要实施高度自定义的分块策略或需要数据管道完全透明的项目。

ref:https://weaviate.io/blog/chunking-strategies-for-rag、阿东的大模型知识库

如何在企业中落地

在生产环境中优化块大小需要进行大量测试和审核。您可以采取以下一些步骤：

先从常见的基线策略入手，例如固定大小的分块。一个好的起点是将分块大小设置为 512 个 token，并将分块重叠设置为 50-100 个 token。这将为你提供一个可靠的基线，易于复现并与其他分块策略进行比较。
通过调整块大小和重叠等参数来尝试不同的分块方法，以找到最适合您的数据的方法。
通过运行典型查询并检查命中率、准确率和召回率等指标来测试检索的效果，看看哪种策略有效。
让人类参与审查检索到的块和 LLM 生成的响应 - 他们的反馈将捕捉到指标可能遗漏的内容。
持续监控 RAG 系统在生产中的性能，并准备根据需要迭代分块策略。