Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Pipeline de production

Paskaita 16 iš 16 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  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. Svarbiausi punktai
  9. Teste tes connaissances

Mise à jour du 2 novembre 2026 — OCR. OCR 4.0 (mistral-ocr-4-0) a été retiré le 30 septembre 2026. Utilise OCR 4.1 (mistral-ocr-4-1), disponible généralement 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 depuis image.image_annotation.

De la preuve de concept à la production

Tu as 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 ton ordinateur portable et un service sur lequel tes collègues comptent chaque matin. Cette dernière leçon assemble les blocs de construction précédents en un pipeline robuste, complet avec récupération d’erreurs, 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 — le schéma d’annotation, le format de tableau et le nombre de nouvelles tentatives — puis l’applique à chaque document. Trois mécanismes méritent ton attention. Premièrement, la nouvelle tentative avec attente exponentielle (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 suit chaque succès avec son nombre de pages et sa durée, et chaque échec avec son numéro de tentative ; sans ces lignes, tu ne découvriras les incidents que lorsque le service comptable t’appellera. Enfin, le dictionnaire stats alimente le rapport de fin de lot.

Note que la méthode renvoie toujours un ResultatTraitement, même après épuisement des nouvelles 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 nouvelles tentatives 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)  # Attente exponentielle

        # 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 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 basés sur le modèle de chat
EmbeddingsJetons d’entrée

Le fait que les annotations n’entraînent aucun coût supplémentaire change la conception : extrais 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 te 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 restant l’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érifie 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 rend compte 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 à ton 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

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

Résumé du cours

Ces seize leçons t’ont fait parcourir le cycle entier. Tu as commencé par les fondamentaux — ce qu’est le Document AI, le modèle OCR 4 et les cas d’usage — avant de passer à l’OCR avancé avec l’API, l’extraction de tableaux, les en-têtes/pieds de page et l’optimisation. Les annotations t’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, des documents isolés aux corpus indexés en RAG. Tu possèdes maintenant les briques nécessaires pour équiper la gestion documentaire de ton organisation avec Mistral Document AI.

Svarbiausi punktai

  • Un pipeline de production inclut les nouvelles tentatives, la journalisation, la surveillance et la gestion des coûts.
  • L’attente exponentielle protège contre les erreurs API transitoires.
  • Estime tes coûts avant de passer à l’échelle (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.

Teste tes connaissances

OCR, annotations, QnA : valide 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 le but de l'API Annotations ?

Réponse : Extraire des métadonnées structurées selon ton 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 : Grâce à la qualité d’entrée (résolution, netteté, orientation) et à la gestion des zones difficiles — en-têtes, pieds de page, pagination — que le cours t’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 la recherche sémantique à travers des archives entières.

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