---
title: "RAG 分块大小与重叠设置：检索效果与 token 成本 | BroadRouter"
description: "分块大小和重叠如何改变 RAG 的召回率、索引规模、向量化成本，以及每次查询发给大模型的 token 数。附公开测试结果和具体计算。"
url: https://broadrouter.com/zh/blog/rag-chunk-size-overlap/
lang: zh-Hans
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

本页由英文原文借助 AI 翻译。[阅读英文原文](https://broadrouter.com/blog/rag-chunk-size-overlap/)（2026-11-16 更新）。

# RAG 分块大小与重叠：对检索效果和成本的影响

BroadNet Inference 团队 · 阅读约 7 分钟 · 发布于 2026-11-15 · 更新于 2026-11-16

先从约 256 到 512 token 的分块、0 到 15% 的重叠开始，并用你自己的查询调整 top-k。分块越大，每次查询发给大模型的 token 越多。重叠会让你向量化和存储的 token 乘以“大小 ÷（大小 − 重叠）”，所以 50% 的重叠会让索引翻倍。公开测试发现，小分块或无重叠的分块召回率往往不差，甚至更好。

## 要点

-   每次查询的输入大约是 top-k × 分块大小 + 提示词。从 5 × 400 改成 8 × 1,024 个 token，每次查询发送的输入约为原来的 3.4 倍。
-   重叠会让索引膨胀为“大小 ÷（大小 − 重叠）”倍：15% 的重叠最多约多出 18%（在本文测量的 10,000 token 文档上为 17%），50% 的重叠则翻倍。
-   在 Chroma 2024 年的评测中，200 到 400 token、无重叠的分块，效果持平或优于 800 token、重叠 400 的分块，而后者正是 OpenAI 文件搜索的默认设置。
-   NVIDIA 2025 年的测试没有找到唯一最佳的大小：事实型问题偏好 256 到 512 token，分析型问题偏好 1,024 token 或整页。
-   分块大小要用你的 embedding 模型的 token 来计算。有些切分器默认按字符计数。

**本页内容**

1.  分块大小和重叠会改变什么？
2.  关于分块大小，公开测试怎么说？
3.  重叠会让索引膨胀多少？
4.  分块大小对大模型账单有什么影响？
5.  怎么按 token 分块又不切断单词？
6.  怎么为你的数据选定这些数字？
7.  BroadNet Inference 适合什么场景

分块大小和重叠，是每条 RAG 流水线一开始就设定、之后却很少再回头看的两个数字。它们决定你要存多少个向量、要向量化多少 token、每个问题要发给大模型多少 token，以及能不能找到正确的段落。本文先介绍公开测试的发现，再一步步算清 token 账，让你在向量化之前就能看到每种设置的成本。

如果你还在考虑要不要用 RAG，先读[长上下文还是 RAG](https://broadrouter.com/zh/blog/long-context-vs-rag/)。处理阿拉伯语文档的话，请把[阿拉伯语 RAG](https://broadrouter.com/zh/blog/arabic-rag-search/) 和[阿拉伯语文本规范化](https://broadrouter.com/zh/blog/arabic-text-normalization-search/)与本文结合起来看。

## 分块大小和重叠会改变什么？

-   **分块大小**是你向量化和检索的每一块包含多少 token。
-   **重叠**是相邻分块共享多少 token，这样在边界处被切断的句子至少会在一个分块中完整出现。
-   **Top-k** 是每个问题检索多少个分块。

三者共同决定了四个量：

| 量 | 公式（长文档） |
| --- | --- |
| 存储的分块数 | 语料 token 数 ÷（大小 − 重叠） |
| 向量化的 token 数 | 语料 token 数 × 大小 ÷（大小 − 重叠） |
| 每次查询的上下文 | top-k × 大小 |
| 每次查询的大模型输入 | top-k × 大小 + 系统提示词 + 问题 |

前两项在每次建索引时支付一次，每次重新分块时再付一次。最后一项则在每个问题上都要付，永远如此。

## 关于分块大小，公开测试怎么说？

有两个公开评测值得了解，因为它们测量的东西不同。

\*\*Chroma（Smith 与 Troynikov，2024 年 7 月）\*\*在 token 层面衡量检索效果：相关文本被检索到了多少（召回率），以及检索到的内容中有多少是相关的。它每次检索五个分块，使用 OpenAI 的 text-embedding-3-large。部分结果：

| 切分器 | 大小（token） | 重叠 | 召回率 | IoU |
| --- | --- | --- | --- | --- |
| Recursive | 800 | 400 | 85.4% | 1.5% |
| Token | 800 | 400 | 87.9% | 1.4% |
| Recursive | 400 | 200 | 88.1% | 3.3% |
| Recursive | 400 | 0 | 89.5% | 3.6% |
| Recursive | 200 | 0 | 88.1% | 6.9% |

IoU（交并比）衡量检索到的文本中有多少是相关的，所以它同时也反映了浪费的 token。800/400 这两行对应 OpenAI 文件搜索的默认设置；假设使用 token 切分器，Chroma 发现这个设置的召回率略低于平均水平，其他指标则是最低的。更小、无重叠的分块召回率持平甚至更高，携带的无关文本也少得多。

\*\*NVIDIA（2025 年 6 月）\*\*在五个数据集上衡量端到端的回答准确率，测试了 128 到 2,048 token、15% 重叠的 token 分块，以及按页和按章节的分块。按页分块的平均准确率最高（0.648），方差也最小。最佳的 token 大小取决于问题类型：事实型数据集偏好 256 到 512 token，分析型偏好 1,024 token 或整页。128 和 2,048 这两个极端通常表现更差。

两者在一点上是一致的：**不存在通用的最佳大小**，而大分块加大重叠，很少是正确的默认值。

## 重叠会让索引膨胀多少？

每个分块向前推进“大小 − 重叠”个 token，所以索引相当于存了“大小 ÷（大小 − 重叠）”份语料。以一个 2,000,000 token、由 10,000 token 文档组成的语料为例：

| 大小 | 重叠 | 分块数 | 向量化的 token 数 | 膨胀倍数 |
| --- | --- | --- | --- | --- |
| 200 | 0 | 10,000 | 2,000,000 | 1.00× |
| 400 | 0 | 5,000 | 2,000,000 | 1.00× |
| 512 | 77 (15%) | 4,600 | 2,338,800 | 1.17× |
| 1,024 | 154 (15%) | 2,400 | 2,338,800 | 1.17× |
| 800 | 400 (50%) | 4,800 | 3,840,000 | 1.92× |
| 400 | 200 (50%) | 9,800 | 3,920,000 | 1.96× |

短文档的膨胀稍小一些，因为每篇文档的最后一个分块是不完整的。公式给出的是上限：15% 的重叠在向量化 token、向量存储和重建索引时间上大约多花 18%，50% 的重叠则大约多花 100%。

重叠在查询时也有成本。重叠 50% 时，为同一个问题检索到的两个相邻分块有一半文本是重复的。你要为这些重复的 token 付费，而且它们还会把其他相关段落挤出 top-k。

BroadNet 不提供 embedding 服务，所以这部分账单付给你的 embedding 服务商。可以用 [Embedding 成本计算器](https://broadrouter.com/tools/embedding-cost-calculator/)估算。

## 分块大小对大模型账单有什么影响？

每个问题都会发送 top-k 个分块加上提示词。假设每月 100,000 个问题，系统提示词加问题共 600 个 token，每次回答都是 300 个 token：

| 大小 × top-k | 每次查询的上下文 | 每次查询的输入 | 每月输入 |
| --- | --- | --- | --- |
| 200 × 10 | 2,000 | 2,600 | 2.6 亿 |
| 400 × 5 | 2,000 | 2,600 | 2.6 亿 |
| 512 × 5 | 2,560 | 3,160 | 3.16 亿 |
| 800 × 5 | 4,000 | 4,600 | 4.6 亿 |
| 1,024 × 5 | 5,120 | 5,720 | 5.72 亿 |
| 1,024 × 8 | 8,192 | 8,792 | 8.79 亿 |

每一行的输出都是每月 3,000 万 token，所以只有输入在变化。按每百万 token 的价格计算，每月输入成本就是最后一列的百万数乘以该价格。在每百万输入 token $0.10 的 [Gemma 4 VL 26B](https://broadrouter.com/zh/models/gemma-4-vl-26b/) 上，1,024 × 8 的设置每月输入成本为 879 × $0.10，而 400 × 5 为 260 × $0.10。前者是后者的 3.4 倍，而公开测试并没有显示这种设置的召回率更好。在 [Qwen3.8 27B](https://broadrouter.com/zh/models/qwen3.8-27b/)（输入 $0.175）或 [GLM 5.3](https://broadrouter.com/zh/models/glm-5.3/)（输入 $0.78）上，比例相同，总额更大。

有两个杠杆比模型价格的影响更大：

1.  \*\*增大分块时调低 k。\*\*200 × 10 和 400 × 5 发送的上下文相同。测试不同大小时，让每次查询的上下文大致保持不变，这样你比较的是检索质量，而不是上下文预算。
2.  \*\*缓存固定部分。\*\*把系统提示词放在最前面并保持逐字节不变，这样在有缓存价格的模型上，它就能按[缓存输入](https://broadrouter.com/zh/blog/cached-input-tokens-explained/)价格计费。检索到的分块每个问题都不同，很少能命中缓存。

上下文限制也要考虑。Gemma 4 VL 26B 每次请求接受 32,768 个 token，对上表任何一行都绰绰有余。如果你把 k × 大小推到几万 token，那你已经从 RAG 走向了[长上下文](https://broadrouter.com/zh/blog/long-context-vs-rag/)，那种比较有它自己的算法。[RAG 分块计算器](https://broadrouter.com/tools/rag-chunking-calculator/)可以按你自己的语料、分块大小、重叠和 top-k 套用这些公式。

## 怎么按 token 分块又不切断单词？

按 token 计数，但在结构处切分。LangChain 的 `RecursiveCharacterTextSplitter` 用它的 `length_function` 计算大小，默认是字符长度。这时 512 的“大小”就是 512 个字符，英文大约相当于 100 到 150 个 token，阿拉伯语又是另一个数字，见[阿拉伯语的每词 token 数](https://broadrouter.com/zh/blog/tokens-per-word-arabic-english/)。而 embedding 的限制和大模型账单都按 token 计。

下面这个分块函数把完整的段落装进 token 预算，并把末尾的段落作为重叠带到下一块。在段落边界处切分，可以避免把单词或多字节的阿拉伯语字符切断，而直接按 token 窗口切分就可能出现这种情况。

```python
import tiktoken

enc = tiktoken.get_encoding("o200k_base")    # an estimate: count with your embedder's tokenizer
count = lambda s: len(enc.encode(s))

def chunk(text, size=512, overlap=64):
    """Pack whole paragraphs up to `size` tokens; repeat trailing paragraphs up to `overlap` tokens."""
    chunks, cur, cur_len = [], [], 0
    for para in (p.strip() for p in text.split("\n\n")):
        if not para:
            continue
        n = count(para)
        if cur and cur_len + n > size:
            chunks.append("\n\n".join(cur))
            tail, t = [], 0
            for q in reversed(cur):                  # carry the end of this chunk forward
                if t + count(q) > overlap:
                    break
                tail.insert(0, q); t += count(q)
            cur, cur_len = tail, t
        cur.append(para); cur_len += n              # a paragraph over `size` stays whole
    if cur:
        chunks.append("\n\n".join(cur))
    return chunks

def plan(corpus_tokens, size, overlap, k, queries_per_month, prompt_tokens=600):
    index_tokens = corpus_tokens * size / (size - overlap)   # long-document limit
    per_query = k * size + prompt_tokens
    return {"chunks": round(index_tokens / size), "tokens_to_embed": round(index_tokens),
            "input_per_query": per_query, "input_per_month": per_query * queries_per_month}

print(plan(2_000_000, 512, 64, 5, 100_000))
# {'chunks': 4464, 'tokens_to_embed': 2285714, 'input_per_query': 3160, 'input_per_month': 316000000}
```

这里的重叠是“最多”：比重叠预算更长的段落不会被重复。单个超过 `size` 的段落会保持完整；如果你的文档有句子结构，先把这类段落按句子切开。在每个分块前加上文档标题和章节标题，这样检索到的分块依然能说明自己讲的是什么。这样每个分块会多几个 token，但往往比重叠更有用。

## 怎么为你的数据选定这些数字？

1.  \*\*建立评测集。\*\*50 到 200 个真实问题，每个问题配上能回答它的段落。评分方法见[大模型评测指南](https://broadrouter.com/zh/blog/evaluate-llm-before-switching/)。
2.  \*\*固定上下文预算。\*\*比较不同大小时，让 k × 大小保持在某个值附近，比如 2,000 个 token。
3.  \*\*试三种大小和两种重叠。\*\*例如 256、512 和 1,024 token，各自在 0 和 15% 重叠下测试。测量正确段落在 k 以内的召回率。
4.  \*\*试试按结构切分。\*\*如果你的文档有页码或编号章节，就拿按页或按章节的分块和各种 token 大小比一比。NVIDIA 发现按页分块最稳定。
5.  \*\*在召回率与最佳值相差一两个百分点以内的设置中，选最便宜的那个，\*\*然后用[月度成本估算方法](https://broadrouter.com/zh/blog/estimate-llm-api-cost-before-launch/)按你的查询量算出价格。

先在样本上完成这些，再对全部语料做向量化。以后再改分块方案，就意味着所有内容都要重新向量化。

## BroadNet Inference 适合什么场景

BroadNet Inference 负责 RAG 的回答环节，而不是检索。它不提供 embedding 或向量存储，所以请搭配你选择的 embedding 服务商和向量数据库。在回答环节，Gemma 4 VL 26B 是低成本选项，可以用 $5 的初始额度运行。Qwen3.8 27B（262,144 token 上下文）和 GLM 5.3（1,048,576）适合更大的 top-k 或长文档，需要先充值。提示词和检索到的段落在请求结束后不会被保留。如果你的语料足够小且稳定，放得进上下文窗口，那么[长上下文](https://broadrouter.com/zh/blog/long-context-vs-rag/)可能比分块更合适。

相关免费工具（英文）

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[免费工具（英文）](https://broadrouter.com/tools/)

## 本文涉及的术语

[Token（词元）](https://broadrouter.com/zh/glossary/token/)

token（词元）是大语言模型读写文本的基本单位：由模型的分词器切分出的一个词、词的一部分、一个标点或一段字节序列。大模型 API 按 token 计数、设定限制，通常也按 token 计费。

[嵌入向量（embeddings）](https://broadrouter.com/zh/glossary/embeddings/)

嵌入向量（embeddings）是模型为一段文本、一张图片或其他输入生成的浮点数列表（向量）。意思相近的输入会得到彼此接近的向量，因此可以用向量之间的距离来给搜索结果排序、对文档聚类或查找相关条目。

[文本分块（chunking）](https://broadrouter.com/zh/glossary/chunking/)

分块是检索流水线中把文档切成较小片段（称为块，chunk）的步骤，在嵌入和建索引之前进行。块大小决定每个片段容纳多少文本，块重叠则让相邻的块重复一部分文本，避免在边界处被切断的内容丢失。

[系统提示词（system prompt）](https://broadrouter.com/zh/glossary/system-prompt/)

系统提示词是应用在对话开始前发给语言模型的指令文本，通常是一条 system 或 developer 角色的消息。它设定模型的角色、规则、语气和输出格式，当用户消息与它冲突时，模型应当优先遵循它。

[工具调用（tool calling / function calling）](https://broadrouter.com/zh/glossary/tool-calling/)

工具调用（也叫函数调用，function calling）是大模型 API 的一项功能：模型返回一个结构化请求，要求执行开发者定义的某个函数，并附上 JSON 参数。应用执行该函数并把结果发回；模型自己从不执行代码。

[评测（eval，LLM evaluation）](https://broadrouter.com/zh/glossary/eval/)

评测（eval，evaluation 的简称）是对语言模型或提示词的可重复测试：一组固定的输入、对好输出的描述，以及给每个输出打分的评分器（代码、人工或另一个模型），以便比较不同版本。

[向量数据库（vector database）](https://broadrouter.com/zh/glossary/vector-database/)

向量数据库是存放嵌入向量的数据存储，通常连同原文和元数据一起保存，并回答最近邻查询：给定查询向量，返回与之最相似的已存向量，一般按余弦距离、欧氏距离或内积计算。

[上下文窗口（context window）](https://broadrouter.com/zh/glossary/context-window/)

上下文窗口是语言模型在单次请求中能处理的最大 token 数。它涵盖提示词、对话历史、工具定义、图片以及生成的输出（包括思考 token）。放不下的内容必须删减、摘要，或拆分到多个请求中。

## 常见问题

### RAG 的分块大小设多少合适？

从 256 到 512 token 左右开始测试。Chroma 的评测发现，200 到 400 token、无重叠的效果很好。NVIDIA 发现，256 到 512 token 适合事实型问题，而分析型问题用 1,024 token 或整页的分块效果更好。

### 分块重叠应该设多少？

比大多数默认值更少。NVIDIA 在一个数据集上试了 10%、15% 和 20%，发现 15% 最好。Chroma 发现无重叠的设置往往得分持平甚至更高。重叠每多一点，要向量化、存储和发送的 token 就多一点。

### 分块越大，成本越高吗？

在没有重叠的情况下，向量化的成本不会更高：语料的 token 数是一样的。但每次查询的成本更高，因为每个检索到的分块更长，top-k × 分块大小随之增长。增大分块时要调低 k。

### 分块大小是按 token 还是按字符计算的？

取决于切分器。LangChain 的 RecursiveCharacterTextSplitter 用它的 length\_function 计算，默认是字符长度。而 embedding 的限制和大模型的账单都按 token 计，所以要传入一个 token 计数函数。

### 改了分块大小，需要重新向量化吗？

需要。新的边界产生新的分块，每个分块都需要新的向量。重新向量化相当于把整个索引的成本再付一遍，所以要先在样本上定好分块方案，再对全部语料做向量化。

## 继续阅读

-   [长上下文还是 RAG：百万 token 什么时候能取代向量数据库](https://broadrouter.com/zh/blog/long-context-vs-rag/)
-   [阿拉伯语 RAG：真正有效的规范化、分块与检索](https://broadrouter.com/zh/blog/arabic-rag-search/)
-   [面向搜索和 RAG 的阿拉伯语文本规范化：该改什么，不该改什么](https://broadrouter.com/zh/blog/arabic-text-normalization-search/)
-   [上线新功能前，怎样估算大模型 API 费用](https://broadrouter.com/zh/blog/estimate-llm-api-cost-before-launch/)
-   [缓存输入 token 详解：如何降低大模型 API 账单](https://broadrouter.com/zh/blog/cached-input-tokens-explained/)
-   [BroadNet 的 GPU 硬件与推理部署方式（据 BroadNet 自述）](https://broadrouter.com/zh/blog/broadnet-gpu-fleet-and-serving/)
-   [缓存大模型 API 响应以降低成本：用 Python 实现精确匹配缓存](https://broadrouter.com/zh/blog/cache-llm-responses-cut-cost/)
-   [指南：用 OpenAI Python SDK 调用 BroadNet Inference](https://broadrouter.com/zh/guides/openai-python-sdk/)

用你的真实业务负载试一试。新账户可获得 US$5 初始额度，用于 Gemma和转写。DeepSeek、GLM和Qwen3.8 需要先充值。

[开始使用](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-rag-chunk-size-overlap&utm_content=page-cta) ·

**来源**

-   [Smith 与 Troynikov，Evaluating Chunking Strategies for Retrieval，Chroma 技术报告，2024 年 7 月（2026-11-15 查阅）](https://research.trychroma.com/evaluating-chunking)
-   [NVIDIA 技术博客，Finding the Best Chunking Strategy for Accurate AI Responses，2025 年 6 月（2026-11-15 查阅）](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [OpenAI 检索指南：默认 800 token 分块、400 token 重叠，以及 chunking\_strategy 的限制（2026-11-15 查阅）](https://developers.openai.com/api/docs/guides/retrieval)
-   [LangChain 文档 RecursiveCharacterTextSplitter：分块大小由 length\_function 计算，默认按字符（2026-11-15 查阅）](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [BroadNet Inference 价格与 API 参考：模型、上下文长度、缓存输入（2026-11-15 查阅）（英文）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=zh-blog-rag-chunk-size-overlap&utm_content=sources)
