分块大小和重叠,是每条 RAG 流水线一开始就设定、之后却很少再回头看的两个数字。它们决定你要存多少个向量、要向量化多少 token、每个问题要发给大模型多少 token,以及能不能找到正确的段落。本文先介绍公开测试的发现,再一步步算清 token 账,让你在向量化之前就能看到每种设置的成本。
如果你还在考虑要不要用 RAG,先读长上下文还是 RAG。处理阿拉伯语文档的话,请把阿拉伯语 RAG 和阿拉伯语文本规范化与本文结合起来看。
分块大小和重叠会改变什么?
- 分块大小是你向量化和检索的每一块包含多少 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 成本计算器估算。
分块大小对大模型账单有什么影响?
每个问题都会发送 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 上,1,024 × 8 的设置每月输入成本为 879 × $0.10,而 400 × 5 为 260 × $0.10。前者是后者的 3.4 倍,而公开测试并没有显示这种设置的召回率更好。在 Qwen3.8 27B(输入 $0.175)或 GLM 5.3(输入 $0.78)上,比例相同,总额更大。
有两个杠杆比模型价格的影响更大:
- **增大分块时调低 k。**200 × 10 和 400 × 5 发送的上下文相同。测试不同大小时,让每次查询的上下文大致保持不变,这样你比较的是检索质量,而不是上下文预算。
- **缓存固定部分。**把系统提示词放在最前面并保持逐字节不变,这样在有缓存价格的模型上,它就能按缓存输入价格计费。检索到的分块每个问题都不同,很少能命中缓存。
上下文限制也要考虑。Gemma 4 VL 26B 每次请求接受 32,768 个 token,对上表任何一行都绰绰有余。如果你把 k × 大小推到几万 token,那你已经从 RAG 走向了长上下文,那种比较有它自己的算法。RAG 分块计算器可以按你自己的语料、分块大小、重叠和 top-k 套用这些公式。
怎么按 token 分块又不切断单词?
按 token 计数,但在结构处切分。LangChain 的 RecursiveCharacterTextSplitter 用它的 length_function 计算大小,默认是字符长度。这时 512 的“大小”就是 512 个字符,英文大约相当于 100 到 150 个 token,阿拉伯语又是另一个数字,见阿拉伯语的每词 token 数。而 embedding 的限制和大模型账单都按 token 计。
下面这个分块函数把完整的段落装进 token 预算,并把末尾的段落作为重叠带到下一块。在段落边界处切分,可以避免把单词或多字节的阿拉伯语字符切断,而直接按 token 窗口切分就可能出现这种情况。
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,但往往比重叠更有用。
怎么为你的数据选定这些数字?
- **建立评测集。**50 到 200 个真实问题,每个问题配上能回答它的段落。评分方法见大模型评测指南。
- **固定上下文预算。**比较不同大小时,让 k × 大小保持在某个值附近,比如 2,000 个 token。
- **试三种大小和两种重叠。**例如 256、512 和 1,024 token,各自在 0 和 15% 重叠下测试。测量正确段落在 k 以内的召回率。
- **试试按结构切分。**如果你的文档有页码或编号章节,就拿按页或按章节的分块和各种 token 大小比一比。NVIDIA 发现按页分块最稳定。
- **在召回率与最佳值相差一两个百分点以内的设置中,选最便宜的那个,**然后用月度成本估算方法按你的查询量算出价格。
先在样本上完成这些,再对全部语料做向量化。以后再改分块方案,就意味着所有内容都要重新向量化。
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 或长文档,需要先充值。提示词和检索到的段落在请求结束后不会被保留。如果你的语料足够小且稳定,放得进上下文窗口,那么长上下文可能比分块更合适。
