Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Pipeline de production

Les 16 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. De la preuve de concept à la production
  2. Les six composants d’un pipeline complet
  3. Une classe qui encapsule le traitement
  4. Anticiper la facture
  5. Surveiller la santé du service
  6. Où aller ensuite
  7. Résumé du cours
  8. Belangrijkste punten
  9. Testez vos connaissances

Mise à jour du 2 novembre 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) a été retiré le 30 septembre 2026. Utilisez OCR 4.1 (mistral-ocr-4-1), disponible en accès général depuis le 31 août au même tarif, ou l’alias mistral-ocr-latest, qui le cible depuis le 16 juillet. OCR 4.1 ajoute des scores de confiance au niveau des blocs. Addendum du 3 novembre 2026 : un PDF local est transmis en base64 sous la forme {"type": "document_url", "document_url": "data:application/pdf;base64,…"} ; le type document_base64 présent dans d’anciens exemples n’existe ni dans la documentation ni dans le SDK mistralai, et ces exemples auraient échoué. Sources : OCR Processor · Document QnA. Corrigé le 3 novembre 2026 : le code lisait précédemment page.document_annotation page par page ; dans le SDK mistralai 3.7.0, l’annotation du document est un champ unique dans la réponse (response.document_annotation), et l’annotation d’une image se lit via image.image_annotation.

De la preuve de concept à la production

Vous avez appris à utiliser l’OCR, les annotations et le QnA Document AI. Il reste un écart coûteux : la distance entre un script qui fonctionne sur votre ordinateur portable et un service sur lequel vos collègues comptent chaque matin. Cette dernière leçon assemble les briques précédentes en un pipeline robuste, complet avec reprise sur erreur, surveillance et maîtrise des coûts.

Les six composants d’un pipeline complet

  1. File d’ingestion : reçoit et priorise les documents.
  2. Prétraitement : valide, convertit les formats et améliore les images.
  3. OCR + Annotations : extrait le texte et les données structurées.
  4. Post-traitement : valide, nettoie et enrichit les données.
  5. Stockage : bases de données, magasins vectoriels et archivage.
  6. Interface de requête : API QnA, tableaux de bord et intégrations.

Le code de cette leçon couvre le cœur de la chaîne — les étapes 3 et 4 — car c’est là que se concentrent les difficultés opérationnelles.

Une classe qui encapsule le traitement

La classe PipelineDocumentAI définit une configuration une fois pour toutes — schéma d’annotation, format de tableau et nombre de tentatives — puis l’applique à chaque document. Trois mécanismes méritent votre attention. Premièrement, la nouvelle tentative avec backoff exponentiel (time.sleep(2 ** tentative)) espace les tentatives d’une, puis deux, puis quatre secondes. Cela laisse le temps à une saturation temporaire de l’API de se résorber plutôt que de l’aggraver. Deuxièmement, la journalisation trace chaque succès avec son nombre de pages et sa durée, et chaque échec avec son numéro de tentative ; sans ces lignes, vous ne découvrirez les incidents que lorsque le service comptable vous appellera. Enfin, le dictionnaire stats alimente le rapport de fin de lot.

Notez que la méthode renvoie toujours un ResultatTraitement, même après épuisement des tentatives : l’appelant n’a jamais à gérer une exception, il lit simplement le champ erreur.

import os
import time
import base64
import logging
from pathlib import Path
from dataclasses import dataclass, field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model
from pydantic import BaseModel, Field
from typing import Optional

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("document_ai_pipeline")

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


@dataclass
class ResultatTraitement:
    fichier: str
    pages: int = 0
    texte: str = ""
    annotations: Optional[dict] = None
    duree_secondes: float = 0.0
    erreur: Optional[str] = None


class PipelineDocumentAI:
    def __init__(
        self,
        schema_annotation=None,
        table_format: str = "markdown",
        max_retries: int = 3,
    ):
        self.schema_annotation = schema_annotation
        self.table_format = table_format
        self.max_retries = max_retries
        self.stats = {"total": 0, "succes": 0, "erreurs": 0}

    def traiter_document(self, chemin: str) -> ResultatTraitement:
        """Traite un document avec reprise et surveillance."""
        debut = time.time()
        self.stats["total"] += 1

        for tentative in range(self.max_retries):
            try:
                # Lecture et encodage
                with open(chemin, "rb") as f:
                    doc_b64 = base64.b64encode(f.read()).decode("utf-8")

                # Paramètres d'appel
                params = {
                    "model": "mistral-ocr-latest",
                    "document": {
                        "type": "document_url",
                        "document_url": f"data:application/pdf;base64,{doc_b64}"
                    },
                    "table_format": self.table_format,
                }

                if self.schema_annotation:
                    params["document_annotation_format"] = (
                        response_format_from_pydantic_model(
                            self.schema_annotation
                        )
                    )

                # Appel OCR
                response = client.ocr.process(**params)

                # Extraction du texte
                texte = "\n\n".join(
                    p.markdown for p in response.pages
                )

                # Extraction des annotations
                annotations = None
                if self.schema_annotation:
                    if response.document_annotation:
                        annotations = response.document_annotation

                duree = time.time() - debut
                self.stats["succes"] += 1

                logger.info(
                    f"OK: {chemin} ({len(response.pages)} pages, "
                    f"{duree:.1f}s)"
                )

                return ResultatTraitement(
                    fichier=chemin,
                    pages=len(response.pages),
                    texte=texte,
                    annotations=annotations,
                    duree_secondes=duree,
                )

            except Exception as e:
                logger.warning(
                    f"Tentative {tentative + 1}/{self.max_retries} "
                    f"échouée pour {chemin}: {e}"
                )
                if tentative < self.max_retries - 1:
                    time.sleep(2 ** tentative)  # Backoff exponentiel

        # Toutes les tentatives ont échoué
        self.stats["erreurs"] += 1
        return ResultatTraitement(
            fichier=chemin,
            duree_secondes=time.time() - debut,
            erreur="Échec après toutes les tentatives",
        )

    def traiter_dossier(self, dossier: str) -> list[ResultatTraitement]:
        """Traite tous les PDF d'un dossier."""
        chemin = Path(dossier)
        fichiers = sorted(chemin.glob("*.pdf"))
        resultats = []

        for fichier in fichiers:
            resultat = self.traiter_document(str(fichier))
            resultats.append(resultat)

        return resultats

    def rapport(self) -> str:
        """Génère un rapport de traitement."""
        return (
            f"Documents traités : {self.stats['total']}\n"
            f"Succès : {self.stats['succes']}\n"
            f"Erreurs : {self.stats['erreurs']}\n"
            f"Taux de succès : "
            f"{self.stats['succes']/max(self.stats['total'],1)*100:.1f}%"
        )

En pratique, la même classe couvre les deux besoins : instanciée sans schéma, elle extrait simplement le texte ; instanciée avec un modèle Pydantic, elle produit également des données structurées.

# Pipeline simple (OCR uniquement)
pipeline = PipelineDocumentAI(table_format="markdown")
resultats = pipeline.traiter_dossier("./factures/")
print(pipeline.rapport())

# Pipeline avec annotations
from pydantic import BaseModel, Field

class ExtractionFacture(BaseModel):
    fournisseur: str = Field(..., description="Nom du fournisseur")
    montant_ttc: float = Field(..., description="Montant TTC")
    date: str = Field(..., description="Date (YYYY-MM-DD)")

pipeline_annote = PipelineDocumentAI(
    schema_annotation=ExtractionFacture,
    table_format="markdown"
)
resultats = pipeline_annote.traiter_dossier("./factures/")

Anticiper la facture

La maîtrise des coûts est essentielle en production, et elle commence par la compréhension de ce qui vous est facturé.

ÉlémentBase de facturation
OCRPar page traitée
AnnotationsInclus dans l’appel OCR (aucun coût supplémentaire)
QnAJetons d’entrée/sortie selon le modèle de chat
EmbeddingsJetons d’entrée

Le fait que les annotations n’engendrent aucun coût supplémentaire change la conception : extrayez les métadonnées lors du passage OCR plutôt que d’exécuter un appel LLM séparé ensuite. La fonction d’estimation ci-dessous vous permet de chiffrer un projet avant de le lancer ; ses tarifs sont des ordres de grandeur à ajuster, le tableau de référence publié par Mistral faisant autorité.

def estimer_cout(
    nombre_pages: int,
    avec_qna: bool = False,
    modele_qna: str = "mistral-small-latest"
) -> dict:
    """Estime le coût de traitement."""

    # Tarifs approximatifs (vérifiez les tarifs actuels)
    cout_ocr_par_page = 0.001  # À ajuster selon le niveau
    cout_qna_par_1k_tokens = {
        "mistral-small-latest": 0.001,
        "mistral-large-latest": 0.008,
    }

    cout_ocr = nombre_pages * cout_ocr_par_page
    cout_qna = 0.0

    if avec_qna:
        # Estimation : ~500 jetons par page en moyenne
        tokens_estimes = nombre_pages * 500
        cout_qna = (
            tokens_estimes / 1000
            * cout_qna_par_1k_tokens.get(modele_qna, 0.001)
        )

    return {
        "cout_ocr": round(cout_ocr, 4),
        "cout_qna": round(cout_qna, 4),
        "cout_total": round(cout_ocr + cout_qna, 4),
    }

Surveiller la santé du service

Un pipeline se dégrade lentement et silencieusement : un nouveau fournisseur envoie des scans de mauvaise qualité, le taux d’erreur passe de 2 % à 15 %, et personne ne s’en aperçoit jusqu’à la clôture mensuelle. Quatre métriques suffisent à détecter une dérive — volume traité, durée moyenne, taux d’erreur et coût estimé — à condition de les émettre systématiquement et de les envoyer à votre outil habituel, qu’il s’agisse de Datadog, Prometheus ou autre.

import json
from datetime import datetime

def log_metrique(nom: str, valeur: float, tags: dict = None) -> None:
    """Enregistre une métrique de surveillance."""
    metrique = {
        "timestamp": datetime.utcnow().isoformat(),
        "nom": nom,
        "valeur": valeur,
        "tags": tags or {}
    }
    # En production : envoyer à Datadog, Prometheus, etc.
    logger.info(f"METRIQUE: {json.dumps(metrique)}")

# Exemples de métriques à suivre
log_metrique("ocr.pages_traitees", 150, {"batch": "factures_mars"})
log_metrique("ocr.duree_moyenne_secondes", 2.3)
log_metrique("ocr.taux_erreur", 0.02)
log_metrique("ocr.cout_estime_usd", 0.15)

Où aller ensuite

Vous disposez désormais des bases pour construire un système Document AI complet, et plusieurs extensions s’ouvrent selon vos contraintes. Des volumes très élevés justifient un déploiement on-premise du modèle OCR sur un GPU dédié ; des documents très spécifiques à votre activité peuvent motiver un fine-tuning, sujet à aborder directement avec Mistral. Côté intégration, le défi consiste à connecter le pipeline à vos systèmes existants — ERP, CRM — et à construire un tableau de bord permettant à vos équipes d’interroger elles-mêmes les documents sans passer par vous. La dernière étape consiste à supprimer le déclenchement manuel : le pipeline s’exécute automatiquement dès l’arrivée de nouveaux documents.

Résumé du cours

Ces seize leçons vous ont fait parcourir le cycle complet. Vous avez commencé par les fondamentaux — ce qu’est le Document AI, le modèle OCR 4 et les cas d’usage — avant d’aborder l’OCR avancé avec l’API, l’extraction de tableaux, les en-têtes/pieds de page et l’optimisation. Les annotations vous ont ensuite offert l’extraction structurée, le traitement par lots et le contrôle de conformité, suivis par le Document QnA, qui a ouvert la voie à l’interrogation en langage naturel, de documents isolés à des corpus indexés en RAG. Vous disposez désormais des briques nécessaires pour équiper la gestion documentaire de votre organisation avec Mistral Document AI.

Belangrijkste punten

  • Un pipeline de production inclut la reprise, la journalisation, la surveillance et la gestion des coûts.
  • Le backoff exponentiel protège contre les erreurs API transitoires.
  • Estimez vos coûts avant de monter en charge (OCR par page, QnA par jeton).
  • Une surveillance continue permet de détecter une dégradation des performances.
  • Le Document AI couvre l’ensemble du cycle de vie du document, de l’ingestion à l’exploitation.

Testez vos connaissances

OCR, annotations, QnA : validez la chaîne documentaire complète.

1. Que produit l'API OCR de Mistral à partir d'un document ?

Réponse : Le contenu structuré du document — texte, tableaux, mise en page — prêt pour un usage programmatique : OCR 4 lit le document comme une source de données, non comme une image.

2. Quel est l'objectif de l'API Annotations ?

Réponse : Extraire des métadonnées structurées selon votre schéma (champs de facture, clauses de contrat) — individuellement ou par lots pour les volumes élevés.

3. Que permet le Document QnA ?

Réponse : Poser des questions en langage naturel sur un ou plusieurs documents et obtenir des réponses basées sur leur contenu — la couche conversationnelle au-dessus de l’extraction.

4. Comment optimiser la précision de l'OCR ?

Réponse : Par la qualité des entrées (résolution, netteté, orientation) et la gestion des zones difficiles — en-têtes, pieds de page, pagination — que le cours vous apprend à gérer explicitement.

5. Pourquoi combiner OCR et RAG ?

Réponse : L’OCR transforme les documents scannés en texte indexable, tandis que le RAG les rend interrogeables à grande échelle : ensemble, ils permettent une recherche sémantique sur des archives entières.

Extraction, annotation, questions-réponses, indexation : le pipeline de production ci-dessus enchaîne ces quatre étapes — votre paperasse devient une base de données.