Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Extraire des métadonnées structurées

Les 10 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Extrayez exactement ce dont vous avez besoin
  2. Structurer plutôt qu’aplatir
  3. Données répétitives
  4. Cases à cocher et formulaires
  5. Implémentation de bout en bout
  6. Belangrijkste punten

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 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 de document est un champ unique dans la réponse (response.document_annotation), et l’annotation d’image se lit depuis image.image_annotation.

Extrayez exactement ce dont vous avez besoin

L’annotation de documents ne consiste pas seulement à récupérer du texte brut. Elle produit des données structurées, typées et validées, prêtes à être utilisées immédiatement dans vos systèmes : une ligne insérée dans une base de données, un champ comparé à une référence, ou un montant vérifié avant paiement. Le défi se déplace entièrement vers la conception du schéma, qui est l’objet de cette leçon.

Structurer plutôt qu’aplatir

Un schéma d’extraction doit refléter la réalité du document. Une facture émane d’une entité légale disposant d’un nom d’entreprise, d’un numéro SIRET et d’une adresse. Au lieu d’aligner huit champs comme emetteur_rue, emetteur_ville, emetteur_siret, définissez un modèle Adresse, puis un modèle LegalEntity qui le contient. Réutilisez ces briques de base pour l’émetteur et le destinataire. L’énumération TypeDocument joue un rôle similaire : elle empêche le modèle d’inventer une catégorie et garantit une valeur que vous pouvez utiliser dans une instruction if ou pour le routage. Les champs Optional indiquent explicitement ce qui peut être absent, tandis que les valeurs par défaut — comme default="France" pour le pays — évitent au modèle de deviner l’évidence.

from pydantic import BaseModel, Field
from typing import Optional
from enum import Enum

class DocumentType(str, Enum):
    INVOICE = "facture"
    CONTRACT = "contrat"
    REPORT = "rapport"
    FORM = "formulaire"
    OTHER = "autre"

class Address(BaseModel):
    street: Optional[str] = Field(None, description="Numéro et rue")
    postal_code: Optional[str] = Field(None, description="Code postal")
    city: Optional[str] = Field(None, description="Ville")
    country: str = Field(default="France", description="Pays")

class LegalEntity(BaseModel):
    name: str = Field(..., description="Raison sociale")
    siret: Optional[str] = Field(None, description="Numéro SIRET")
    address: Optional[Address] = Field(None, description="Adresse postale")
    email: Optional[str] = Field(None, description="Adresse e-mail")

class DocumentExtraction(BaseModel):
    document_type: DocumentType = Field(
        ..., description="Type du document"
    )
    date: Optional[str] = Field(
        None, description="Date principale (AAAA-MM-JJ)"
    )
    emetteur: LegalEntity = Field(
        ..., description="Entité qui émet le document"
    )
    destinataire: Optional[LegalEntity] = Field(
        None, description="Entité destinataire"
    )
    resume: str = Field(
        ..., description="Résumé en 2-3 phrases du contenu"
    )
    langue: str = Field(
        ..., description="Langue du document (code ISO 639-1)"
    )

Données répétitives

De nombreux documents contiennent des séries : lignes de facturation, clauses ou postes de dépenses. Modélisez-les sous la forme d’une list[...] d’un sous-modèle dédié. Le modèle analyse alors le tableau du document et produit autant d’objets LigneFacture qu’il trouve de lignes, incluant pour chacune la description, la quantité, le prix unitaire et le total. Cela vous fournit suffisamment de données pour recalculer vous-même le sous-total et vérifier la cohérence du document avant de l’accepter.

from pydantic import BaseModel, Field

class InvoiceLine(BaseModel):
    description: str = Field(..., description="Description du produit/service")
    quantity: float = Field(..., description="Quantité")
    unit_price: float = Field(..., description="Prix unitaire HT")
    amount: float = Field(..., description="Montant total HT de la ligne")

class DetailedInvoice(BaseModel):
    supplier: str = Field(..., description="Nom du fournisseur")
    number: str = Field(..., description="Numéro de facture")
    date: str = Field(..., description="Date (AAAA-MM-JJ)")
    lines: list[InvoiceLine] = Field(
        ..., description="Lignes de la facture"
    )
    subtotal_excl_tax: float = Field(..., description="Sous-total HT")
    vat: float = Field(..., description="Montant TVA")
    total_incl_tax: float = Field(..., description="Total TTC")
    payment_terms: str = Field(
        ..., description="Conditions de paiement mentionnées"
    )

Cases à cocher et formulaires

Les formulaires papier numérisés sont le domaine où le modèle excelle. Un champ bool associé à l’intitulé de la question suffit : le modèle reconnaît si une case est cochée, extrait la question correspondante et — point crucial pour les usages médicaux ou administratifs — déduit qu’un champ est manquant plutôt que d’inventer une valeur, comme l’a démontré l’équipe Mistral. La note « null if not provided » dans la description du numéro de téléphone n’est pas décorative ; elle autorise explicitement une valeur vide.

from pydantic import BaseModel, Field

class FormResponse(BaseModel):
    question: str = Field(..., description="Intitulé de la question")
    answer: bool = Field(..., description="True si coché, False sinon")

class MedicalForm(BaseModel):
    patient_name: str = Field(..., description="Nom complet du patient")
    age: Optional[int] = Field(None, description="Âge du patient")
    sex: Optional[str] = Field(None, description="Sexe (H/F)")
    patient_id: Optional[str] = Field(None, description="ID patient")
    phone: Optional[str] = Field(
        None, description="Numéro de téléphone (null si non fourni)"
    )
    responses: list[FormResponse] = Field(
        ..., description="Réponses aux questions du formulaire"
    )

Implémentation de bout en bout

Reprenons l’exemple de la facture détaillée et connectons-le à un document encodé en base64. L’invite d’annotation complète le schéma en spécifiant le type de fichier et en insistant sur l’attention à porter aux lignes de facturation ; la validation Pydantic au retour convertit la chaîne JSON en un objet que vous pouvez parcourir en toute sécurité.

import os
import json
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model

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

ocr_response = client.ocr.process(
    model="mistral-ocr-latest",
    document={
        "type": "document_url",
        "document_url": f"data:application/pdf;base64,{document_base64}"
    },
    document_annotation_format=response_format_from_pydantic_model(
        DetailedInvoice
    ),
    document_annotation_prompt=(
        "Ce document est une facture. Extrayez toutes les lignes "
        "de facturation avec leurs montants."
    )
)

# Extraction et validation
if ocr_response.document_annotation:
    invoice = DetailedInvoice.model_validate_json(
        ocr_response.document_annotation
    )

    print(f"Facture {invoice.number} - {invoice.supplier}")
    print(f"Date : {invoice.date}")
    print(f"\nLignes :")
    for line in invoice.lines:
        print(f"  - {line.description}: {line.quantity} x "
              f"{line.unit_price}€ = {line.amount}€")
    print(f"\nTotal TTC : {invoice.total_incl_tax}€")

Des résultats d’extraction médiocres proviennent presque toujours du schéma, rarement du modèle. Revoyez vos descriptions une par une : elles doivent être précises et sans ambiguïté, car le modèle ne s’appuie que sur elles pour comprendre vos attentes. Rédigez-les dans la langue de vos documents — le français fonctionne parfaitement pour des factures françaises — et réservez les énumérations aux champs aux valeurs limitées et les sous-modèles aux structures que vous réutiliserez dans plusieurs schémas.

Belangrijkste punten

  • Les schémas Pydantic permettent l’extraction de données typées et validées
  • Utilisez des types complexes (listes, énumérations, modèles imbriqués) pour des extractions précises
  • Le modèle gère fiablement les champs optionnels et les cases à cocher
  • Les descriptions de champs guident l’extraction : soyez précis et explicite
  • Combinez document_annotation_prompt avec le schéma pour un contexte maximal