Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Chunking: Dividir os Seus Documentos de Forma Inteligente

Aula 12 de 22 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Objetivos
  2. Por que dividir documentos?
  3. Estratégia 1: Chunking de tamanho fixo
  4. Estratégia 2: Chunking baseado em separadores
  5. Estratégia 3: Chunking por secções Markdown
  6. Estratégia 4: Chunking semântico
  7. Enriquecer chunks com contexto
  8. Que tamanho de chunk deve escolher?
  9. Pontos-chave

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)VantagensDesvantagens
100–200Muito preciso, boa granularidadePerde contexto
300–500Bom compromissoPadrão
500–1000Contexto ricoMenos preciso, caro
1000+Contexto máximoDilui 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