Automatize imagens de faturas com OCI Vision e OCI Generative AI

Introdução

Muitas vezes, as empresas recebem milhares de faturas em formatos não estruturados como imagens digitalizadas ou PDFs provenientes de fornecedores e prestadores de serviços. A extração manual de dados dessas faturas, como número da fatura, nome do cliente, itens comprados e valor total, é um processo demorado e propenso a erros.

Esses atrasos no processamento não afetam apenas os ciclos de contas a pagar e a visibilidade do fluxo de caixa, mas também introduzem gargalos na conformidade, na auditoria e nos relatórios.

Este tutorial demonstra como implementar um pipeline automatizado que monitora um bucket na Oracle Cloud Infrastructure (OCI) para imagens de NFFs recebidas, extrai conteúdo textual usando o OCI Vision e, em seguida, aplica o OCI Generative AI (LLM) para extrair dados fiscais estruturados, como número da NFF, cliente e lista de itens.

Os serviços do OCI usados neste tutorial são:

Serviço	Objetivo
OCI Vision	Executa OCR em imagens de NFF carregadas.
IA Generativa do OCI	Extrai dados JSON estruturados de texto OCR bruto usando prompts de poucas capturas.
OCI Object Storage	Armazena imagens de NFF de entrada e resultados JSON de saída.

Objetivos

Automatize a ingestão de faturas do OCI Object Storage.
Extrair dados estruturados de documentos digitalizados semiestruturados.
Integre o OCR (Optical Character Recognition) e o LLM em pipelines em tempo real usando OCI AI Services.

Pré-requisitos

Uma conta do OCI com acesso a:
- OCI Vision
- IA Generativa do OCI
- OCI Object Storage
Uma versão do Python 3.10 ou posterior.
Um bucket para imagens de entrada (por exemplo, input-bucket) e outro para arquivos de saída (por exemplo, output-bucket).
Faça download dos seguintes arquivos:

Tarefa 1: Configurar Pacotes Python

Execute o arquivo requirements.txt usando o comando a seguir.
```
pip install -r requirements.txt
```
Execute o script Python (main.py).
Faça upload de imagens de NFF (por exemplo, .png, .jpg) para seu bucket de entrada.
Aguarde o processamento da imagem e o JSON extraído salvo no bucket de saída.

Tarefa 2: Compreender o Código

Configuração da Carga:

with open("./config", "r") as f:
    config_data = json.load(f)

Este código carrega todos os valores de configuração necessários, como namespace, nomes de bucket, ID do compartimento e ponto final do LLM.

Informe os parâmetros de configuração no arquivo config.

{
    "oci_profile": "DEFAULT",
    "namespace": "your_namespace",
    "input_bucket": "input-bucket",
    "output_bucket": "output-bucket",
    "compartment_id": "ocid1.compartment.oc1..xxxx",
    "llm_endpoint": "https://inference.generativeai.us-chicago-1.oci.oraclecloud.com"
}

Inicializar Clientes do OCI:

oci_config = oci.config.from_file("~/.oci/config", PROFILE)
object_storage = oci.object_storage.ObjectStorageClient(oci_config)
ai_vision_client = oci.ai_vision.AIServiceVisionClient(oci_config)

Este código configura os clientes do OCI SDK para acessar os serviços OCI Object Storage e OCI Vision. Consulte OCI Vision para obter mais informações.

Inicializar LLM:

llm = ChatOCIGenAI(
    model_id="meta.llama-3.1-405b-instruct",
    service_endpoint=LLM_ENDPOINT,
    compartment_id=COMPARTMENT_ID,
    auth_profile=PROFILE,
    model_kwargs={"temperature": 0.7, "top_p": 0.75, "max_tokens": 2000},
)

Esse código inicializa o modelo da OCI Generative AI para compreensão de linguagem natural e conversão de texto em estrutura.

Prompt de poucas capturas:
```
few_shot_examples = [ ... ]
instruction = """
You are a fiscal data extractor.
...
"""
```
Esse código usa o aprendizado instantâneo fornecendo um exemplo de saída esperada para que o modelo aprenda a extrair campos estruturados como number of invoice, customer, location e items.

OCR com OCI Vision:

def perform_ocr(file_name):
print(f"📄 Performing OCR on: {file_name}")

response = ai_vision_client.analyze_document(
    analyze_document_details=oci.ai_vision.models.AnalyzeDocumentDetails(
        features=[
            oci.ai_vision.models.DocumentTableDetectionFeature(
            feature_type="TEXT_DETECTION")],
        document=oci.ai_vision.models.ObjectStorageDocumentDetails(
            source="OBJECT_STORAGE",
            namespace_name=NAMESPACE,
            bucket_name=INPUT_BUCKET,
            object_name=file_name),
        compartment_id=COMPARTMENT_ID,
        language="POR",
        document_type="INVOICE")
)
print(response.data)
return response.data

Esta função:

Envia a imagem para o OCI Vision.
Solicita detecção de texto.
Retorna o texto bruto extraído.

Extração de Dados com LLM:

def extract_data_with_llm(ocr_result, file_name):
    # 🔍 Extrai texto OCR (usando a estrutura da resposta do OCI Vision)
    extracted_lines = []
    for page in getattr(ocr_result, 'pages', []):
        for line in getattr(page, 'lines', []):
            extracted_lines.append(line.text.strip())

    plain_text = "\n".join(extracted_lines)

    # 🧠 Monta o prompt com instrução, few-shot e texto OCR limpo
    prompt = instruction + "\n" + "\n".join(few_shot_examples) + f"\nInvoice text:\n{plain_text}\nExtracted fields (JSON format):"

    # 🔗 Chamada ao LLM
    response = llm([HumanMessage(content=prompt)])

    # 🧪 Tenta extrair JSON puro da resposta
    try:
        content = response.content.strip()
        first_brace = content.find("{")
        last_brace = content.rfind("}")
        json_string = content[first_brace:last_brace + 1]
        parsed_json = json.loads(json_string)
    except Exception as e:
        print(f"⚠️ Erro ao extrair JSON da resposta do LLM: {e}")
        parsed_json = {"raw_response": response.content}

    return {
        "file": file_name,
        "result": parsed_json,
        "timestamp": datetime.utcnow().isoformat()
    }

Esta função:

Combina instruções, exemplo de poucas capturas e texto OCR.
Prepara os dados do OCR retornados pelo OCI Vision.
Envia para a OCI Generative AI.
Recebe campos JSON estruturados (como string).
O OCI Vision suporta o OCR Português (o language="POR" pode ser usado em vez de "ENG").

Salvar Saída no OCI Object Storage:
```
def save_output(result, file_name):
    ...
```
Esse código faz upload do resultado estruturado para o bucket de saída usando o nome de arquivo original com a extensão .json.
Loop Principal - Monitor e Processo:
```
def monitor_bucket():
    ...
```
Rotina principal que:
- Monitora o bucket de entrada a cada 30 segundos.
- Detecta novos arquivos .png, .jpg, .jpeg.
- Executa OCR, LLM e upload em sequência.
- Mantém o controle de arquivos já processados na memória.
Ponto de entrada:
```
if __name__ == "__main__":
    monitor_bucket()
```
Este código inicia o observador de bucket e começa a processar faturas automaticamente.

Tarefa 3: Executar o Código

Execute o código usando o comando a seguir.

python main.py

Tarefa 4: Sugestões de Teste

Use NFFs reais ou fictícias com linhas de produtos legíveis e nome do cliente.
Faça upload de várias imagens no bloco de entrada em sequência para ver o processamento automatizado.
Faça log-in na Console do OCI e navegue até o serviço Object Storage para verificar os resultados em ambos os buckets.

Observação: neste tutorial, a amostra usada é uma NFF brasileira para ilustrar a complexidade dos atributos e da disposição e como o prompt foi criado para resolver esse caso.

Fatura

Tarefa 5: Exibir Saída Esperada

Para cada imagem de fatura carregada, verifique o arquivo de bucket de saída processado. Um arquivo .json correspondente é gerado com conteúdo estruturado, conforme mostrado na imagem a seguir.

Observação:

O OCI Vision suporta o OCR Português (o language="POR" pode ser usado em vez de "ENG").

O prompt do LLM pode ser ajustado para extrair outros campos como CNPJ, quantidade, data de emissão e assim por diante.

Considere persistir o processed_files com um banco de dados ou arquivo para tornar o processo tolerante a falhas.

Esse processo pode ser usado com o caso de uso: Criar um Agente de IA com Servidor de Protocolo de Comunicação Multiagente para Resolução de NFF como uma imagem de NFF pré-processada. A fatura é uma fatura de devolução do cliente da empresa. Os campos cliente e local são capturados do criador da fatura.

Confirmações

Autor - Cristiano Hoshikawa (Oracle LAD A - Engenheiro de Soluções de Equipe)

Mais Recursos de Aprendizado

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal do Oracle Learning YouTube. Além disso, acesse education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

Automate Invoice Images with OCI Vision and OCI Generative AI

G39786-01