Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Prochaines étapes : Document AI, appel de fonctions et pipelines multimodaux

12. lecke 12 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Au-delà de l’API Vision
  2. Mistral Document AI (OCR 4)
  3. Vision + Appel de fonctions
  4. Pipelines multimodaux
  5. Résumé du cours
  6. Prochaines étapes
  7. Főbb megállapítások
  8. Teste tes connaissances

Mis à jour le 3 novembre 2026 sur la base de la page Document QnA de Mistral et du SDK mistralai 3.7.0 : l’exemple interroge un document via un modèle de chat (mistral-small-latest), et non le modèle OCR, et document_image_limit n’est pas un paramètre pour chat.complete (l’appel aurait échoué) ; les limites de pages sont définies dans client.ocr.process. Source : Document QnA.

Au-delà de l’API Vision

Tu as maintenant maîtrisé les fondamentaux de l’API Vision de Mistral : envoi d’images via URL et Base64, analyse de graphiques, réalisation d’OCR, extraction de données structurées et comparaison d’images. Cette fondation possède une limite naturelle : jusqu’à présent, le modèle a toujours observé une image pour renvoyer du texte, sans jamais agir. Cette dernière leçon franchit cette frontière en trois étapes : le service spécialisé pour les documents, l’appel de fonctions qui transforme l’analyse en action, et les pipelines qui les enchaînent.

Mistral Document AI (OCR 4)

Pour les besoins avancés en OCR, Mistral propose Document AI, un service spécialisé dans le traitement de documents. Là où l’API Vision gère des images individuelles, Document AI raisonne à l’échelle du document : il traite des PDF multipages et analyse de longs fichiers en une seule passe. Il gère des mises en page complexes — colonnes, en-têtes et pieds de page, tableaux imbriqués — et préserve la structure, avec une sortie maintenant la hiérarchie du document (titres, paragraphes, listes). Enfin, sa précision OCR est optimisée pour le texte imprimé comme manuscrit.

Exemple d’appel à Document AI

from mistralai.client 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-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)

La différence avec tout ce que tu as écrit jusqu’ici réside dans le type d’élément : document_url au lieu de image_url, lu par un modèle de chat standard (mistral-small-latest dans la documentation de Mistral). Le document ne doit pas dépasser 50 Mo et contenir au maximum 1 000 pages. Pour traiter uniquement une partie d’un rapport annuel de 300 pages, utilise plutôt le point de terminaison OCR (client.ocr.process), où les paramètres pages et image_limit délimitent le travail.

Quand utiliser Document AI ou l’API Vision

BesoinAPI VisionDocument AI
Photo d’une factureSuffisantSurdimensionné
PDF de 50 pagesNon pris en chargeIdéal
Tableau imbriqué complexeApproximatifPrécis
Capture d’écran d’interfaceIdéalInadapté
Document manuscritBasiqueOptimisé

Retiens cette règle empirique : utilise l’API Vision pour ce qui est né en tant qu’image, et Document AI pour ce qui est né en tant que document.

Vision + Appel de fonctions

Jusqu’à présent, ton code recevait une réponse et décidait quoi en faire. L’appel de fonctions inverse cette relation : tu fournis au modèle une liste d’actions disponibles, et il choisit laquelle appeler en fonction de l’image. C’est la clé pour construire des agents visuels autonomes.

Le cycle comporte quatre étapes :

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

Exemple : Agent de traitement de factures

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

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

# Gérer 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)}")

Rédige soigneusement le champ description pour chaque fonction : le modèle base son choix là-dessus, et non sur le nom. 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. Sa valeur est à la fois économique et organisationnelle : chaque étape emploie strictement le modèle nécessaire.

Exemple : Pipeline de traitement du courrier

Le courrier entrant d’une PME mélange factures, devis, contrats et publicités. Les classer coûte peu ; les analyser en détail coûte plus cher. Le pipeline commence donc par un tri utilisant un modèle léger, et n’engage le modèle Large que pour les documents qui le justifient.

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

Dans un lot où un élément sur cinq est une facture, quatre documents sur cinq ne voient jamais le modèle coûteux, pour une qualité finale identique.

Résumé du cours

Au cours de ces 12 leçons, tu es passé de la mécanique à l’application. Tu as d’abord compris l’architecture multimodale et ce qui se passe réellement lorsqu’une image entre dans le modèle, puis appris à choisir la variante adaptée à ta charge de travail — Large, Small ou Ministral. Tu as ensuite appris à envoyer des images via URL et Base64, individuellement ou par lots. Sur cette base, tu as abordé les usages qui constituent l’essentiel du travail réel : analyse de graphiques, lecture de texte via OCR, extraction de données structurées, comparaison d’images pour le contrôle qualité et le suivi de l’évolution. Enfin, tu as appris à optimiser tes appels pour le coût, la latence et la fiabilité, et à intégrer la vision dans des pipelines plus larges grâce à l’appel de fonctions.

Prochaines étapes

Quatre directions prolongent naturellement ce parcours. D’abord, Document AI, dont l’OCR 4 gère les documents que l’API Vision ne peut pas prendre en charge. Ensuite, les agents, combinant vision et appel de fonctions pour construire des systèmes qui décident et agissent. Puis le fine-tuning, si tes images ont des spécificités qu’aucun modèle généraliste ne connaît — un catalogue de pièces industrielles, un formulaire interne. Enfin, l’API Batch, conçue pour traiter des milliers d’images à coût réduit lorsque le temps de réponse n’est pas critique. À plus long terme, des capacités multimodales avancées ouvriront la voie à la vidéo et à l’audio lorsqu’elles seront disponibles.

Főbb megállapítások

  • Document AI (OCR 4) est le complément naturel de l’API Vision pour les documents complexes et les PDF
  • L’appel de fonctions transforme la vision en un 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
  • L’API Vision de Mistral est un bloc de construction fondamental pour créer des applications IA modernes

Teste tes connaissances

Vision via l’API : cinq questions pour ancrer le pipeline.

1. Comment envoyer une image à l'API Mistral ?

Réponse : Via une URL ou encodée en Base64, dans un message avec un 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 (transcription de texte depuis des images) et l’extraction de données structurées — l’image devient une source de données, pas une illustration.

3. Comment rendre fiable l'extraction structurée depuis une image ?

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

4. Quelles limites dois-tu garder en tête ?

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

5. Quelles sont les suites naturelles de ce cours ?

Réponse : Document AI pour les documents complets, l’appel de fonctions pour connecter l’extraction à tes 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 dans tes applications.