---
title: "Tamanho de chunk e overlap no RAG: recuperação e custo"
description: "Como tamanho de chunk e overlap mudam o recall do RAG, o tamanho do índice, o custo de embeddings e os tokens enviados ao LLM por consulta, com resultados e contas."
url: https://broadrouter.com/pt/blog/rag-chunk-size-overlap/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/rag-chunk-size-overlap/) (atualizado em 2026-11-16).

# Tamanho de chunk e overlap no RAG: efeito na recuperação e no custo

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em 2026-11-15 · Atualizado em 2026-11-16

Comece com chunks de cerca de 256 a 512 tokens, overlap de 0 a 15% e um top-k ajustado às suas consultas. Chunks maiores aumentam os tokens que cada consulta envia ao LLM. O overlap multiplica os tokens que você indexa e armazena por tamanho ÷ (tamanho − overlap), então 50% de overlap dobra o índice. Testes publicados mostraram que chunks pequenos ou sem overlap muitas vezes têm recall igual ou melhor.

## Pontos principais

-   A entrada por consulta é mais ou menos top-k × tamanho do chunk + prompt. Passar de 5 × 400 para 8 × 1.024 tokens envia cerca de 3,4 vezes mais entrada em toda consulta.
-   O overlap infla o índice em tamanho ÷ (tamanho − overlap): 15% de overlap acrescenta até cerca de 18% (17% nos documentos de 10.000 tokens medidos aqui), e 50% o dobra.
-   Na avaliação da Chroma de 2024, chunks de 200 a 400 tokens sem overlap empataram ou superaram chunks de 800 tokens com 400 de overlap, que é o padrão do file search da OpenAI.
-   Os testes da NVIDIA de 2025 não encontraram um tamanho ideal único: perguntas factuais favoreceram 256 a 512 tokens, e perguntas analíticas, 1.024 tokens ou uma página.
-   Meça o tamanho do chunk em tokens do seu modelo de embeddings. Alguns splitters contam caracteres por padrão.

**Nesta página**

1.  O que tamanho de chunk e overlap mudam?
2.  O que os testes publicados dizem sobre tamanho de chunk?
3.  Quanto o overlap infla o índice?
4.  O que o tamanho do chunk faz com a conta do LLM?
5.  Como fazer chunking por tokens sem cortar palavras?
6.  Como escolher os números para os seus dados?
7.  Onde a BroadNet Inference se encaixa

Tamanho de chunk e overlap são os dois números que todo pipeline de RAG define cedo e raramente revisita. Eles decidem quantos vetores você armazena, quantos tokens passam pelo modelo de embeddings, quantos tokens cada pergunta envia ao LLM e se o trecho certo vai ser encontrado. Este post mostra o que os testes publicados encontraram e depois faz as contas de tokens, para você ver o custo de cada configuração antes de gerar um único embedding.

Se você ainda está decidindo se vai usar RAG, comece por [contexto longo vs RAG](https://broadrouter.com/pt/blog/long-context-vs-rag/). Para documentos em árabe, leia também [RAG em árabe](https://broadrouter.com/pt/blog/arabic-rag-search/) e [normalização de texto em árabe](https://broadrouter.com/pt/blog/arabic-text-normalization-search/).

## O que tamanho de chunk e overlap mudam?

-   **Tamanho do chunk** é quantos tokens entram em cada pedaço que você indexa e recupera.
-   **Overlap** é quantos tokens chunks consecutivos compartilham, para que uma frase cortada em uma fronteira apareça inteira em pelo menos um chunk.
-   **Top-k** é quantos chunks você recupera por pergunta.

Juntos, eles definem quatro coisas:

| Grandeza | Fórmula (documentos longos) |
| --- | --- |
| Chunks armazenados | tokens do corpus ÷ (tamanho − overlap) |
| Tokens indexados | tokens do corpus × tamanho ÷ (tamanho − overlap) |
| Contexto por consulta | top-k × tamanho |
| Entrada do LLM por consulta | top-k × tamanho + prompt de sistema + pergunta |

As duas primeiras são pagas uma vez por indexação, e de novo toda vez que você refaz o chunking. A última é paga em toda pergunta, para sempre.

## O que os testes publicados dizem sobre tamanho de chunk?

Vale conhecer duas avaliações públicas, porque elas mediram coisas diferentes.

**Chroma (Smith e Troynikov, julho de 2024)** mediu a recuperação no nível de tokens: quanto do texto relevante foi recuperado (recall) e quanto do que foi recuperado era relevante. Usou cinco chunks recuperados e o text-embedding-3-large da OpenAI. Algumas linhas:

| Splitter | Tamanho (tokens) | 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% |

O IoU (intersection over union) mede quanto do texto recuperado era relevante, então também serve como medida de tokens desperdiçados. As linhas 800/400 correspondem ao padrão da OpenAI para file search; supondo um splitter por tokens, a Chroma viu que essa configuração dava recall um pouco abaixo da média e as piores pontuações nas outras métricas. Chunks menores sem overlap recuperaram o mesmo ou mais e carregaram muito menos texto irrelevante.

**NVIDIA (junho de 2025)** mediu a precisão das respostas de ponta a ponta em cinco conjuntos de dados, com chunks de 128 a 2.048 tokens e 15% de overlap, além de chunking por página e por seção. O chunking por página teve a maior precisão média (0,648) e a menor variância. O melhor tamanho em tokens dependeu das perguntas: conjuntos factuais favoreceram 256 a 512 tokens, e os analíticos, 1.024 tokens ou páginas inteiras. Os dois extremos, 128 e 2.048, geralmente foram piores.

As duas concordam em um ponto: **não existe um tamanho ideal universal**, e chunks muito grandes com muito overlap raramente são o padrão certo.

## Quanto o overlap infla o índice?

Cada chunk avança tamanho − overlap tokens, então o índice guarda tamanho ÷ (tamanho − overlap) cópias do corpus. Para um corpus de 2.000.000 de tokens formado por documentos de 10.000 tokens:

| Tamanho | Overlap | Chunks | Tokens indexados | Aumento |
| --- | --- | --- | --- | --- |
| 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× |

Documentos curtos inflam um pouco menos, porque o último chunk de cada um é parcial. A fórmula dá o limite: 15% de overlap custa cerca de 18% a mais, e 50% custa cerca de 100% a mais, em tokens de embeddings, armazenamento de vetores e tempo de reindexação.

O overlap também custa na hora da consulta. Com 50% de overlap, dois chunks vizinhos recuperados para a mesma pergunta repetem metade do texto. Você paga por esses tokens duplicados, e eles empurram outros trechos relevantes para fora do top-k.

A BroadNet não vende embeddings, então essa parte da conta vai para o seu provedor de embeddings. Calcule-a com a [calculadora de custo de embeddings](https://broadrouter.com/tools/embedding-cost-calculator/).

## O que o tamanho do chunk faz com a conta do LLM?

Toda pergunta envia top-k chunks mais o prompt. Considere 100.000 perguntas por mês, 600 tokens de prompt de sistema e pergunta, e a mesma resposta de 300 tokens em cada uma:

| Tamanho × top-k | Contexto por consulta | Entrada por consulta | Entrada por mês |
| --- | --- | --- | --- |
| 200 × 10 | 2.000 | 2.600 | 260 milhões |
| 400 × 5 | 2.000 | 2.600 | 260 milhões |
| 512 × 5 | 2.560 | 3.160 | 316 milhões |
| 800 × 5 | 4.000 | 4.600 | 460 milhões |
| 1.024 × 5 | 5.120 | 5.720 | 572 milhões |
| 1.024 × 8 | 8.192 | 8.792 | 879 milhões |

A saída é de 30 milhões de tokens por mês em todas as linhas, então só a entrada muda. Com um preço por 1M de tokens, o custo mensal de entrada é o número de milhões da última coluna vezes esse preço. No [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/), a $0.10 por 1M de tokens de entrada, a configuração 1.024 × 8 custa 879 × $0.10 por mês em entrada, contra 260 × $0.10 para 400 × 5. São 3,4 vezes mais, por uma configuração que os testes publicados não mostram recuperando melhor. No [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) ($0.175 de entrada) ou no [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) ($0.78 de entrada), a proporção é a mesma e os totais são maiores.

Duas alavancas pesam mais do que o preço do modelo:

1.  **Reduza o k quando aumentar o tamanho.** 200 × 10 e 400 × 5 enviam o mesmo contexto. Mantenha o contexto por consulta mais ou menos fixo enquanto testa tamanhos, para comparar a qualidade da recuperação, não o orçamento de contexto.
2.  **Coloque a parte fixa em cache.** Ponha o prompt de sistema primeiro e mantenha-o idêntico byte a byte, para que possa ser cobrado pela tarifa de [entrada em cache](https://broadrouter.com/pt/blog/cached-input-tokens-explained/) nos modelos que têm uma. Os chunks recuperados mudam a cada pergunta e raramente entram no cache.

Limites de contexto também importam. O Gemma 4 VL 26B aceita 32.768 tokens por requisição, mais que suficiente para qualquer linha acima. Se você empurrar k × tamanho para dezenas de milhares de tokens, saiu do RAG em direção ao [contexto longo](https://broadrouter.com/pt/blog/long-context-vs-rag/), e essa comparação tem as suas próprias contas. A [calculadora de chunking para RAG](https://broadrouter.com/tools/rag-chunking-calculator/) aplica essas fórmulas ao seu corpus, tamanho de chunk, overlap e top-k.

## Como fazer chunking por tokens sem cortar palavras?

Conte em tokens, mas corte na estrutura. O `RecursiveCharacterTextSplitter` do LangChain mede o tamanho com a sua `length_function`, que por padrão é o tamanho em caracteres. Um “tamanho” de 512 vira então 512 caracteres, uns 100 a 150 tokens de inglês, e outro número ainda para árabe; veja [tokens por palavra em árabe](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/). Limites de embeddings e contas de LLM são em tokens.

Este chunker junta parágrafos inteiros até um orçamento de tokens e leva os parágrafos finais adiante como overlap. Cortar nas fronteiras dos parágrafos evita partir palavras ou caracteres árabes multibyte, o que janelas de tokens brutas podem fazer.

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

Aqui o overlap é “até”: um parágrafo maior que o orçamento de overlap não é repetido. Um parágrafo sozinho maior que `size` fica inteiro; se os seus documentos têm parágrafos assim, divida-os antes por frases. Coloque antes de cada chunk o título do documento e o título da seção, para que um chunk recuperado ainda diga do que trata. Isso acrescenta poucos tokens por chunk e muitas vezes ajuda mais que o overlap.

## Como escolher os números para os seus dados?

1.  **Monte um conjunto de avaliação.** De 50 a 200 perguntas reais, cada uma com o trecho que a responde. O [guia de avaliação de LLMs](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/) cobre a pontuação.
2.  **Fixe o orçamento de contexto.** Mantenha k × tamanho perto de um valor, como 2.000 tokens, enquanto compara tamanhos.
3.  **Teste três tamanhos e dois overlaps.** Por exemplo 256, 512 e 1.024 tokens, cada um com 0 e 15% de overlap. Meça o recall do trecho certo em k.
4.  **Teste a estrutura.** Se os seus documentos têm páginas ou seções numeradas, compare chunks por página ou por seção com os tamanhos em tokens. A NVIDIA viu que o chunking por página foi o mais consistente.
5.  **Escolha a configuração mais barata a um ou dois pontos do melhor recall,** depois calcule o custo para o seu volume de consultas com o [método de custo mensal](https://broadrouter.com/pt/blog/estimate-llm-api-cost-before-launch/).

Faça isso em uma amostra antes de indexar o corpus completo. Mudar o chunking depois significa refazer todos os embeddings.

## Onde a BroadNet Inference se encaixa

A BroadNet Inference atende a etapa de resposta do RAG, não a recuperação. Ela não vende embeddings nem armazenamento de vetores, então combine-a com um provedor de embeddings e um banco de dados vetorial de sua escolha. Para a resposta, o Gemma 4 VL 26B é a opção de baixo custo e roda com o crédito inicial de $5. O Qwen3.8 27B (contexto de 262.144 tokens) e o GLM 5.3 (1.048.576) servem para top-k maiores ou documentos longos, depois de uma recarga. Prompts e trechos recuperados não são retidos depois da requisição. Se o seu corpus é pequeno e estável o bastante para caber na janela de contexto, o [contexto longo](https://broadrouter.com/pt/blog/long-context-vs-rag/) pode dispensar o chunking por completo.

Ferramentas gratuitas sobre o tema (em inglês)

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

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

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

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

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

Embeddings são listas de números de ponto flutuante (vetores) que um modelo produz para representar um texto, uma imagem ou outra entrada. Entradas com significado parecido recebem vetores próximos, então a distância entre vetores serve para ordenar resultados de busca, agrupar documentos ou encontrar itens relacionados.

[Prompt de sistema (system prompt)](https://broadrouter.com/pt/glossary/system-prompt/)

O system prompt, ou prompt de sistema, é o texto de instruções que uma aplicação envia a um modelo de linguagem antes da conversa, em geral como mensagem com o papel system ou developer. Ele define o papel, as regras, o tom e o formato de saída do modelo, que deve segui-lo mesmo quando mensagens do usuário o contradizem.

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

Chunking é a etapa de um pipeline de recuperação que divide os documentos em pedaços menores, chamados chunks, antes de gerar embeddings e indexá-los. O chunk size define quanto texto cada pedaço tem, e o chunk overlap repete parte do texto entre chunks vizinhos para que ideias cortadas numa fronteira não se percam.

[Eval (avaliação de LLM)](https://broadrouter.com/pt/glossary/eval/)

Uma eval (abreviação de evaluation, avaliação) é um teste repetível de um modelo de linguagem ou de um prompt: um conjunto fixo de entradas, uma descrição de como é uma boa saída e um avaliador (código, uma pessoa ou outro modelo) que pontua cada saída, para que versões possam ser comparadas.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Crédito pré-pago (prepaid credit)](https://broadrouter.com/pt/glossary/prepaid-credit/)

Crédito pré-pago é dinheiro adicionado a uma conta de API antes do uso. Cada requisição desconta o próprio custo do saldo e, quando o saldo acaba, as requisições cobradas por uso param até você fazer uma recarga. Ele limita o gasto ao que você já pagou.

[Janela de contexto (context window)](https://broadrouter.com/pt/glossary/context-window/)

A janela de contexto é o número máximo de tokens com que um modelo de linguagem consegue trabalhar em uma única requisição. Ela abrange o prompt, o histórico da conversa, as definições de ferramentas, as imagens e a saída gerada, incluindo os tokens de raciocínio. O que não couber precisa ser cortado, resumido ou dividido em várias requisições.

## Perguntas frequentes

### Qual é um bom tamanho de chunk para RAG?

Comece em torno de 256 a 512 tokens e teste. A avaliação da Chroma encontrou bom desempenho com 200 a 400 tokens sem overlap. A NVIDIA viu que 256 a 512 tokens serviam bem para perguntas factuais, enquanto perguntas analíticas foram melhor com chunks de 1.024 tokens ou por página.

### Quanto overlap entre chunks devo usar?

Menos que a maioria dos padrões. A NVIDIA achou 15% o melhor entre 10%, 15% e 20% testados em um conjunto de dados. A Chroma viu que configurações sem overlap muitas vezes pontuavam igual ou melhor. Cada ponto de overlap acrescenta tokens para indexar, armazenar e enviar.

### Um chunk maior custa mais?

Para gerar embeddings, não, sem overlap: o corpus tem o mesmo número de tokens. Custa mais por consulta, porque cada chunk recuperado é mais longo, então top-k × tamanho do chunk cresce. Reduza o k quando aumentar o tamanho.

### O tamanho do chunk é medido em tokens ou em caracteres?

Depende do splitter. O RecursiveCharacterTextSplitter do LangChain mede com a sua length\_function, que por padrão é o tamanho em caracteres. Limites de embeddings e contas de LLM são em tokens, então passe um contador de tokens.

### Preciso gerar os embeddings de novo quando mudo o tamanho do chunk?

Sim. Novas fronteiras geram novos chunks, e cada um precisa de um novo vetor. Refazer os embeddings custa o índice inteiro de novo, então defina o chunking em uma amostra antes de indexar o corpus completo.

## Continue lendo

-   [Contexto longo vs RAG: quando 1M de tokens substitui um banco vetorial](https://broadrouter.com/pt/blog/long-context-vs-rag/)
-   [RAG em árabe: normalização, chunking e retrieval que funcionam](https://broadrouter.com/pt/blog/arabic-rag-search/)
-   [Normalizar texto em árabe para busca e RAG: o que mudar e o que não](https://broadrouter.com/pt/blog/arabic-text-normalization-search/)
-   [Como estimar o custo de API de LLM antes de lançar uma funcionalidade](https://broadrouter.com/pt/blog/estimate-llm-api-cost-before-launch/)
-   [Tokens de entrada em cache: como reduzir a conta de API de LLM](https://broadrouter.com/pt/blog/cached-input-tokens-explained/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

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

**Fontes**

-   [Smith e Troynikov, Evaluating Chunking Strategies for Retrieval, relatório técnico da Chroma, julho de 2024 (verificado em 2026-11-15)](https://research.trychroma.com/evaluating-chunking)
-   [NVIDIA Technical Blog, Finding the Best Chunking Strategy for Accurate AI Responses, junho de 2025 (verificado em 2026-11-15)](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [Guia de retrieval da OpenAI: chunks padrão de 800 tokens com overlap de 400, limites de chunking\_strategy (verificado em 2026-11-15)](https://developers.openai.com/api/docs/guides/retrieval)
-   [Documentação do LangChain, RecursiveCharacterTextSplitter: tamanho do chunk medido pela length\_function, em caracteres por padrão (verificado em 2026-11-15)](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [Preços e referência da API da BroadNet Inference: modelos, tamanhos de contexto, entrada em cache (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-rag-chunk-size-overlap&utm_content=sources)
