Pipeline de production
På denna sida
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’aliasmistral-ocr-latestqui 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 typedocument_base64présent dans d’anciens exemples n’existe ni dans la documentation ni dans le SDKmistralai, et ces exemples auraient échoué. Sources : OCR Processor · Document QnA. Corrigé le 3 novembre 2026 : le code lisait précédemmentpage.document_annotationpage par page ; dans le SDKmistralai3.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 depuisimage.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 briques précédentes 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
- File d’ingestion : Reçoit et priorise les documents.
- Prétraitement : Valide, convertit les formats et améliore les images.
- OCR + Annotations : Extrait le texte et les données structurées.
- Post-traitement : Valide, nettoie et enrichit les données.
- Stockage : Bases de données, magasins vectoriels et archivage.
- 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 tentatives — puis l’applique à chaque document. Trois mécanismes méritent ton 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, 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 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 nouvelle tentative 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 est facturé.
| Élément | Base de facturation |
|---|---|
| OCR | Par page traitée |
| Annotations | Inclus dans l’appel OCR (aucun coût supplémentaire) |
| QnA | Jetons d’entrée/sortie basés sur le modèle de chat |
| Embeddings | Jetons d’entrée |
Le fait que les annotations n’engendrent 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 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é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 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 à 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. De très gros volumes 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 dès l’arrivée de nouveaux documents.
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.
Viktiga punkter
- Un pipeline de production inclut la nouvelle tentative, la journalisation, la surveillance et la gestion des coûts.
- Le backoff exponentiel protège contre les erreurs API transitoires.
- Estime tes 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’intégralité 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 gros volumes.
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é de l’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.