Pular para o conteúdo
Engenharia com agentes de IA: governança e custo em reais.

IA em produção · 16 de outubro de 2026

Chunking e metadados: como a divisão do documento decide a qualidade da resposta

Por Medha

Cenário (sintético)

Uma política interna de reembolso de viagem tinha a seguinte frase, em sequência, no mesmo parágrafo: "Despesas com hospedagem acima de R$ 400 por noite não são reembolsáveis, exceto quando pré-aprovadas pela liderança com 5 dias de antecedência." A pipeline de chunking cortava o texto a cada 500 caracteres, sem olhar para frase ou parágrafo. O corte caiu exatamente entre "não são reembolsáveis" e "exceto quando pré-aprovadas". O chunk indexado continha só a primeira parte.

Quando um funcionário perguntou ao assistente se podia reembolsar uma diária de R$ 550 pré-aprovada, a resposta foi "não, despesas acima de R$ 400 por noite não são reembolsáveis" — tecnicamente baseada no documento, mas incompleta, porque a exceção ficou em outro chunk que o sistema de recuperação nem chegou a buscar.

O modelo não inventou nada. Recebeu metade da regra e respondeu com metade da regra. O problema não é o modelo: é o corte.

Chunking ingênuo corta regra ao meio

Dividir o documento em blocos de tamanho fixo (por exemplo, 500 ou 1.000 caracteres) é a forma mais simples de fazer chunking, e a mais comum em implementação de primeira versão. É também a mais propensa a cortar uma condição da sua exceção, uma definição do seu exemplo, ou uma tabela do seu título.

Duas alternativas reduzem esse risco:

  1. Respeitar a estrutura do documento. Dividir primeiro por seção (cabeçalho Markdown, título de cláusula, número de artigo) e só depois, dentro de cada seção, aplicar um limite de tamanho. Isso evita que o corte automático caia no meio de uma frase que pertence, semanticamente, a uma única seção.
  2. Cortar por frase, com sobreposição. Em vez de contar caracteres cegamente, dividir por frase (usando pontuação como limite) e manter uma ou duas frases de sobreposição entre um chunk e o seguinte, para que uma condição e sua exceção, quando estão em frases adjacentes, tenham chance de aparecer juntas em pelo menos um chunk.
import re
from dataclasses import dataclass, field

@dataclass
class Chunk:
    texto: str
    metadados: dict = field(default_factory=dict)

def split_by_heading(texto: str) -> list[tuple[str, str]]:
    """Divide o texto por cabeçalho Markdown (#, ## ou ###), associando
    cada trecho ao título da seção — evita que o chunking por tamanho
    misture conteúdo de seções diferentes."""
    partes = re.split(r"(?m)^(#{1,3} .+)$", texto)
    secoes = []
    titulo_atual = "Introdução"
    for parte in partes:
        parte = parte.strip()
        if not parte:
            continue
        if re.match(r"^#{1,3} ", parte):
            titulo_atual = parte.lstrip("# ").strip()
        else:
            secoes.append((titulo_atual, parte))
    return secoes

def chunk_by_sentences(texto: str, max_chars: int = 800, overlap_sentences: int = 1) -> list[str]:
    """Divide o texto por frase, respeitando um limite de caracteres,
    com sobreposição de frases entre chunks consecutivos."""
    frases = re.split(r"(?<=[.!?])\s+", texto.strip())
    chunks, atual, tamanho = [], [], 0
    for frase in frases:
        if tamanho + len(frase) > max_chars and atual:
            chunks.append(" ".join(atual))
            atual = atual[-overlap_sentences:] if overlap_sentences else []
            tamanho = sum(len(f) for f in atual)
        atual.append(frase)
        tamanho += len(frase)
    if atual:
        chunks.append(" ".join(atual))
    return chunks

No cenário exato desta peça, o corte por frase resolve por completo: condição e exceção ("não são reembolsáveis" e "exceto quando pré-aprovadas...") estão na mesma frase, então dividir por frase — em vez de por um número fixo de caracteres — nunca as separaria em chunks diferentes. A ressalva fica para o caso mais comum, que essa peça não usa como exemplo: quando condição e exceção estão em frases ou parágrafos distintos, é a sobreposição entre chunks consecutivos que dá a chance de as duas coexistirem em pelo menos um chunk recuperável — sem garantir isso. Nenhuma técnica de chunking garante que toda regra fique inteira; o objetivo é reduzir a taxa de corte no lugar errado, não prometer corte perfeito.

Metadado não é acessório, é o que permite filtrar e citar

Chunk sem metadado é texto solto. Com metadado — documento de origem, seção, página, data e versão — o sistema ganha duas capacidades que a resposta de um RAG em produção precisa ter:

  • Filtrar pela versão vigente. Se existem três versões da política de reembolso na base, o sistema precisa saber buscar (ou pelo menos sinalizar) qual é a vigente, e não misturar regra antiga com regra nova na mesma resposta.
  • Citar a fonte de forma verificável. "Segundo a Política de Reembolso, versão de março de 2026, seção 4" é uma citação que o usuário pode conferir. Sem metadado, a citação vira "segundo o documento", que não ajuda ninguém a checar se a resposta está certa.
def build_chunks_with_metadata(secoes: list[tuple[str, str]], documento: str, versao: str) -> list[Chunk]:
    chunks = []
    for titulo, texto_secao in secoes:
        for trecho in chunk_by_sentences(texto_secao):
            chunks.append(Chunk(
                texto=trecho,
                metadados={"documento": documento, "secao": titulo, "versao": versao},
            ))
    return chunks

Critério prático de aceite para chunking e metadados

  1. O chunking respeita a estrutura do documento (seção, cláusula, artigo) antes de aplicar limite de tamanho?
  2. Existe sobreposição entre chunks consecutivos, para reduzir o corte de uma condição no meio?
  3. Todo chunk carrega metadado de origem (documento, seção/página, data, versão)?
  4. Quando existe mais de uma versão do mesmo documento na base, o sistema tem como filtrar ou sinalizar qual é a vigente?

Um teste rápido para validar isso na prática: pegue cinco regras do tipo "X, exceto quando Y" na sua base de documentos e verifique, chunk por chunk, se a condição e a exceção aparecem juntas em pelo menos um chunk recuperável. Se não aparecerem, o chunking está cortando regra ao meio — e nenhum ajuste de prompt resolve isso, porque o modelo nunca recebe a informação completa.

Próximo passo

A peça seguinte desta série entra na recuperação: como busca híbrida e reranking ajudam a trazer o chunk certo entre milhares — e como diferenciar um problema de recuperação de um problema do modelo.

Para aplicar este critério e os outros da série, fique de olho no Checklist de RAG em Produção, gratuito — ainda em preparação: deixe seu e-mail na lista de espera para recebê-lo assim que ele sair.

Checklist de RAG em Produção

Os critérios da série IA em produção reunidos num checklist para levar um RAG da prova de conceito à produção.

Só enviamos o material e avisos sobre ele. Privacidade