Ang chunk size at overlap ang dalawang numerong itinatakda nang maaga ng bawat RAG pipeline at bihirang balikan. Sila ang nagpapasya kung ilang vector ang iniimbak mo, ilang token ang ine-embed mo, ilang token ang ipinapadala ng bawat tanong sa LLM, at kung mahahanap pa ba ang tamang passage. Ipinapakita ng post na ito ang natuklasan ng mga published na test, saka kinukuwenta ang token math para makita mo ang gastos ng bawat setting bago ka mag-embed ng kahit ano.
Kung nagpapasya ka pa kung gagamit ng RAG, magsimula sa long context vs RAG. Para sa mga Arabic na dokumento, basahin ang Arabic RAG at Arabic text normalization kasabay ng post na ito.
Ano ang binabago ng chunk size at overlap?
- Ang chunk size ay kung ilang token ang nasa bawat pirasong ine-embed at nire-retrieve mo.
- Ang overlap ay kung ilang token ang pinaghahatian ng magkasunod na chunk, para buo ang pangungusap na naputol sa hangganan sa kahit isang chunk.
- Ang top-k ay kung ilang chunk ang nire-retrieve mo kada tanong.
Magkakasama, apat na bagay ang itinatakda nila:
| Dami | Formula (mahahabang dokumento) |
|---|---|
| Mga chunk na iniimbak | corpus token ÷ (size − overlap) |
| Token na ine-embed | corpus token × size ÷ (size − overlap) |
| Context kada query | top-k × size |
| Input sa LLM kada query | top-k × size + system prompt + tanong |
Isang beses binabayaran ang unang dalawa kada indexing run, at muli tuwing magre-re-chunk ka. Binabayaran ang huli sa bawat tanong, magpakailanman.
Ano ang sinasabi ng mga published na test tungkol sa chunk size?
Dalawang public na evaluation ang dapat mong malaman, dahil magkaibang bagay ang sinukat nila.
Ang Chroma (Smith at Troynikov, Hulyo 2024) ay sumukat ng retrieval sa antas ng token: gaano karami ng relevant na text ang na-retrieve (recall), at gaano karami ng na-retrieve ang relevant. Limang na-retrieve na chunk at ang text-embedding-3-large ng OpenAI ang ginamit nito. Mga piling row:
| Splitter | Size (token) | Overlap | Recall | 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% |
Sinusukat ng IoU (intersection over union) kung gaano karami ng na-retrieve na text ang relevant, kaya nagsisilbi rin itong sukat ng nasasayang na token. Tugma ang mga row na 800/400 sa default ng OpenAI para sa file search; kung token splitter ang ipagpapalagay, natuklasan ng Chroma na bahagyang mas mababa sa average ang recall ng setting na iyon at ito ang may pinakamababang score sa iba pang metric. Pareho o mas mataas ang recall ng mas maliliit na chunk na walang overlap at mas kaunting irrelevant na text ang dala nila.
Ang NVIDIA (Hunyo 2025) ay sumukat ng end-to-end na katumpakan ng sagot sa limang dataset, gamit ang token chunk na 128 hanggang 2,048 na may 15% overlap, kasama ang page-level at section-level na chunking. Ang page-level na chunking ang may pinakamataas na average na katumpakan (0.648) at pinakamababang variance. Nakadepende sa mga tanong ang pinakamagandang token size: pabor ang mga factoid na set sa 256 hanggang 512 token, ang mga analytical sa 1,024 token o buong page. Kadalasang mas mahina ang dalawang dulo, 128 at 2,048.
Iisang bagay ang pinagkakasunduan nila: walang unibersal na pinakamagandang size, at bihirang tamang default ang napakalalaking chunk na may mabigat na overlap.
Gaano pinalalaki ng overlap ang index?
Sumusulong ang bawat chunk nang size − overlap na token, kaya size ÷ (size − overlap) na kopya ng corpus ang laman ng index. Para sa corpus na 2,000,000 token na binubuo ng mga dokumentong tig-10,000 token:
| Size | Overlap | Mga chunk | Token na ine-embed | Paglaki |
|---|---|---|---|---|
| 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× |
Bahagyang mas kaunti ang paglaki ng maiikling dokumento, dahil kulang ang huling chunk ng bawat isa. Ibinibigay ng formula ang hangganan: mga 18% ang dagdag na gastos ng 15% overlap, at mga 100% ang sa 50%, sa embedding token, vector storage at oras ng muling pag-index.
May gastos din ang overlap sa oras ng query. Sa 50% overlap, inuulit ng dalawang magkatabing chunk na na-retrieve para sa iisang tanong ang kalahati ng text nila. Binabayaran mo ang mga dobleng token na iyon, at itinutulak nila palabas ng top-k ang ibang relevant na passage.
Hindi nagbebenta ng embeddings ang BroadNet, kaya sa embedding provider mo napupunta ang bahaging ito ng bill. Kuwentahin ito gamit ang embedding cost calculator.
Ano ang epekto ng chunk size sa bill ng LLM?
Nagpapadala ang bawat tanong ng top-k na chunk kasama ang prompt. Halimbawa, 100,000 tanong kada buwan, 600 token ng system prompt at tanong, at parehong 300-token na sagot sa bawat pagkakataon:
| Size × top-k | Context kada query | Input kada query | Input kada buwan |
|---|---|---|---|
| 200 × 10 | 2,000 | 2,600 | 260 milyon |
| 400 × 5 | 2,000 | 2,600 | 260 milyon |
| 512 × 5 | 2,560 | 3,160 | 316 milyon |
| 800 × 5 | 4,000 | 4,600 | 460 milyon |
| 1,024 × 5 | 5,120 | 5,720 | 572 milyon |
| 1,024 × 8 | 8,192 | 8,792 | 879 milyon |
30 milyong token kada buwan ang output sa bawat row, kaya input lang ang nagbabago. Sa presyong kada 1M token, ang buwanang gastos sa input ay ang milyon sa huling column na pinarami sa presyong iyon. Sa Gemma 4 VL 26B na $0.10 kada 1M input token, 879 × $0.10 kada buwan sa input ang gastos ng setup na 1,024 × 8, kumpara sa 260 × $0.10 para sa 400 × 5. Iyan ay 3.4 ulit na mas malaki, para sa setting na hindi ipinapakita ng mga published na test na mas maganda ang recall. Sa Qwen3.8 27B ($0.175 na input) o GLM 5.3 ($0.78 na input), pareho ang ratio at mas malaki ang kabuuan.
Dalawang lever ang mas nakakagalaw nito kaysa sa presyo ng model:
- Babaan ang k kapag tinaasan ang size. Parehong context ang ipinapadala ng 200 × 10 at 400 × 5. Panatilihing halos pareho ang context kada query habang nagte-test ng mga size, para kalidad ng retrieval ang inihahambing mo, hindi budget ng context.
- I-cache ang nakapirming bahagi. Ilagay muna ang system prompt at panatilihin itong byte-identical, para masingil ito sa cached input rate sa mga model na mayroon nito. Nagbabago kada tanong ang mga na-retrieve na chunk at bihirang ma-cache.
Mahalaga rin ang mga limit ng context. Tumatanggap ang Gemma 4 VL 26B ng 32,768 token kada request, higit sa sapat para sa anumang row sa itaas. Kapag itinulak mo ang k × size papuntang sampu-sampung libong token, lumipat ka na mula RAG papuntang long context, at may sariling math ang paghahambing na iyon. Pinapatakbo ng RAG chunking calculator ang mga formula na ito para sa sarili mong corpus, chunk size, overlap at top-k.
Paano mag-chunk ayon sa token nang hindi pinuputol ang mga salita?
Magbilang sa token, pero pumutol sa istruktura. Sinusukat ng RecursiveCharacterTextSplitter ng LangChain ang size gamit ang length_function nito, na haba sa character bilang default. Kung gayon, 512 character ang “size” na 512, mga 100 hanggang 150 token ng English, at ibang numero naman para sa Arabic; tingnan ang token kada salita sa Arabic. Nasa token ang mga limit ng embedding at ang bill ng LLM.
Pinupuno ng chunker na ito ng buong paragraph ang bawat chunk hanggang sa token budget at dinadala pasulong ang mga huling paragraph bilang overlap. Ang pagputol sa hangganan ng paragraph ay umiiwas sa paghahati ng mga salita o ng multi-byte na Arabic na character, na puwedeng mangyari sa raw na token window.
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}
“Hanggang” ang ibig sabihin ng overlap dito: hindi inuulit ang paragraph na mas mahaba kaysa sa overlap budget. Nananatiling buo ang iisang paragraph na mas mahaba kaysa sa size; hatiin muna ang mga ganitong paragraph ayon sa pangungusap kung mayroon ang mga dokumento mo. Lagyan ng prefix ang bawat chunk ng title ng dokumento at heading ng section nito, para sinasabi pa rin ng na-retrieve na chunk kung tungkol saan ito. Ilang token lang ang idinadagdag nito kada chunk at madalas mas nakakatulong pa kaysa sa overlap.
Paano pipiliin ang mga numero para sa data mo?
- Gumawa ng evaluation set. 50 hanggang 200 totoong tanong, bawat isa may passage na sumasagot dito. Tinatalakay ng gabay sa LLM evaluation ang scoring.
- I-fix ang budget ng context. Panatilihing malapit sa iisang value ang k × size, gaya ng 2,000 token, habang naghahambing ng mga size.
- Subukan ang tatlong size at dalawang overlap. Halimbawa, 256, 512 at 1,024 token, bawat isa sa 0 at 15% overlap. Sukatin ang recall ng tamang passage sa k.
- Subukan ang istruktura. Kung may mga page o may-numerong section ang mga dokumento mo, i-test ang page-level o section-level na chunk laban sa mga token size. Natuklasan ng NVIDIA na page-level ang pinaka-consistent.
- Piliin ang pinakamurang setting na nasa loob ng isa o dalawang punto ng pinakamagandang recall, saka kuwentahin ang presyo nito sa dami ng query mo gamit ang paraan ng pagkuwenta ng buwanang gastos.
Gawin ito sa isang sample bago i-embed ang buong corpus. Kapag binago ang chunking pagkatapos, kailangang i-re-embed ang lahat.
Saan bagay ang BroadNet Inference
Sine-serve ng BroadNet Inference ang hakbang ng pagsagot sa RAG, hindi ang retrieval. Hindi ito nagbebenta ng embeddings o vector storage, kaya ipares ito sa embeddings provider at vector database na pipiliin mo. Para sa sagot, ang Gemma 4 VL 26B ang murang opsiyon at gumagana ito sa $5 na panimulang credit. Bagay ang Qwen3.8 27B (262,144-token na context) at GLM 5.3 (1,048,576) sa mas malaking top-k o mahahabang dokumento, pagkatapos ng top-up. Hindi itinatago ang mga prompt at na-retrieve na passage pagkatapos ng request. Kung maliit at stable ang corpus mo para magkasya sa context window, puwedeng mas mainam ang long context kaysa sa chunking.
