Como automatizar a extração de dados de PDF usando modelos de IA locais sem uma API na nuvem

O fluxo de trabalho mais confiável para extração local de PDF geralmente é um pipeline, não um único prompt de IA: primeiro recupere texto e layout confiáveis do PDF, depois peça a um modelo local para mapear esse conteúdo em um esquema estrito e, finalmente, valide os campos antes de salvá-los. Enviar cada página do PDF diretamente para um modelo de visão pode funcionar, mas muitas vezes é mais lento, mais intensivo em hardware e mais difícil de auditar do que usar texto nativo do PDF ou OCR quando esses são suficientes.

Essa distinção é importante se o seu objetivo é “sem API na nuvem”. Você ainda pode usar uma API local na sua própria máquina—por exemplo, o endpoint HTTP do Ollama em localhost—sem enviar o conteúdo dos documentos para um serviço hospedado. O Ollama afirma que prompts e respostas não são enviados de volta ao Ollama quando os modelos são executados localmente, e fornece um modo somente local que desativa recursos na nuvem. O Docling também mantém serviços remotos desativados por padrão, embora os arquivos de modelo ainda possam precisar ser baixados durante a configuração, a menos que você os pré-baixe para uso offline.

A pilha certa depende do PDF. Faturas digitais nativas com texto selecionável exigem uma abordagem diferente de recibos digitalizados, tabelas financeiras complicadas ou formulários com muitas imagens. Este guia compara essas opções e fornece um padrão de automação em quatro etapas que você pode adaptar para faturas, contratos, ordens de compra, formulários de inscrição, relatórios e outros documentos recorrentes.

Recomendação rápida: escolha o pipeline pelo tipo de documento

Não há um vencedor universal. Se seus documentos são previsíveis e contêm texto incorporado, um parser mais um pequeno modelo de linguagem local pode superar um fluxo de trabalho de visão muito maior em custo, velocidade e reprodutibilidade. Se a posição do texto faz parte do significado—por exemplo, uma tabela com células mescladas ou um formulário onde rótulos e valores são espacialmente pareados—o processamento consciente do layout se torna mais valioso.

Etapa 1: Classifique o PDF antes de escolher OCR ou IA

Comece determinando se o documento já contém texto utilizável. Digital nativo significa que o PDF foi gerado por software e geralmente contém objetos de texto que podem ser selecionados e copiados. Um PDF digitalizado pode conter apenas imagens de página, então um parser de texto normal retorna pouco ou nada.

A documentação oficial do PyMuPDF mostra a extração direta de texto com page.get_text(). Um teste local mínimo se parece com isto:

import pymupdf

def extract_native_text(pdf_path: str) -> str:
    pages = []
    with pymupdf.open(pdf_path) as doc:
        for page in doc:
            pages.append(page.get_text())
    return "\f".join(pages)

text = extract_native_text("invoice.pdf")
print(text[:1000])

Veja os fundamentos oficiais do PyMuPDF. O PyMuPDF também alerta que o texto simples do PDF pode não aparecer na ordem natural de leitura e pode conter quebras de linha inesperadas. Isso é uma limitação do parser, não necessariamente um problema de IA.

Melhor ajuste: faturas, extratos, relatórios e formulários onde a cópia/colagem de texto já funciona e os campos são fáceis de identificar a partir de rótulos próximos.

Cuidado com: uma página pode conter uma camada de texto minúscula mais uma grande imagem digitalizada. Portanto, verificar simplesmente se “algum texto existe” não é um detector de digitalização perfeito. Para automação de produção, inspecione documentos representativos em vez de depender de um único limite universal de contagem de caracteres.

Ação: pegue 20–50 PDFs representativos e classifique-os em grupos digitais nativos, digitalizados, mistos e com muito layout. Seu pipeline deve rotear pelo comportamento do documento, não apenas pela extensão do arquivo.

Etapa 2: Extraia texto localmente—ou use OCR apenas quando necessário

Opção A: PyMuPDF para PDFs digitais limpos

Se a camada de texto for confiável, a extração direta é normalmente o caminho mais simples. Isso evita a latência do OCR e evita introduzir erros de caracteres do OCR em texto que já estava codificado corretamente. Para documentos longos, você pode preservar separadores de página e processar grupos de páginas ou seções lógicas em vez de passar o documento inteiro para o modelo de uma só vez.

Compensação: texto simples é barato e rápido, mas tabelas, páginas de múltiplas colunas, cabeçalhos, rodapés e ordem de leitura podem exigir tratamento adicional. Se essas relações forem importantes para os campos de destino, mude para uma representação consciente do layout em vez de acumular instruções de prompt em texto de origem pobre.

Opção B: OCRmyPDF mais Tesseract para páginas digitalizadas

O Tesseract é um mecanismo de OCR de código aberto. Seu manual de usuário atual documenta a série 5.x e o suporte para muitos idiomas através de arquivos de dados treinados separados. O OCRmyPDF envolve o OCR ao redor do processamento específico de PDF para que páginas digitalizadas possam ganhar uma camada de texto pesquisável.

Para um documento misto onde algumas páginas já contêm texto, as versões atuais do OCRmyPDF suportam um modo skip:

ocrmypdf --mode skip input.pdf searchable.pdf

A documentação avançada oficial do OCRmyPDF explica que --mode skip deixa as páginas com texto existente intactas e faz OCR nas páginas que precisam. A mesma documentação descreve redo para substituir o OCR anterior detectado e force para rasterizar e fazer OCR de todo o conteúdo. Use force com cautela porque a rasterização pode descartar vantagens vetoriais e achatar conteúdo interativo.

Para instalação do Tesseract, idiomas e comportamento da linha de comando, use o manual de usuário oficial do Tesseract. O idioma do OCR importa: se suas faturas contêm inglês e alemão, por exemplo, instale e configure os dados de idioma apropriados em vez de assumir que o modelo padrão em inglês lidará com ambos igualmente bem.

Opção C: Docling quando a estrutura importa

O Docling foi projetado para conversão de documentos com opções de layout, tabela, OCR e processamento local de visão-linguagem. Sua documentação do projeto lista compreensão avançada de PDF, estrutura de tabela, OCR e saídas sem perdas no estilo JSON/Markdown, com execução local destinada a fluxos de trabalho sensíveis e isolados (air-gapped).

Uma conversão básica em Python pode ser tão pequena quanto:

from docling.document_converter import DocumentConverter

converter = DocumentConverter()
doc = converter.convert("input.pdf").document

markdown = doc.export_to_markdown()
structured = doc.export_to_dict()

Veja o início rápido oficial do Docling. O Docling também suporta pipelines VLM locais e vários backends de OCR. Suas opções avançadas explicam que chamadas de serviços remotos exigem opt-in explícito, enquanto artefatos de modelo podem ser pré-baixados para uso offline.

Melhor ajuste: tabelas complexas, cabeçalhos, relatórios de múltiplas colunas, digitalizações mistas ou casos onde você deseja uma representação de documento reutilizável em vez de um despejo de texto simples.

Compensação: o pipeline é mais pesado que um parser de PDF simples. Use-o porque a estrutura extra melhora sua precisão de extração—não apenas porque tem mais componentes.

Ação: escolha o método de extração mais leve que preserva as informações de que seu esquema de destino precisa. Não faça OCR de texto incorporado limpo e não descarte o layout quando o layout determina o significado.

Etapa 3: Mapeie o conteúdo recuperado em um esquema estrito com um modelo local

Depois de ter conteúdo de origem confiável, use o modelo local para o que ele é bom: mapeamento semântico. Em vez de perguntar “Extraia tudo desta fatura”, defina os campos que você realmente precisa.

Por exemplo:

from pydantic import BaseModel
from typing import Optional

class LineItem(BaseModel):
    description: str
    quantity: Optional[float]
    unit_price: Optional[float]
    amount: Optional[float]

class Invoice(BaseModel):
    invoice_number: Optional[str]
    invoice_date: Optional[str]
    vendor_name: Optional[str]
    currency: Optional[str]
    subtotal: Optional[float]
    tax: Optional[float]
    total: Optional[float]
    items: list[LineItem]

A documentação atual de saída estruturada do Ollama suporta passar um JSON Schema através do campo format e validar a resposta com Pydantic. Uma chamada local pode se parecer com isto:

from ollama import chat

schema = Invoice.model_json_schema()

prompt = f"""
Extract the invoice into the supplied schema.

Rules:
- Use only information present in the source.
- Use null when a field is not found.
- Do not infer missing invoice numbers, dates, tax, or totals.
- Preserve line items individually.

SOURCE:
{text}
"""

response = chat(
    model="gpt-oss",
    messages=[{"role": "user", "content": prompt}],
    format=schema,
    options={"temperature": 0},
)

invoice = Invoice.model_validate_json(response.message.content)

Isso segue o padrão na documentação oficial de Saídas Estruturadas do Ollama, que recomenda esquemas reutilizáveis e uma temperatura baixa, como zero, para conclusões estruturadas mais determinísticas.

O nome do modelo acima é um exemplo da própria documentação de saída estruturada do Ollama, não uma afirmação de que é o melhor modelo para cada trabalho de extração. Um modelo menor pode ser adequado para faturas repetitivas com rótulos claros; um modelo mais forte pode ajudar com contratos ambíguos ou layouts inconsistentes, mas geralmente exigirá mais memória e tempo de processamento.

Modelo de texto ou modelo de visão?

Use um modelo de texto quando a saída do parser/OCR já preserva as relações de campo de que você precisa. Use um modelo local com capacidade de visão quando a posição visual for essencial ou a conversão de texto estiver consistentemente perdendo estrutura. A documentação oficial de Visão do Ollama suporta entradas de imagem para modelos de visão locais, e seu recurso de saída estruturada pode ser combinado com modelos com capacidade de visão.

No entanto, renderizar cada página como uma imagem muda a compensação:

• mais pixels devem ser processados;
• o agrupamento de páginas se torna importante para PDFs longos;
• modelos visuais ainda podem inventar um campo ou ler incorretamente um número;
• você precisa de uma maneira de rastrear valores extraídos de volta a uma página ou região de origem.

Ação: comece com texto de parser/OCR mais um LLM local restrito por esquema. Escale apenas os tipos de página difíceis para um VLM local em vez de pagar o custo de visão por cada página.

Etapa 4: Valide antes de escrever JSON, CSV, Excel ou um banco de dados

JSON válido por esquema não é automaticamente factualmente correto. Um modelo pode produzir campos válidos com valores errados. O último estágio deve, portanto, usar verificações determinísticas sempre que possível.

Para uma fatura, verificações úteis incluem:

• Campos de identidade obrigatórios: número da fatura ou nome do fornecedor deve estar presente se seu fluxo de trabalho precisar deles.
• Análise de data: analise datas com uma política fixa em vez de confiar em strings ambíguas como 03/04/26.
• Aritmética: compare a soma dos valores dos itens da linha com o subtotal do documento dentro de uma tolerância definida.
• Totais: verifique se subtotal mais impostos e outras cobranças é consistente com o total.
• Moeda: não assuma USD porque o documento está em inglês.
• Proveniência: armazene o nome do arquivo de origem, número da página, timestamp da extração e, opcionalmente, um hash do PDF original.
• Fila de revisão: roteie casos ausentes, conflitantes ou de baixa confiança para revisão humana em vez de preencher valores silenciosamente.

Uma estrutura básica de lote pode separar extração de validação:

from pathlib import Path
import json

for pdf_path in Path("inbox").glob("*.pdf"):
    source_text = extract_native_text(str(pdf_path))

    # If text is unusable, run your OCR or Docling branch here.
    record = extract_with_local_model(source_text)

    errors = validate_record(record)

    if errors:
        save_for_review(pdf_path, record, errors)
    else:
        output = Path("processed") / f"{pdf_path.stem}.json"
        output.write_text(
            json.dumps(record, ensure_ascii=False, indent=2),
            encoding="utf-8"
        )

As funções auxiliares são intencionalmente deixadas específicas da aplicação porque as regras de validação diferem dramaticamente entre faturas, contratos, formulários fiscais, relatórios de laboratório e ordens de compra. Um validador universal criaria falsa confiança.

Se você precisar de CSV ou Excel, achate apenas os campos que realmente pertencem a linhas e colunas. Para documentos com itens de linha repetidos, muitas vezes é mais limpo criar uma tabela de nível de documento e uma segunda tabela de itens de linha vinculada por um ID de documento, em vez de forçar cada campo em uma única linha larga de planilha.

Ação: defina regras de validação antes de processar milhares de arquivos. Teste contra um conjunto de amostras rotulado e registre a precisão por campo, não apenas “documentos processados com sucesso”.

Uma arquitetura totalmente local prática

Para muitos trabalhos de automação de pequeno e médio porte, essa divisão de responsabilidades é mais fácil de manter do que um modelo tudo-em-um:

PDF inbox
   |
   +-- born-digital --> PyMuPDF -------------------+
   |                                               |
   +-- scanned/mixed --> OCRmyPDF/Tesseract -------+--> normalized text/layout
   |                                               |
   +-- layout-heavy --> Docling -------------------+
                                                   |
                                                   v
                                         local LLM / VLM
                                                   |
                                            JSON Schema
                                                   |
                                                   v
                                   deterministic validation
                                                   |
                            +----------------------+----------------+
                            |                      |                |
                           JSON                   CSV             database

Esse design permite trocar componentes independentemente. Se a qualidade do OCR for fraca, melhore a camada de OCR sem retreinar o LLM. Se o modelo local for muito lento, use um menor sem alterar o parser de PDF. Se as faturas de um fornecedor precisarem de tratamento especial de tabela, roteie apenas esses arquivos através do Docling ou de um ramo de visão.

Ollama vs. llama.cpp vs. Docling VLM: qual runtime local você deve escolher?

O repositório oficial do llama.cpp documenta um llama-server local e geração restrita por gramática; o código atual do servidor também aceita restrições de esquema JSON. A documentação de Modelos de Visão do Docling lista opções VLM locais para conversão de documentos.

Não selecione um runtime apenas com base em um ranking de modelos. Para extração de PDF, as medidas práticas são precisão de campo, throughput por documento, uso de memória na sua máquina, taxa de falha nos seus layouts, complexidade de inicialização e quão facilmente você pode inspecionar resultados incorretos.

Como manter o pipeline genuinamente local

“Sem API na nuvem” deve ser uma propriedade de implantação que você pode verificar, não apenas um rótulo de marketing.

Ollama

A FAQ oficial do Ollama diz que prompts e respostas locais não são enviados de volta ao Ollama. Também documenta uma configuração de desativação da nuvem:

OLLAMA_NO_CLOUD=1

ou a configuração de servidor equivalente disable_ollama_cloud. A API local do Ollama roda em http://localhost:11434 e não requer autenticação para acesso local, de acordo com sua documentação de autenticação.

Lembre-se de que um serviço vinculado ao localhost é diferente de um exposto à sua LAN. Se você alterar seu endereço de vinculação ou colocá-lo atrás de outro servidor, você é responsável pelo controle de acesso.

Docling

O Docling mantém o uso de serviços remotos desativado por padrão. Sua documentação também distingue privacidade de processamento de aquisição de modelo: modelos podem ser buscados no primeiro uso, a menos que você os pré-baixe. Para um sistema isolado (air-gapped), use docling-tools models download em uma máquina de staging conectada ou pré-posicione artefatos de modelo aprovados de outra forma, então aponte o ambiente offline para esse diretório de artefatos local.

Ação: antes de processar documentos sensíveis, bloqueie o acesso de rede de saída na camada de sistema operacional ou rede e execute um teste enquanto monitora conexões. As configurações da aplicação são úteis, mas os controles de rede fornecem uma camada de verificação independente.

O que a IA local não resolve

Executar localmente melhora as opções de controle de dados, mas não torna automaticamente a extração correta, compatível ou segura. Arquivos locais ainda podem vazar através de logs de depuração, diretórios temporários, backups, pastas compartilhadas, serviços excessivamente permissivos ou exportações copiadas. Um modelo local também pode alucinar valores exatamente como um modelo hospedado pode.

Não use o modelo como o único verificador para campos de alto impacto, como números de conta bancária, instruções de pagamento, datas de contrato, valores médicos ou identificadores regulatórios. Para esses, compare com o texto de origem, aplique validação determinística e exija revisão humana quando a confiança for insuficiente.

Como testar antes de automatizar uma pasta inteira

Construa um pequeno conjunto de avaliação rotulado contendo os casos que você realmente recebe:

• PDF digital limpo;
• digitalização de baixa resolução;
• página rotacionada ou distorcida;
• fatura de múltiplas páginas;
• tabela abrangendo páginas;
• campos opcionais ausentes;
• formatos diferentes de data e número;
• pelo menos um documento deliberadamente difícil.

Para cada campo de destino, compare o valor extraído com a verdade fundamental. Meça a correspondência exata para identificadores, tolerância numérica para valores e precisão por linha para itens de linha. Registre também o tempo de processamento e a porcentagem de documentos enviados para revisão manual.

Se um caminho mais simples PyMuPDF+LLM atingir sua precisão necessária, mantenha-o. Se as digitalizações forem a principal falha, melhore o OCR. Se as relações de tabela forem o problema, teste o Docling. Se os campos posicionados visualmente permanecerem difíceis, roteie esse subconjunto através de um modelo de visão local. Essa escalada em etapas geralmente oferece melhor controle sobre velocidade e uso de hardware do que aplicar o modelo mais pesado a cada página.

Conclusão

Um bom sistema local de extração de PDF separa leitura de documento de extração semântica. Use PyMuPDF quando o PDF já contém bom texto; OCRmyPDF/Tesseract quando a página é digitalizada; Docling quando estrutura e tabelas importam; e um modelo local Ollama ou llama.cpp quando você precisa de mapeamento flexível em um esquema de negócio. Use visão local apenas onde o layout visual adiciona informação que o pipeline de texto não pode preservar de forma confiável.

O requisito final é validação. O JSON Schema pode restringir a forma da resposta do modelo, mas não pode provar que o valor, data, nome ou número de conta corresponde à fonte. Se você projetar o pipeline para que documentos incertos sejam visíveis e revisáveis, pode automatizar uma grande fração da extração de dados de PDF sem entregar os documentos a uma API na nuvem—e sem fingir que a IA local elimina a necessidade de controle de qualidade.