Chunking: Dividir os Seus Documentos de Forma Inteligente
Nesta página
Objetivos
- Compreender por que o chunking é crítico para a qualidade do RAG
- Dominar diferentes estratégias de divisão
- Escolher o tamanho de chunk e a sobreposição adequados
Por que dividir documentos?
Os modelos de embedding têm um limite de tokens: 8.191 para a OpenAI. Este limite é a primeira razão para dividir documentos, mas não é a mais importante. Mesmo um documento muito abaixo desse teto produz resultados fracos quando codificado como um único bloco, porque o vetor resultante faz a média de todo o conteúdo e perde detalhes. Considere um manual de RH de 40 páginas que abrange políticas de férias, trabalho remoto, relatórios de despesas e seguro de saúde: o seu único embedding não se assemelha verdadeiramente a nenhum destes quatro tópicos, e uma pesquisa por “quantos dias de férias” irá classificá-lo abaixo de um documento muito mais curto, mas muito mais direcionado.
O chunking resolve este problema ao dividir o documento em peças coerentes, cada uma capturando uma ideia ou parágrafo específico. Este é o passo onde um pipeline RAG ganha ou perde mais qualidade — mesmo antes de escolher um modelo de embedding.
Estratégia 1: Chunking de tamanho fixo
O método mais simples conta palavras e corta em intervalos regulares. Ignora completamente a estrutura do texto, tornando-o brutal, mas requer apenas três linhas de código e serve como uma linha de base essencial: qualquer estratégia mais sofisticada deve provar que tem um desempenho melhor do que esta.
def chunker_fixed_size(
text: str,
size: int = 500,
overlap: int = 100
) -> list[str]:
"""Splits text into fixed-size chunks with overlap."""
words = text.split()
chunks = []
for i in range(0, len(words), size - overlap):
chunk = " ".join(words[i:i + size])
if chunk.strip():
chunks.append(chunk)
return chunks
long_text = "A very long document... " * 500
chunks = chunker_fixed_size(long_text, size=300, overlap=50)
print(f"{len(chunks)} chunks generated")
O parâmetro overlap merece atenção. Sem sobreposição, um corte acabará por cair no meio de uma explicação: a frase “o período de aviso prévio é de três meses” fica num chunk, e “exceto durante o período experimental” no seguinte. Nenhum dos dois responde corretamente à pergunta, e o segundo é até enganador. Ao sobrepor os chunks em 10–20% do seu tamanho, garante que cada ideia existe intacta pelo menos uma vez em algum lugar do índice. Este é um bom ponto de partida; ajuste-o posteriormente com base na densidade do seu documento.
Estratégia 2: Chunking baseado em separadores
Em vez de cortar palavra por palavra, pode respeitar os limites naturais do texto. A ideia é tentar primeiro o separador mais forte — a quebra de linha dupla que separa dois parágrafos — e depois descer para separadores progressivamente mais fracos, desde que a peça resultante exceda o tamanho máximo. Um artigo de blogue será assim dividido parágrafo por parágrafo, e apenas um parágrafo monstruoso será fragmentado por frases.
import re
def chunker_separators(
text: str,
separators: list[str] = ["\n\n", "\n", ". ", " "],
max_size: int = 1000
) -> list[str]:
"""Splits text while respecting natural separators."""
chunks = []
current_chunk = ""
# Split by the strongest separator first
segments = [text]
for sep in separators:
new_segments = []
for segment in segments:
parts = segment.split(sep)
for part in parts:
if len(part.split()) > max_size:
new_segments.append(part)
else:
if (current_chunk and
len((current_chunk + sep + part).split()) > max_size):
chunks.append(current_chunk.strip())
current_chunk = part
else:
current_chunk = (
current_chunk + sep + part
if current_chunk else part
)
segments = new_segments
if current_chunk.strip():
chunks.append(current_chunk.strip())
return chunks
Estratégia 3: Chunking por secções Markdown
Quando o seu corpus consiste em documentação estruturada, os cabeçalhos já fazem o trabalho por si: o autor já delimitou as unidades de significado. Dividir nos níveis de cabeçalho # e ## produz chunks que correspondem exatamente às secções, e a função abaixo mantém o cabeçalho junto ao texto, o que utilizaremos imediatamente a seguir para enriquecimento.
def chunker_markdown(text: str, max_level: int = 2) -> list[dict]:
"""Splits a Markdown document by sections."""
chunks = []
current_section = {"title": "", "content": "", "level": 0}
for line in text.split("\n"):
# Detect headings
match = re.match(r"^(#{1,6})\s+(.+)$", line)
if match:
level = len(match.group(1))
title = match.group(2)
if level <= max_level and current_section["content"].strip():
chunks.append({
"title": current_section["title"],
"text": current_section["content"].strip(),
"level": current_section["level"]
})
if level <= max_level:
current_section = {
"title": title,
"content": "",
"level": level
}
else:
current_section["content"] += line + "\n"
else:
current_section["content"] += line + "\n"
if current_section["content"].strip():
chunks.append({
"title": current_section["title"],
"text": current_section["content"].strip(),
"level": current_section["level"]
})
return chunks
Estratégia 4: Chunking semântico
Para texto sem estrutura explícita — um resumo de reunião, uma transcrição de chamada — nem o tamanho nem os separadores sabem onde o tópico muda. Os embeddings sabem. Codifica cada frase, compara cada frase com a anterior e corta onde a similaridade colapsa: é exatamente aí que o orador mudou do orçamento para o recrutamento. Note que o text-embedding-3-small é suficiente aqui, já que não procura precisão absoluta, mas sim uma rutura relativa.
from openai import OpenAI
import numpy as np
client = OpenAI()
def chunker_semantic(
text: str,
similarity_threshold: float = 0.75,
min_sentence_length: int = 20
) -> list[str]:
"""Groups sentences by semantic similarity."""
# Split into sentences
sentences = re.split(r"(?<=[.!?])\s+", text)
sentences = [s for s in sentences if len(s) > min_sentence_length]
if len(sentences) <= 1:
return [text]
# Embeddings for each sentence
resp = client.embeddings.create(
input=sentences,
model="text-embedding-3-small" # small is sufficient here
)
embs = np.array([d.embedding for d in sorted(resp.data, key=lambda x: x.index)])
# Find break points
chunks = []
chunk_sentences = [sentences[0]]
for i in range(1, len(sentences)):
sim = float(np.dot(embs[i], embs[i - 1]))
if sim < similarity_threshold:
# Semantic break detected
chunks.append(" ".join(chunk_sentences))
chunk_sentences = [sentences[i]]
else:
chunk_sentences.append(sentences[i])
if chunk_sentences:
chunks.append(" ".join(chunk_sentences))
return chunks
Enriquecer chunks com contexto
Um chunk isolado perde frequentemente a informação que o tornava interpretável. “A duração é de três anos” não significa nada se o leitor — ou o modelo de embedding — não souber que provém do capítulo da garantia do fabricante. Prefixar cada chunk com o título do documento e o título da secção restaura este contexto diretamente no próprio vetor, e uma pesquisa por “duração da garantia” encontrará então a passagem.
def enrich_chunk(chunk: str, doc_title: str, section: str = "") -> str:
"""Adds context to the chunk for better embedding."""
prefix = f"Document: {doc_title}"
if section:
prefix += f" | Section: {section}"
return f"{prefix}\n\n{chunk}"
Que tamanho de chunk deve escolher?
A escolha envolve um compromisso entre precisão e contexto: um chunk curto visa com precisão, mas fica amputado, enquanto um chunk longo compreende tudo, mas dilui o sinal.
| Tamanho (tokens) | Vantagens | Desvantagens |
|---|---|---|
| 100–200 | Muito preciso, boa granularidade | Perde contexto |
| 300–500 | Bom compromisso | Padrão |
| 500–1000 | Contexto rico | Menos preciso, caro |
| 1000+ | Contexto máximo | Dilui a informação |
Não existe um valor universal: o tamanho ideal depende dos seus documentos e consultas. O único método fiável é indexar o mesmo corpus com dois ou três tamanhos e depois medir utilizando as métricas da lição 10 num conjunto de perguntas reais. Uma base de conhecimento de suporte feita de respostas curtas tolera 200 tokens; um corpus jurídico exigirá 800.
Pontos-chave
- O chunking é o passo mais impactante no pipeline RAG
- Utilize tamanho fixo como linha de base, separadores para respeitar a estrutura
- O chunking semântico deteta automaticamente mudanças de tópico
- A sobreposição e o enriquecimento contextual melhoram a qualidade
- Teste diferentes tamanhos e meça com métricas de pesquisa