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

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

Ingestão de documento real: PDF, tabela, digitalização e lixo de formatação

Por Medha

Cenário (sintético)

Um relatório financeiro trimestral, em PDF, tinha na página 4 uma tabela com o valor por filial em cada mês do trimestre:

Filial Jan Fev Mar
SP 118.200 122.300 128.400
RJ 91.100 94.300 97.200
MG 51.200 52.800 54.100

Depois de extraído pela pipeline de ingestão de um RAG, o conteúdo da tabela virou uma sequência de números sem linha, coluna nem cabeçalho, misturada ao texto corrido da página: "Filial SP 118200 122300 128400 Filial RJ 91100 94300 97200 Filial MG 51200 52800 54100". O modelo, ao ser perguntado "qual filial teve o maior valor em março", respondeu errado — sem a coluna "Mar" preservada, não havia como saber qual dos três números de cada filial correspondia a qual mês.

No mesmo lote de documentos havia contratos escaneados sem nenhuma camada de texto (fotografados e convertidos direto para PDF) e um manual interno com cabeçalho de página repetido ("Confidencial — Uso Interno — Página 3 de 42") que entrava em todo chunk, competindo por espaço com o conteúdo relevante — e cujo número de página muda a cada folha, o que faz uma checagem ingênua por texto idêntico não detectar a repetição.

Esses três problemas — tabela virando texto corrido, documento sem texto extraível e lixo de formatação repetido — são a primeira coisa a checar quando um erro de RAG parece, à primeira vista, erro do modelo.

Problema 1: o PDF não tem camada de texto (é uma imagem)

Nem todo PDF tem texto selecionável. Um documento escaneado é, para fins de extração, uma foto. Tentar extrair texto dele sem OCR devolve string vazia — e uma pipeline que trata string vazia como "documento sem conteúdo relevante" perde o documento inteiro silenciosamente.

O primeiro passo da ingestão é verificar, página por página — não o documento inteiro de uma vez — se o PDF tem texto nativo, porque um PDF nativo pode ter capa escaneada, folha de rosto quase em branco ou página solta sem texto misturadas com páginas de texto real. Decidir por documento inteiro (por exemplo, exigir que todas as páginas amostradas tenham texto) classificaria esse documento nativo como "sem texto" e mandaria tudo para OCR, degradando texto que já estava bom:

import pdfplumber

def paginas_sem_texto_nativo(pdf_path: str, min_chars_por_pagina: int = 20) -> list[int]:
    """Verifica cada página individualmente e devolve os números
    (1-based) das páginas sem camada de texto nativa suficiente — só
    essas páginas precisam ir para OCR, não o documento inteiro."""
    sem_texto: list[int] = []
    with pdfplumber.open(pdf_path) as pdf:
        for i, page in enumerate(pdf.pages, start=1):
            if len((page.extract_text() or "")) < min_chars_por_pagina:
                sem_texto.append(i)
    return sem_texto

Só as páginas listadas por paginas_sem_texto_nativo precisam passar por OCR (por exemplo, Tesseract via pytesseract) — as demais páginas do mesmo documento seguem direto para o resto da pipeline. O resultado do OCR deve carregar uma pontuação de confiança por página; página com confiança baixa não deveria ser indexada em silêncio, e sim sinalizada para revisão manual, porque texto de OCR ruim vira base para resposta errada com aparência de resposta correta.

Problema 2: tabela virando texto corrido

Extrator de texto simples lê a página da esquerda para a direita, de cima para baixo, sem noção de coluna. Uma tabela como a do cenário acima vira uma sequência linear de valores, e a relação entre "Filial SP", "Mar" e "128.400" se perde.

O erro mais comum ao corrigir isso é extrair a tabela com uma função separada (por exemplo extract_tables()) mas continuar extraindo o texto da página inteira com extract_text() — o que faz o conteúdo da tabela aparecer duas vezes: uma vez, estruturado, na tabela; outra vez, solto, dentro do texto corrido, competindo por espaço no mesmo chunk. A correção correta é localizar a área (bounding box) de cada tabela com find_tables() e recortar essa área do texto antes de extrair o restante, com outside_bbox() — assim o texto corrido e a tabela não aparecem duplicados no mesmo chunk (exemplo testado com pdfplumber 0.11.10):

import pdfplumber

def extract_text_and_tables(pdf_path: str) -> list[dict]:
    """Extrai texto e tabela por página, mantendo os dois sem
    sobreposição: find_tables() localiza a área de cada tabela e
    outside_bbox() recorta essa área antes de extrair o texto corrido,
    para o mesmo conteúdo não aparecer duas vezes (uma vez estruturado,
    outra vez solto no texto)."""
    paginas = []
    with pdfplumber.open(pdf_path) as pdf:
        for i, page in enumerate(pdf.pages):
            tabelas = page.find_tables()

            pagina_sem_tabela = page
            for tabela in tabelas:
                pagina_sem_tabela = pagina_sem_tabela.outside_bbox(tabela.bbox)
            texto = pagina_sem_tabela.extract_text() or ""

            tabelas_md = [_tabela_para_markdown(t.extract()) for t in tabelas]
            paginas.append({"pagina": i + 1, "texto": texto, "tabelas": tabelas_md})
    return paginas

def _tabela_para_markdown(tabela: list[list[str]]) -> str:
    linhas = ["| " + " | ".join(c or "" for c in linha) + " |" for linha in tabela]
    if len(linhas) > 1:
        separador = "| " + " | ".join(["---"] * len(tabela[0])) + " |"
        linhas.insert(1, separador)
    return "\n".join(linhas)

O chunk que contém a tabela deve guardar essa tabela como bloco Markdown, separado do parágrafo anterior ou seguinte, e o texto corrido da mesma página não deve repetir os valores que já estão na tabela. Com a coluna "Mar" preservada, a pergunta "qual filial teve o maior valor em março" volta a ser respondível: SP, com 128.400.

outside_bbox() só mantém objetos que caem inteiramente fora da área da tabela — texto corrido que apenas encosta na borda do bounding box é descartado em silêncio, e isso é perda de conteúdo, não um recorte limpo. Compare a contagem de caracteres do texto antes e depois do recorte nos seus próprios documentos, e teste o encadeamento de outside_bbox() sobre o resultado de outro outside_bbox() (quando a página tem mais de uma tabela) na versão de pdfplumber que você usa antes de levar isso para produção — esse comportamento de encadeamento não está documentado no README oficial da biblioteca.

Problema 3: cabeçalho e rodapé repetidos viram ruído em todo chunk

Cabeçalho de página, numeração e aviso de confidencialidade se repetem em toda página do documento — mas raramente de forma literalmente idêntica, porque o número da página muda a cada folha ("Página 3 de 42", "Página 4 de 42"). Uma checagem por igualdade de texto não detecta essa repetição, porque cada linha é, tecnicamente, diferente da anterior. Quando o texto é dividido em chunks, esse ruído ocupa espaço no contexto sem agregar informação — e em documentos longos pode se tornar uma fração relevante de cada chunk.

A correção tem duas partes. Primeiro, normalizar números antes de comparar (trocar sequência de dígitos por um marcador), para que "Página 3 de 42" e "Página 4 de 42" caiam na mesma chave. Segundo, remover só a primeira e a última linha da página quando elas baterem com essa chave repetida — nunca uma linha no meio do texto, mesmo que ela coincida por acaso com o padrão de ruído:

import re
from collections import Counter

def _normalizar(linha: str) -> str:
    """Troca sequências de dígitos por '#', para agrupar variações do
    mesmo cabeçalho/rodapé que só mudam o número da página."""
    return re.sub(r"\d+", "#", linha)

def remove_repeated_header_footer(paginas: list[dict], limiar: float = 0.6) -> list[dict]:
    """Remove ruído de topo/rodapé comparando linhas normalizadas
    (números viram '#'), mas só remove a primeira e/ou a última linha
    NÃO VAZIA de cada página — nunca uma linha no meio do texto. Usa a
    mesma lista de linhas não vazias tanto na detecção quanto na
    remoção: comparar contra a linha crua (sem filtrar branco) faria a
    chave cair numa string vazia sempre que a página começar ou
    terminar com linha em branco — saída comum de extract_text() — e o
    cabeçalho/rodapé nunca seria removido."""
    primeiras, ultimas = Counter(), Counter()
    for p in paginas:
        linhas = [l.strip() for l in p["texto"].splitlines() if l.strip()]
        if linhas:
            primeiras[_normalizar(linhas[0])] += 1
            ultimas[_normalizar(linhas[-1])] += 1

    total = len(paginas)
    ruido = {c for c, n in primeiras.items() if n / total >= limiar}
    ruido |= {c for c, n in ultimas.items() if n / total >= limiar}

    for p in paginas:
        linhas_originais = p["texto"].splitlines()
        indices_com_conteudo = [i for i, l in enumerate(linhas_originais) if l.strip()]
        if not indices_com_conteudo:
            continue
        primeiro_idx, ultimo_idx = indices_com_conteudo[0], indices_com_conteudo[-1]
        remover_primeiro = _normalizar(linhas_originais[primeiro_idx].strip()) in ruido
        remover_ultimo = (
            ultimo_idx != primeiro_idx
            and _normalizar(linhas_originais[ultimo_idx].strip()) in ruido
        )
        linhas = list(linhas_originais)
        if remover_ultimo:
            del linhas[ultimo_idx]
        if remover_primeiro:
            del linhas[primeiro_idx]
        p["texto"] = "\n".join(linhas)
    return paginas

Critério prático de aceite para a etapa de ingestão

Antes de considerar a ingestão pronta, a pipeline precisa responder sim para as quatro perguntas abaixo, para cada tipo de documento que existe na base real:

  1. O sistema detecta, página por página, se ela tem ou não camada de texto nativa, e roteia para OCR só as páginas que precisam — sem jogar o documento inteiro para OCR por causa de uma página atípica?
  2. Página de OCR com confiança baixa é sinalizada para revisão, em vez de indexada em silêncio?
  3. Tabela é extraída pela área (bounding box), com o texto corrido da mesma página excluindo essa área — sem o conteúdo da tabela aparecer duplicado entre texto e tabela?
  4. Cabeçalho, rodapé e numeração repetidos são detectados por comparação normalizada (números viram um marcador comum) e removidos só no topo e no rodapé da página — nunca no meio do texto?

Nenhuma dessas quatro coisas aparece em um teste com PDF nativo, bem formatado e sem tabela — o que reforça o critério da peça anterior desta série: teste contra amostra hostil, não contra a base bonita.

Próximo passo

A peça seguinte desta série trata do que acontece depois da ingestão: como a divisão do documento em chunks e a escolha de metadados decidem, sozinhas, boa parte da qualidade da resposta final.

Para aplicar estes quatro critérios (e os outros da série) no seu projeto, 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