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

Próximos Passos: Document AI, Chamada de Funções e Pipelines Multimodais

Aula 12 de 12 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Para Além da Vision API
  2. Mistral Document AI (OCR 4)
  3. Visão + Chamada de Funções
  4. Pipelines Multimodais
  5. Resumo do Curso
  6. Próximos Passos
  7. Pontos-chave
  8. Teste os Seus Conhecimentos

Atualizado em 3 de novembro de 2026 com base na página Document QnA da Mistral e no SDK mistralai 3.7.0: o exemplo consulta um documento utilizando um modelo de chat (mistral-small-latest), não o modelo de OCR, e document_image_limit não é um parâmetro para chat.complete (a chamada falharia); os limites de página são definidos em client.ocr.process. Fonte: Document QnA.

Para Além da Vision API

Dominou agora os fundamentos da Mistral Vision API: envio de imagens via URL e Base64, análise de gráficos, realização de OCR, extração de dados estruturados e comparação de imagens. Esta fundação tem um limite natural — até agora, o modelo observou sempre uma imagem e devolveu texto, sem nunca tomar uma ação. Esta última lição ultrapassa essa fronteira em três etapas: o serviço especializado para documentos, a chamada de funções que transforma análise em ação e os pipelines que as encadeiam.

Mistral Document AI (OCR 4)

Para necessidades avançadas de OCR, a Mistral oferece o Document AI, um serviço especializado no processamento de documentos. Enquanto a Vision API lida com imagens individuais, o Document AI raciocina à escala do documento: gere PDFs de várias páginas e analisa ficheiros longos numa única passagem. Gere layouts complexos — colunas, cabeçalhos e rodapés, tabelas aninhadas — e preserva a estrutura, mantendo a hierarquia do documento de títulos, parágrafos e listas na saída. Por fim, a sua precisão de OCR é otimizada tanto para texto impresso como manuscrito.

Exemplo de Chamada ao Document AI

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Analyze a PDF with Document AI
response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Extract the full content of this document while preserving the structure."
                },
                {
                    "type": "document_url",
                    "document_url": "https://example.com/annual-report.pdf"
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

A diferença face a tudo o que escreveu até agora reside no tipo de elemento: document_url em vez de image_url, lido por um modelo de chat padrão (mistral-small-latest na documentação da Mistral). O documento não deve exceder 50 MB e conter, no máximo, 1.000 páginas. Para processar apenas parte de um relatório anual de 300 páginas, utilize o endpoint de OCR (client.ocr.process), onde os parâmetros pages e image_limit delimitam o trabalho.

Quando Utilizar o Document AI vs. Vision API

NecessidadeVision APIDocument AI
Foto de uma faturaSuficienteExcessivo
PDF de 50 páginasNão suportadoIdeal
Tabela aninhada complexaAproximadoPreciso
Captura de ecrã de interfaceIdealNão adequado
Documento manuscritoBásicoOtimizado

Lembre-se da regra prática: utilize a Vision API para o que nasceu como imagem e o Document AI para o que nasceu como documento.

Visão + Chamada de Funções

Até agora, o seu código recebia uma resposta e decidia o que fazer com ela. A chamada de funções inverte esta relação: fornece ao modelo uma lista de ações disponíveis e este escolhe qual invocar com base na imagem. Esta é a chave para construir agentes visuais autónomos.

O ciclo tem quatro passos:

  1. Envia uma imagem + definições de funções
  2. O modelo analisa a imagem e decide qual a função a chamar
  3. Executa a função e devolve o resultado
  4. O modelo formula uma resposta final

Exemplo: Agente de Processamento de Faturas

Considere um departamento de contabilidade que recebe faturas por correio. São possíveis dois resultados: a fatura é válida e deve ser registada, ou apresenta uma anomalia e deve ser assinalada. Definimos, portanto, duas ferramentas, com os seus parâmetros e campos obrigatórios.

import json

# Define available tools
outils = [
    {
        "type": "function",
        "function": {
            "name": "enregistrer_facture",
            "description": "Enregistre une facture dans le système comptable",
            "parameters": {
                "type": "object",
                "properties": {
                    "emetteur": {"type": "string", "description": "Nom de l'émetteur"},
                    "numero": {"type": "string", "description": "Numéro de facture"},
                    "date": {"type": "string", "description": "Date d'émission (YYYY-MM-DD)"},
                    "montant_ttc": {"type": "number", "description": "Montant TTC en euros"},
                    "tva": {"type": "number", "description": "Montant de la TVA"}
                },
                "required": ["emetteur", "numero", "date", "montant_ttc"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "signaler_anomalie",
            "description": "Signale une anomalie sur une facture (doublons, montants incohérents)",
            "parameters": {
                "type": "object",
                "properties": {
                    "type_anomalie": {"type": "string"},
                    "description": {"type": "string"}
                },
                "required": ["type_anomalie", "description"]
            }
        }
    }
]

# Send the image with the tools
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Vous êtes un assistant comptable. Analysez les factures et utilisez les outils appropriés."
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Traitez cette facture."},
                {"type": "image_url", "image_url": encoder_image("factures/facture-2024-0042.jpg")}
            ]
        }
    ],
    tools=outils,
    tool_choice="auto"
)

# Handle the function call
if response.choices[0].message.tool_calls:
    appel = response.choices[0].message.tool_calls[0]
    nom_fonction = appel.function.name
    arguments = json.loads(appel.function.arguments)
    print(f"Fonction appelée : {nom_fonction}")
    print(f"Arguments : {json.dumps(arguments, indent=2, ensure_ascii=False)}")

Elabore o campo description de cada função com cuidado: o modelo baseia a sua escolha nisso, não no nome. Uma descrição vaga produz um agente que chama a função errada.

Pipelines Multimodais

Um pipeline multimodal encadeia múltiplos passos de processamento combinando visão, texto e ferramentas. O seu valor é tanto económico como organizacional: cada passo emprega estritamente o modelo necessário.

Exemplo: Pipeline de Processamento de Correio

O correio entrante de uma PME mistura faturas, orçamentos, contratos e publicidade. Classificá-los custa pouco; analisá-los em detalhe custa mais. O pipeline começa, portanto, com uma triagem usando um modelo leve, e só recorre ao modelo Large nos documentos que o justifiquem.

def mail_pipeline(image_path):
    """Pipeline complet : classification -> extraction -> action."""

    # Étape 1 : Classification (modèle léger)
    classification = client.chat.complete(
        model="mistral-small-latest",
        response_format={"type": "json_object"},
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": 'Classifiez ce document : {"type": "facture|devis|contrat|courrier|autre", "urgence": "haute|moyenne|basse"}'},
                {"type": "image_url", "image_url": encoder_image(image_path)}
            ]
        }]
    )
    info = json.loads(classification.choices[0].message.content)
    print(f"Type : {info['type']} | Urgence : {info['urgence']}")

    # Étape 2 : Extraction détaillée (modèle puissant, seulement si nécessaire)
    if info["type"] == "facture":
        extraction = client.chat.complete(
            model="mistral-large-latest",
            response_format={"type": "json_object"},
            messages=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": "Extrayez toutes les données de cette facture en JSON : emetteur, numero, date, lignes, total_ht, tva, total_ttc."},
                    {"type": "image_url", "image_url": encoder_image(image_path)}
                ]
            }]
        )
        data = json.loads(extraction.choices[0].message.content)
        return {"classification": info, "données": data}

    # Étape 3 : Résumé pour les autres types
    summary = client.chat.complete(
        model="mistral-small-latest",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Résumez le contenu de ce document en 3 phrases maximum."},
                {"type": "image_url", "image_url": encoder_image(image_path)}
            ]
        }]
    )
    return {"classification": info, "summary": summary.choices[0].message.content}

# Traiter un lot de courrier
from pathlib import Path

for file in sorted(Path("courrier/").glob("*.jpg")):
    print(f"\n--- {file.name} ---")
    result = mail_pipeline(file)
    print(json.dumps(result, indent=2, ensure_ascii=False))

Num lote onde um em cada cinco itens é uma fatura, quatro em cada cinco documentos nunca veem o modelo dispendioso, mantendo uma qualidade final idêntica.

Resumo do Curso

Ao longo destas 12 lições, evoluiu do mecanismo para a aplicação. Primeiro compreendeu a arquitetura multimodal e o que realmente acontece quando uma imagem entra no modelo, depois aprendeu a escolher a variante adequada à sua carga de trabalho — Large, Small ou Ministral. De seguida, aprendeu a enviar imagens via URL e Base64, isoladamente ou em lotes. Com esta base, abordou os usos que constituem a maior parte do trabalho real: análise de gráficos, leitura de texto via OCR, extração de dados estruturados e comparação de imagens para controlo de qualidade e acompanhamento da evolução. Por fim, aprendeu a otimizar as suas chamadas em termos de custo, latência e fiabilidade, e a integrar a visão em pipelines maiores graças à chamada de funções.

Próximos Passos

Quatro direções estendem naturalmente este caminho. Primeiro, o Document AI, cujo OCR 4 lida com documentos que a Vision API não suporta. De seguida, os agentes, combinando visão e chamada de funções para construir sistemas que decidem e agem. Depois, o ajuste fino (fine-tuning), se as suas imagens tiverem especificidades que nenhum modelo generalista conhece — um catálogo de peças industriais, um formulário interno. Por fim, a Batch API, concebida para processar milhares de imagens a custo reduzido quando o tempo de resposta não é crítico. A longo prazo, capacidades multimodais avançadas abrirão o caminho ao vídeo e ao áudio quando estiverem disponíveis.

Pontos-chave

  • O Document AI (OCR 4) é o complemento natural da Vision API para documentos complexos e PDFs
  • A chamada de funções transforma a visão num agente autónomo capaz de agir sobre dados extraídos
  • Um pipeline multimodal combina classificação (Small) e extração (Large) para otimizar qualidade e custo
  • A Mistral Vision API é um bloco de construção fundamental para criar aplicações de IA modernas

Teste os Seus Conhecimentos

Visão via API: cinco perguntas para consolidar o pipeline.

1. Como envia uma imagem para a API da Mistral?

Resposta: Via URL ou codificada em Base64, numa mensagem com conteúdo misto de texto + imagem — e várias imagens podem viajar na mesma mensagem para comparação.

2. O que permite a visão para além da descrição?

Resposta: Análise de gráficos, OCR (transcrição de texto a partir de imagens) e extração de dados estruturados — a imagem torna-se uma fonte de dados, não uma ilustração.

3. Como tornar fiável a extração estruturada a partir de uma imagem?

Resposta: Especifique o esquema esperado com precisão (campos, formato), solicite completude ou admissão de ausência e verifique valores críticos — a visão é instruída tal como o texto.

4. Que limites deve ter em mente?

Resposta: A qualidade da imagem condiciona tudo (resolução, nitidez); texto muito pequeno e layouts complexos fatigam o modelo — otimize a entrada antes de culpar a saída.

5. Quais são os seguimentos naturais deste curso?

Resposta: Document AI para documentos completos, chamada de funções para ligar a extração aos seus sistemas e pipelines multimodais que combinam tudo isto.

URL ou Base64, prompts precisos, entradas cuidadas: o pipeline de visão está pronto — os próximos passos integram-no nas suas aplicações.