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. Para documentos em árabe, leia também RAG em árabe e normalização de texto em árabe.
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.
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, 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 ($0.175 de entrada) ou no 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:
- 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.
- 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 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, e essa comparação tem as suas próprias contas. A calculadora de chunking para RAG 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. 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.
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?
- 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 cobre a pontuação.
- Fixe o orçamento de contexto. Mantenha k × tamanho perto de um valor, como 2.000 tokens, enquanto compara tamanhos.
- 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.
- 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.
- 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.
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 pode dispensar o chunking por completo.
