BroadRouter

RAG chunk size at overlap: epekto sa retrieval at gastos

Ng BroadNet Inference team · 7 minutong basa · Nailathala · Na-update

Magsimula sa chunk na mga 256 hanggang 512 token, 0 hanggang 15% overlap, at top-k na tine-tune sa sarili mong query. Pinapataas ng mas malaking chunk ang token ng bawat query sa LLM. Pinararami ng overlap ang token na ine-embed at iniimbak nang size ÷ (size − overlap), kaya dinodoble ng 50% overlap ang index. Sa mga published na test, madalas pareho o mas maganda ang recall ng maliit o walang-overlap na chunk.

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:

  1. 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.
  2. 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?

  1. Gumawa ng evaluation set. 50 hanggang 200 totoong tanong, bawat isa may passage na sumasagot dito. Tinatalakay ng gabay sa LLM evaluation ang scoring.
  2. I-fix ang budget ng context. Panatilihing malapit sa iisang value ang k × size, gaya ng 2,000 token, habang naghahambing ng mga size.
  3. 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.
  4. 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.
  5. 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.

Mga tanong

Ano ang magandang chunk size para sa RAG?

Magsimula sa mga 256 hanggang 512 token at mag-test. Sa evaluation ng Chroma, maganda ang performance ng 200 hanggang 400 token na walang overlap. Sa NVIDIA, bagay ang 256 hanggang 512 token sa mga factoid na tanong, habang mas maganda ang mga analytical na tanong sa 1,024-token o page-level na chunk.

Gaano kalaking chunk overlap ang dapat kong gamitin?

Mas kaunti kaysa sa karamihan ng default. Sa NVIDIA, 15% ang pinakamaganda sa 10%, 15% at 20% na sinubukan nila sa isang dataset. Sa Chroma, madalas na pareho o mas mataas ang score ng mga setting na walang overlap. Bawat punto ng overlap ay nagdadagdag ng token na ie-embed, iimbakin at ipapadala.

Mas mahal ba ang mas malaking chunk size?

Hindi sa pag-embed, kung walang overlap: pareho ang bilang ng token ng corpus. Mas mahal ito kada query, dahil mas mahaba ang bawat nire-retrieve na chunk, kaya lumalaki ang top-k × chunk size. Babaan ang k kapag tinaasan mo ang size.

Token ba o character ang sukat ng chunk size?

Depende sa splitter. Sinusukat ng RecursiveCharacterTextSplitter ng LangChain gamit ang length_function nito, na haba sa character bilang default. Nasa token ang mga limit ng embedding at ang bill ng LLM, kaya magpasa ng token counter.

Kailangan ko bang mag-re-embed kapag binago ko ang chunk size?

Oo. Bagong hangganan, bagong chunk, at kailangan ng bawat isa ng bagong vector. Muling binabayaran ang buong index kapag nag-re-embed, kaya ayusin muna ang chunking sa isang sample bago i-embed ang buong corpus.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity