Cas d'usage des annotations

Des annotations pour chaque métier

Les annotations Document AI transforment des documents non structurés en données exploitables. Dans cette leçon, vous découvrirez des implémentations concrètes pour la classification de documents, l’extraction de clauses contractuelles et la conformité réglementaire.

Classification automatique de documents

Avant de traiter un document, il faut souvent identifier son type. Utilisez les annotations pour classifier automatiquement :

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

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

class TypeDocument(str, Enum):
    FACTURE = "facture"
    BON_COMMANDE = "bon_commande"
    CONTRAT = "contrat"
    RAPPORT = "rapport"
    COURRIER = "courrier"
    FORMULAIRE = "formulaire"
    PIECE_IDENTITE = "piece_identite"
    AUTRE = "autre"

class Classification(BaseModel):
    type_document: TypeDocument = Field(
        ..., description="Type du document identifié"
    )
    confiance: float = Field(
        ..., description="Score de confiance entre 0 et 1"
    )
    langue: str = Field(
        ..., description="Langue principale (code ISO 639-1)"
    )
    resume: str = Field(
        ..., description="Résumé en une phrase du contenu"
    )

def classifier_document(document_base64: str) -> Classification:
    """Classifie automatiquement un document."""
    response = client.ocr.process(
        model="mistral-ocr-latest",
        document={
            "type": "document_base64",
            "document_base64": document_base64
        },
        document_annotation_format=response_format_from_pydantic_model(
            Classification
        ),
        document_annotation_prompt=(
            "Identifie le type de ce document et fournis "
            "un résumé de son contenu."
        )
    )

    for page in response.pages:
        if page.document_annotation:
            return Classification.model_validate_json(
                page.document_annotation
            )

    raise ValueError("Aucune annotation retournée")

Extraction de clauses contractuelles

L’analyse de contrats est un cas d’usage majeur en juridique et en finance :

from pydantic import BaseModel, Field
from typing import Optional

class Clause(BaseModel):
    titre: str = Field(..., description="Titre ou numéro de la clause")
    contenu: str = Field(..., description="Résumé du contenu de la clause")
    type_clause: str = Field(
        ..., description="Type: confidentialite, resiliation, "
        "non-concurrence, responsabilite, paiement, autre"
    )
    risque: str = Field(
        ..., description="Niveau de risque: faible, moyen, eleve"
    )

class AnalyseContrat(BaseModel):
    parties: list[str] = Field(
        ..., description="Noms des parties contractantes"
    )
    date_signature: Optional[str] = Field(
        None, description="Date de signature (YYYY-MM-DD)"
    )
    duree: Optional[str] = Field(
        None, description="Durée du contrat"
    )
    clauses_cles: list[Clause] = Field(
        ..., description="Clauses principales identifiées"
    )
    montant: Optional[float] = Field(
        None, description="Montant total si mentionné"
    )
    juridiction: Optional[str] = Field(
        None, description="Juridiction applicable"
    )

def analyser_contrat(document_base64: str) -> AnalyseContrat:
    """Analyse un contrat et extrait les clauses principales."""
    response = client.ocr.process(
        model="mistral-ocr-latest",
        document={
            "type": "document_base64",
            "document_base64": document_base64
        },
        document_annotation_format=response_format_from_pydantic_model(
            AnalyseContrat
        ),
        document_annotation_prompt=(
            "Analyse ce contrat commercial. Identifie les parties, "
            "les clauses principales et évalue le niveau de risque "
            "de chaque clause."
        )
    )

    for page in response.pages:
        if page.document_annotation:
            return AnalyseContrat.model_validate_json(
                page.document_annotation
            )

    raise ValueError("Aucune annotation retournée")

Vérification de conformité

Automatisez les vérifications de conformité réglementaire :

from pydantic import BaseModel, Field

class PointConformite(BaseModel):
    critere: str = Field(..., description="Critère de conformité vérifié")
    conforme: bool = Field(..., description="True si conforme, False sinon")
    justification: str = Field(
        ..., description="Explication de la conformité ou non-conformité"
    )

class AuditConformite(BaseModel):
    type_document: str = Field(..., description="Type de document audité")
    points_conformite: list[PointConformite] = Field(
        ..., description="Points de conformité vérifiés"
    )
    score_global: float = Field(
        ..., description="Score de conformité global (0-100)"
    )
    recommandations: list[str] = Field(
        ..., description="Recommandations d'amélioration"
    )

def audit_conformite_facture(document_base64: str) -> AuditConformite:
    """Vérifie la conformité d'une facture selon les règles françaises."""
    response = client.ocr.process(
        model="mistral-ocr-latest",
        document={
            "type": "document_base64",
            "document_base64": document_base64
        },
        document_annotation_format=response_format_from_pydantic_model(
            AuditConformite
        ),
        document_annotation_prompt=(
            "Vérifie la conformité de cette facture selon les "
            "obligations légales françaises : mentions obligatoires "
            "(SIRET, TVA intracommunautaire, conditions de paiement, "
            "pénalités de retard), format des montants, date d'émission."
        )
    )

    for page in response.pages:
        if page.document_annotation:
            return AuditConformite.model_validate_json(
                page.document_annotation
            )

    raise ValueError("Aucune annotation retournée")

Enrichissement pour RAG

Les annotations permettent d’enrichir vos documents avant l’indexation RAG :

def enrichir_pour_rag(ocr_response) -> str:
    """Enrichit le contenu OCR avec les annotations pour le RAG."""
    parties = []

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

        # Annotations des images (remplace les images par leur description)
        for image in page.images:
            if image.annotation:
                parties.append(
                    f"[Description de {image.id}]: {image.annotation}"
                )

        # Annotation du document
        if page.document_annotation:
            parties.append(
                f"[Métadonnées extraites]: {page.document_annotation}"
            )

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

En ajoutant les descriptions d’images et les métadonnées extraites au contenu indexé, vous ne perdez aucune information du document original.

Points clés à retenir

• La classification automatique oriente 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 annotations améliore la qualité de l’indexation RAG
• Chaque cas d’usage se résume à un schéma Pydantic bien conçu et un prompt adapté