Prochaines Étapes : Document AI, Function Calling et Pipelines Multimodaux

Au-delà de la Vision API

Vous maîtrisez désormais les fondamentaux de la Vision API de Mistral : envoi d’images par URL et Base64, analyse de graphiques, OCR, extraction structurée et comparaison. Cette dernière leçon ouvre la porte aux fonctionnalités avancées qui complètent et étendent la vision.

Document AI (OCR 3) de Mistral

Pour les besoins d’OCR avancé, Mistral propose Document AI, un service spécialisé dans le traitement de documents. Contrairement à la Vision API qui traite des images individuelles, Document AI gère :

• Les PDF multi-pages : analyse complète de documents longs
• La mise en page complexe : colonnes, en-têtes/pieds de page, tableaux imbriqués
• La préservation de la structure : l’output conserve la hiérarchie du document (titres, paragraphes, listes)
• La haute précision OCR : optimisé pour le texte imprimé et manuscrit

Exemple d’appel Document AI

from mistralai import Mistral
import os

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

# Analyser un PDF avec Document AI
response = client.chat.complete(
    model="mistral-ocr-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Extrayez le contenu complet de ce document en conservant la structure."
                },
                {
                    "type": "document_url",
                    "document_url": "https://exemple.com/rapport-annuel.pdf"
                }
            ]
        }
    ],
    document_image_limit=20  # Nombre max de pages à traiter
)

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

Quand utiliser Document AI vs Vision API

Vision + Function Calling

Le function calling permet au modèle d’appeler des fonctions de votre code en réponse à une image. C’est la clé pour construire des agents visuels autonomes.

Principe

1. Vous envoyez une image + des définitions de fonctions
2. Le modèle analyse l’image et décide quelle fonction appeler
3. Vous exécutez la fonction et retournez le résultat
4. Le modèle formule une réponse finale

Exemple : agent de traitement de factures

import json

# Définir les outils disponibles
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"]
            }
        }
    }
]

# Envoyer l'image avec les outils
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"
)

# Traiter l'appel de fonction
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)}")

Pipelines multimodaux

Un pipeline multimodal enchaîne plusieurs étapes de traitement, combinant vision, texte et outils :

Exemple : pipeline de traitement de courrier

def pipeline_courrier(chemin_image):
    """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(chemin_image)}
            ]
        }]
    )
    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(chemin_image)}
                ]
            }]
        )
        donnees = json.loads(extraction.choices[0].message.content)
        return {"classification": info, "donnees": donnees}

    # Étape 3 : Résumé pour les autres types
    resume = 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(chemin_image)}
            ]
        }]
    )
    return {"classification": info, "resume": resume.choices[0].message.content}

# Traiter un lot de courrier
from pathlib import Path

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

Ce pipeline utilise Small pour le triage rapide et Large uniquement pour l’extraction détaillée, optimisant ainsi les coûts.

Résumé de la formation

Au cours de ces 12 leçons, vous avez appris à :

1. Comprendre l’architecture multimodale et le fonctionnement interne de la vision
2. Choisir le modèle adapté à votre cas d’usage (Large, Small, Ministral)
3. Envoyer des images par URL et en Base64, individuellement ou par lots
4. Analyser des graphiques, lire du texte (OCR), extraire des données structurées
5. Comparer des images pour le contrôle qualité et le suivi d’évolution
6. Optimiser vos appels en termes de coût, latence et fiabilité
7. Intégrer la vision dans des pipelines complexes avec le function calling

Pour aller plus loin

• Document AI : explorez l’OCR 3 de Mistral pour le traitement avancé de documents
• Agents : combinez vision + function calling pour créer des agents autonomes
• Fine-tuning : entraînez un modèle Mistral sur vos données visuelles spécifiques
• Batch API : utilisez l’API batch de Mistral pour traiter des milliers d’images à coût réduit
• Multimodal avancé : explorez la vidéo et l’audio lorsqu’ils seront disponibles

Points clés à retenir

• Document AI (OCR 3) est le complément naturel de la Vision API pour les documents complexes et les PDF
• Le function calling transforme la vision en agent autonome capable d’agir sur les données extraites
• Un pipeline multimodal combine classification (Small) et extraction (Large) pour optimiser qualité et coût
• La Vision API de Mistral est une brique fondamentale pour construire des applications AI modernes