Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Cas d'utilisation des annotations

Paskaita 12 iš 16 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Des annotations pour chaque rôle
  2. Trier avant de traiter
  3. Lire un contrat comme un avocat
  4. Vérifier automatiquement la conformité
  5. Ne rien perdre avant l’indexation
  6. Svarbiausi punktai

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

Des annotations pour chaque rôle

Les annotations Document AI transforment des documents non structurés en données exploitables. Le mécanisme reste toujours identique — un schéma, une invite, un appel — mais ce que tu extrais change radicalement selon le rôle. Cette leçon explore quatre implémentations concrètes : la classification en amont d’un pipeline, l’analyse de clauses contractuelles, les vérifications de conformité réglementaire et l’enrichissement d’un index RAG.

Trier avant de traiter

Dans un flux de travail réel, les documents arrivent mélangés : une facture, un bon de commande, une pièce d’identité, une lettre. Avant d’appliquer le schéma d’extraction approprié, tu dois savoir à quoi tu as affaire. L’annotation sert d’étape de tri initiale. L’énumération TypeDocument verrouille les catégories admissibles, le score de confiance te permet d’aiguiller tout élément en dessous d’un seuil vers une revue humaine, et le résumé en une phrase donne aux opérateurs assez de contexte pour décider sans ouvrir le fichier.

import os
from enum import Enum
from pydantic import BaseModel, Field
from mistralai.client import Mistral
from mistralai.extra import response_format_from_pydantic_model

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

class TypeDocument(str, Enum):
    INVOICE = "facture"
    PURCHASE_ORDER = "bon_commande"
    CONTRACT = "contrat"
    REPORT = "rapport"
    LETTER = "courrier"
    FORM = "formulaire"
    ID_DOCUMENT = "piece_identite"
    OTHER = "autre"

class Classification(BaseModel):
    document_type: TypeDocument = Field(
        ..., description="Identified document type"
    )
    confidence: float = Field(
        ..., description="Confidence score between 0 and 1"
    )
    language: str = Field(
        ..., description="Primary language (ISO 639-1 code)"
    )
    summary: str = Field(
        ..., description="One-sentence summary of the content"
    )

def classify_document(document_base64: str) -> Classification:
    """Classifie automatiquement un document."""
    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(
            Classification
        ),
        document_annotation_prompt=(
            "Identify the type of this document and provide "
            "a summary of its content."
        )
    )

    if response.document_annotation:
        return Classification.model_validate_json(
            response.document_annotation
        )

    raise ValueError("No annotation returned")

Lire un contrat comme un avocat

L’analyse contractuelle est un cas d’usage majeur dans les domaines juridique et financier, et c’est là que les schémas imbriqués brillent vraiment. Chaque Clause porte son titre, un résumé de son contenu, sa catégorie — confidentialité, résiliation, non-concurrence, responsabilité, paiement — et une évaluation des risques sur trois niveaux. Le contrat lui-même agrège ces clauses ainsi que les parties, la date de signature, la durée, le montant et la juridiction applicable. Sur un portefeuille de deux cents contrats fournisseurs, tu obtiens en quelques heures une cartographie que personne n’aurait eu le temps de produire manuellement.

Le champ risk mérite un avertissement : il s’agit d’une évaluation produite par un modèle, utile pour prioriser la revue d’un avocat, mais jamais pour la remplacer.

from pydantic import BaseModel, Field
from typing import Optional

class Clause(BaseModel):
    title: str = Field(..., description="Title or number of the clause")
    content: str = Field(..., description="Summary of the clause content")
    clause_type: str = Field(
        ..., description="Type: confidentiality, termination, "
        "non-compete, liability, payment, other"
    )
    risk: str = Field(
        ..., description="Risk level: low, medium, high"
    )

class ContractAnalysis(BaseModel):
    parts: list[str] = Field(
        ..., description="Names of the contracting parts"
    )
    signature_date: Optional[str] = Field(
        None, description="Signature date (YYYY-MM-DD)"
    )
    duration: Optional[str] = Field(
        None, description="Contract duration"
    )
    key_clauses: list[Clause] = Field(
        ..., description="Identified main clauses"
    )
    amount: Optional[float] = Field(
        None, description="Total amount if mentioned"
    )
    jurisdiction: Optional[str] = Field(
        None, description="Applicable jurisdiction"
    )

def analyze_contract(document_base64: str) -> ContractAnalysis:
    """Analyse un contrat et extrait les clauses principales."""
    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(
            ContractAnalysis
        ),
        document_annotation_prompt=(
            "Analyze this commercial contract. Identify the parts, "
            "the main clauses, and evaluate the risk level "
            "of each clause."
        )
    )

    if response.document_annotation:
        return ContractAnalysis.model_validate_json(
            response.document_annotation
        )

    raise ValueError("No annotation returned")

Vérifier automatiquement la conformité

Le contrôle réglementaire est particulièrement adapté à l’annotation car les critères sont écrits noir sur blanc dans la loi. Pour une facture française, l’invite liste les obligations à vérifier — mentions obligatoires (SIRET, TVA intracommunautaire, conditions de paiement, pénalités de retard), formatage des montants, date d’émission — et le schéma impose, pour chaque critère, un verdict booléen accompagné de sa justification. Tu récupères un score global et des recommandations d’amélioration, ce qui suffit à bloquer une facture non conforme avant qu’elle n’entre dans le circuit de paiement.

from pydantic import BaseModel, Field

class CompliancePoint(BaseModel):
    criterion: str = Field(..., description="Compliance criterion checked")
    compliant: bool = Field(..., description="True if compliant, False otherwise")
    justification: str = Field(
        ..., description="Explanation of compliance or non-compliance"
    )

class ComplianceAudit(BaseModel):
    document_type: str = Field(..., description="Type of document audited")
    compliance_points: list[CompliancePoint] = Field(
        ..., description="Compliance points checked"
    )
    global_score: float = Field(
        ..., description="Global compliance score (0-100)"
    )
    recommendations: list[str] = Field(
        ..., description="Improvement recommendations"
    )

def audit_invoice_compliance(document_base64: str) -> ComplianceAudit:
    """Vérifie la conformité d'une facture selon les règles françaises."""
    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(
            ComplianceAudit
        ),
        document_annotation_prompt=(
            "Verify the compliance of this invoice according to "
            "French legal obligations: mandatory mentions "
            "(SIRET, intra-community VAT, payment terms, "
            "late payment penalties), amount formatting, issue date."
        )
    )

    if response.document_annotation:
        return ComplianceAudit.model_validate_json(
            response.document_annotation
        )

    raise ValueError("No annotation returned")

Ne rien perdre avant l’indexation

Un dernier cas d’usage, plus discret mais décisif : préparer le contenu pour un index RAG. Un index construit uniquement sur du Markdown perd tout ce qui était visuel, et tes recherches ne trouveront jamais le graphique qui contenait le chiffre clé. La fonction ci-dessous recompose, page par page, le texte et la description de chaque image, puis ajoute les métadonnées extraites du document, le tout dans un bloc unique prêt à être découpé en chunks.

def enrich_for_rag(ocr_response) -> str:
    """Enrichit le contenu OCR avec des annotations pour le RAG."""
    parts = []

    for page in ocr_response.pages:
        # Contenu textuel
        parts.append(page.markdown)

        # Annotations d'image (remplacer les images par leur description)
        for image in page.images:
            if image.image_annotation:
                parts.append(
                    f"[Description of {image.id}]: {image.image_annotation}"
                )

    # Annotation de document : une seule, portée par la réponse
    if ocr_response.document_annotation:
        parts.append(
            f"[Extracted Metadata]: {ocr_response.document_annotation}"
        )

    return "\n\n".join(parts)

En ajoutant les descriptions d’images et les métadonnées extraites au contenu indexé, tu ne perds aucune information du document original. Tu remarqueras que ces quatre scénarios partagent la même ossature : ce qui les distingue, c’est le schéma et l’invite, pas le code d’appel.

Svarbiausi punktai

  • La classification automatique aiguille les documents vers le bon pipeline de traitement
  • L’extraction de clauses contractuelles identifie les risques et les points clés
  • La vérification de conformité automatise les audits réglementaires
  • L’enrichissement par annotation améliore la qualité de l’indexation RAG
  • Chaque cas d’usage se résume à un schéma Pydantic bien conçu et une invite adaptée