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. Ce socle a une frontière naturelle — jusqu’ici, le modèle a toujours regardé une image et rendu du texte, sans jamais agir. Cette dernière leçon franchit cette frontière en trois temps : le service spécialisé pour les documents, le function calling qui transforme l’analyse en action, et les pipelines qui enchaînent les deux.

Document AI (OCR 4) de Mistral

Pour les besoins d’OCR avancé, Mistral propose Document AI, un service spécialisé dans le traitement de documents. Là où la Vision API traite des images individuelles, Document AI raisonne à l’échelle du document : il prend en charge les PDF multi-pages et analyse des dossiers longs d’un seul tenant. Il gère les mises en page complexes — colonnes, en-têtes et pieds de page, tableaux imbriqués — et préserve la structure, l’output conservant la hiérarchie du document avec ses titres, ses paragraphes et ses listes. Sa précision OCR, enfin, est optimisée aussi bien pour le texte imprimé que 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)

Deux différences avec tout ce que vous avez écrit jusqu’ici : le type d’élément devient document_url au lieu de image_url, et le paramètre document_image_limit plafonne le nombre de pages traitées — un garde-fou indispensable face à un rapport annuel de trois cents pages.

Quand utiliser Document AI vs Vision API

Retenez la règle de partage : la Vision API pour ce qui est né image, Document AI pour ce qui est né document.

Vision + Function Calling

Jusqu’ici, votre code recevait une réponse et décidait quoi en faire. Le function calling inverse ce rapport : vous fournissez au modèle la liste des actions disponibles, et c’est lui qui choisit laquelle appeler au vu de l’image. C’est la clé pour construire des agents visuels autonomes.

Le cycle comporte quatre temps :

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

Considérez un service comptable qui reçoit des factures par courrier. Deux issues sont possibles : la facture est saine et doit être enregistrée, ou elle présente une anomalie et doit être signalée. On décrit donc deux outils, avec leurs paramètres et leurs champs obligatoires.

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)}")

Soignez le champ description de chaque fonction : c’est sur lui, et non sur le nom, que le modèle fonde son choix. Une description vague produit un agent qui appelle la mauvaise fonction.

Pipelines multimodaux

Un pipeline multimodal enchaîne plusieurs étapes de traitement en combinant vision, texte et outils. Son intérêt est autant économique qu’organisationnel : chaque étape emploie le modèle strictement nécessaire.

Exemple : pipeline de traitement de courrier

Le courrier entrant d’une PME mêle factures, devis, contrats et publicités. Les classer coûte peu, les analyser en détail coûte cher : le pipeline commence donc par un tri au modèle léger, et ne mobilise Large que sur les documents qui le justifient.

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, "données": 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))

Sur un lot où une pièce sur cinq est une facture, quatre documents sur cinq ne verront jamais le modèle coûteux, pour une qualité finale identique.

Résumé de la formation

Au cours de ces 12 leçons, vous êtes passé du mécanisme à l’application. Vous avez d’abord compris l’architecture multimodale et ce qui se produit réellement quand une image entre dans le modèle, puis appris à choisir la déclinaison adaptée à votre charge de travail — Large, Small ou Ministral. Vous savez ensuite envoyer des images par URL comme en Base64, seules ou par lots. Sur cette base, vous avez traité les usages qui font l’essentiel du travail réel : analyser des graphiques, lire du texte par OCR, extraire des données structurées, comparer des images pour le contrôle qualité et le suivi d’évolution. Vous avez enfin appris à optimiser vos appels en coût, en latence et en fiabilité, et à intégrer la vision dans des pipelines plus larges grâce au function calling.

Pour aller plus loin

Quatre directions prolongent naturellement ce parcours. Document AI, d’abord, dont l’OCR 4 traite les documents que la Vision API ne sait pas prendre en charge. Les agents ensuite, en combinant vision et function calling pour construire des systèmes qui décident et agissent. Le fine-tuning, si vos images présentent des spécificités qu’aucun modèle généraliste ne connaît — un catalogue de pièces industrielles, un formulaire interne. La Batch API enfin, conçue pour traiter des milliers d’images à coût réduit lorsque le délai de réponse n’est pas critique. À plus long terme, le multimodal avancé ouvrira la voie à la vidéo et à l’audio lorsqu’ils seront disponibles.

Points clés à retenir

• Document AI (OCR 4) 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

Testez vos connaissances

La vision par l’API : cinq questions pour ancrer le pipeline.

1. Comment envoie-t-on une image à l'API Mistral ?

Réponse : Par URL ou encodée en base64, dans un message au contenu mixte texte + image — et plusieurs images peuvent voyager dans le même message pour comparaison.

2. Que permet la vision au-delà de la description ?

Réponse : L’analyse de graphiques, l’OCR (transcrire le texte des images) et l’extraction de données structurées — l’image devient une source de données, pas une illustration.

3. Comment fiabiliser une extraction structurée depuis une image ?

Réponse : Spécifier précisément le schéma attendu (champs, format), demander l’exhaustivité ou l’aveu d’absence, et vérifier les valeurs critiques — la vision se prompte comme le texte.

4. Quelles limites garder en tête ?

Réponse : La qualité de l’image conditionne tout (résolution, netteté) ; les très petits textes et mises en page complexes fatiguent le modèle — optimiser l’entrée avant de blâmer la sortie.

5. Quelles suites naturelles à ce cours ?

Réponse : Document AI pour les documents complets, le function calling pour brancher l’extraction sur vos systèmes, et les pipelines multimodaux qui combinent le tout.

URL ou base64, prompts précis, entrées soignées : le pipeline vision est prêt — les prochaines étapes l’intègrent à vos applications.