---
title: "RAG chunk size at overlap: retrieval at gastos sa token"
description: "Paano binabago ng chunk size at overlap ang recall ng RAG, laki ng index, gastos sa embedding at token kada query sa LLM, gamit ang published na resulta at kuwenta."
url: https://broadrouter.com/fil/blog/rag-chunk-size-overlap/
lang: fil
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/rag-chunk-size-overlap/) (na-update noong 2026-11-16).

# RAG chunk size at overlap: epekto sa retrieval at gastos

Ng BroadNet Inference team · 7 minutong basa · Nailathala 2026-11-15 · Na-update 2026-11-16

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.

## Mga pangunahing punto

-   Ang input kada query ay halos top-k × chunk size + prompt. Kapag lumipat mula 5 × 400 papuntang 8 × 1,024 token, mga 3.4 ulit na input ang ipinapadala sa bawat query.
-   Pinalalaki ng overlap ang index nang size ÷ (size − overlap): hanggang mga 18% ang idinadagdag ng 15% overlap (17% sa mga 10,000-token na dokumentong sinukat dito), at dinodoble ito ng 50%.
-   Sa evaluation ng Chroma noong 2024, ang 200- hanggang 400-token na chunk na walang overlap ay pumantay o tumalo sa 800-token na chunk na may 400 overlap, na siyang default ng file search ng OpenAI.
-   Walang iisang pinakamagandang size sa mga test ng NVIDIA noong 2025: 256 hanggang 512 token ang pabor sa mga factoid na tanong, 1,024 token o isang page sa mga analytical.
-   Bilangin ang chunk size sa token ng embedding model mo. May mga splitter na character ang binibilang bilang default.

**Sa page na ito**

1.  Ano ang binabago ng chunk size at overlap?
2.  Ano ang sinasabi ng mga published na test tungkol sa chunk size?
3.  Gaano pinalalaki ng overlap ang index?
4.  Ano ang epekto ng chunk size sa bill ng LLM?
5.  Paano mag-chunk ayon sa token nang hindi pinuputol ang mga salita?
6.  Paano pipiliin ang mga numero para sa data mo?
7.  Saan bagay ang BroadNet Inference

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](https://broadrouter.com/fil/blog/long-context-vs-rag/). Para sa mga Arabic na dokumento, basahin ang [Arabic RAG](https://broadrouter.com/fil/blog/arabic-rag-search/) at [Arabic text normalization](https://broadrouter.com/fil/blog/arabic-text-normalization-search/) 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](https://broadrouter.com/tools/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](https://broadrouter.com/fil/models/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](https://broadrouter.com/fil/models/qwen3.8-27b/) ($0.175 na input) o [GLM 5.3](https://broadrouter.com/fil/models/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](https://broadrouter.com/fil/blog/cached-input-tokens-explained/) 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](https://broadrouter.com/fil/blog/long-context-vs-rag/), at may sariling math ang paghahambing na iyon. Pinapatakbo ng [RAG chunking calculator](https://broadrouter.com/tools/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](https://broadrouter.com/fil/blog/tokens-per-word-arabic-english/). 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.

```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}
```

“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](https://broadrouter.com/fil/blog/evaluate-llm-before-switching/) 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](https://broadrouter.com/fil/blog/estimate-llm-api-cost-before-launch/).

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](https://broadrouter.com/fil/blog/long-context-vs-rag/) kaysa sa chunking.

Mga libreng tool para rito (Ingles)

-   [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.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[Context window](https://broadrouter.com/fil/glossary/context-window/)

Ang context window ay ang pinakamaraming token na kayang hawakan ng isang language model sa iisang request. Sakop nito ang prompt, history ng usapan, tool definitions, mga larawan at ang nabuong output, kasama ang anumang reasoning tokens. Ang hindi kasya ay kailangang bawasan, ibuod o hatiin sa ilang request.

[Embeddings](https://broadrouter.com/fil/glossary/embeddings/)

Ang embeddings ay mga listahan ng floating-point na numero (vector) na binubuo ng isang model para kumatawan sa isang piraso ng text, larawan o ibang input. Magkakalapit ang vector ng mga input na magkatulad ang kahulugan, kaya magagamit ang layo ng mga vector para i-rank ang search results, i-cluster ang mga dokumento o hanapin ang magkakaugnay na item.

[Chunking (RAG)](https://broadrouter.com/fil/glossary/chunking/)

Ang chunking ay ang hakbang sa retrieval pipeline na naghahati sa mga dokumento sa mas maliliit na piraso, na tinatawag na chunks, bago i-embed at i-index ang mga ito. Itinatakda ng chunk size kung gaano karaming text ang laman ng bawat piraso, at inuulit ng chunk overlap ang ilang text sa magkatabing chunk para hindi mawala ang ideyang naputol.

[System prompt](https://broadrouter.com/fil/glossary/system-prompt/)

Ang system prompt ay ang instruction na ipinapadala ng isang application sa language model bago ang usapan, kadalasan bilang mensaheng may system o developer role. Itinatakda nito ang role, mga patakaran, tono at format ng output ng model, at dapat itong sundin ng model kahit salungat ang mensahe ng user.

[Tool calling (function calling)](https://broadrouter.com/fil/glossary/tool-calling/)

Ang tool calling, tinatawag ding function calling, ay feature ng LLM API kung saan nagbabalik ang model ng structured na request para magpatakbo ng function na tinukoy ng developer, kasama ang JSON arguments. Ang application ang nagpapatakbo ng function at nagpapadala pabalik ng resulta; hindi kailanman nagpapatakbo ng code ang model mismo.

[Arabic text normalization](https://broadrouter.com/fil/glossary/arabic-text-normalization/)

Ang Arabic text normalization ay ang hakbang na nagmamapa sa iisang anyo ng mga variant ng spelling ng parehong salita bago ang matching: pagtatanggal ng diacritics at tatweel, pag-iisa ng mga anyo ng alef, at kadalasang pagmapa ng ى sa ي at ة sa ه. Ginagamit ito sa search key at evaluation, hindi sa text na ipinapakita mo.

[Cached input token (cached input tokens)](https://broadrouter.com/fil/glossary/cached-input-tokens/)

Ang cached input token ay prompt token na kamakailan lang naproseso ng LLM provider at magagamit ulit mula sa cache sa halip na kuwentahin muli, kadalasang paulit-ulit na prefix gaya ng system prompt o dokumento. Mas mababa ang singil dito kaysa sa bagong input token.

## 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.

## Magbasa pa

-   [Long context vs RAG: kailan pinapalitan ng 1M token ang vector DB](https://broadrouter.com/fil/blog/long-context-vs-rag/)
-   [Arabic RAG: normalisation, chunking at retrieval na gumagana](https://broadrouter.com/fil/blog/arabic-rag-search/)
-   [Arabic text normalization para sa search at RAG: ano ang babaguhin](https://broadrouter.com/fil/blog/arabic-text-normalization-search/)
-   [Paano tantiyahin ang gastos sa LLM API bago mag-launch ng feature](https://broadrouter.com/fil/blog/estimate-llm-api-cost-before-launch/)
-   [Cached input token: paano nito binabawasan ang LLM API bill mo](https://broadrouter.com/fil/blog/cached-input-tokens-explained/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

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

**Mga source**

-   [Smith at Troynikov, Evaluating Chunking Strategies for Retrieval, technical report ng Chroma, Hulyo 2024 (sinuri noong 2026-11-15)](https://research.trychroma.com/evaluating-chunking)
-   [NVIDIA Technical Blog, Finding the Best Chunking Strategy for Accurate AI Responses, Hunyo 2025 (sinuri noong 2026-11-15)](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [Retrieval guide ng OpenAI: default na 800-token na chunk na may 400-token na overlap, mga limit sa chunking\_strategy (sinuri noong 2026-11-15)](https://developers.openai.com/api/docs/guides/retrieval)
-   [Docs ng LangChain, RecursiveCharacterTextSplitter: sinusukat ang chunk size gamit ang length\_function, character bilang default (sinuri noong 2026-11-15)](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [Pricing at API reference ng BroadNet Inference: mga model, haba ng context, cached input (sinuri noong 2026-11-15) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-rag-chunk-size-overlap&utm_content=sources)
