Extraction et validation avec outils

Construire des pipelines d’extraction fiables

En combinant les sorties structurées avec les outils (web search, code execution), vous pouvez construire des pipelines d’extraction et de validation robustes. Cette leçon montre comment architecturer ces pipelines pour un usage en production.

Pattern : extraction enrichie

Le pattern le plus courant est l’extraction de données enrichie par la recherche web. Vous partez d’un texte brut, et le modèle extrait les entités puis les enrichit avec des informations trouvées en ligne.

from pydantic import BaseModel

class EntrepriseEnrichie(BaseModel):
    nom: str
    secteur: str
    pays_siege: str
    site_web: str | None
    description_courte: str
    nombre_employes_estime: str | None
    technologies_utilisees: list[str]

class ExtractionEnrichie(BaseModel):
    entreprises: list[EntrepriseEnrichie]
    relations: list[str]
    contexte: str

response, parsed = client.chat.parse(
    model="grok-4.20-reasoning",
    messages=[{
        "role": "user",
        "content": """Extrais et enrichis les entreprises mentionnées dans ce texte :

        'Mistral AI a annoncé un partenariat avec Scaleway pour
        héberger ses modèles en France. De son côté, Hugging Face
        continue de collaborer avec OVHcloud sur l'infrastructure
        open source.'"""
    }],
    response_format=ExtractionEnrichie,
    tools=[{"type": "web_search"}]
)

Pattern : validation croisée

La validation croisée utilise la recherche web pour vérifier des informations extraites d’un document :

class FactCheck(BaseModel):
    affirmation: str
    verifie: bool
    source: str | None
    correction: str | None
    confiance: float

class RapportValidation(BaseModel):
    document_original: str
    verifications: list[FactCheck]
    fiabilite_globale: float
    resume: str

response, parsed = client.chat.parse(
    model="grok-4.20-reasoning",
    messages=[{
        "role": "user",
        "content": """Vérifie les faits dans ce texte :
        'La France compte 68 millions d'habitants. Paris est la
        plus grande ville d'Europe. Le PIB français est le 7ème
        mondial.'"""
    }],
    response_format=RapportValidation,
    tools=[{"type": "web_search"}]
)

for v in parsed.verifications:
    status = "Vrai" if v.verifie else "Faux"
    print(f"[{status}] {v.affirmation}")
    if v.correction:
        print(f"  → Correction : {v.correction}")

Pattern : calcul et structuration

Combinez code execution pour les calculs et structured outputs pour la mise en forme :

class LigneFacture(BaseModel):
    description: str
    quantite: int
    prix_unitaire_ht: float
    montant_ht: float
    tva: float
    montant_ttc: float

class Facture(BaseModel):
    lignes: list[LigneFacture]
    total_ht: float
    total_tva: float
    total_ttc: float

response, parsed = client.chat.parse(
    model="grok-4.20-reasoning",
    messages=[{
        "role": "user",
        "content": """Calcule la facture :
        - 3x Licence Pro à 299 EUR HT (TVA 20%)
        - 1x Formation à 1500 EUR HT (TVA 20%)
        - 12x Support mensuel à 49 EUR HT (TVA 20%)"""
    }],
    response_format=Facture,
    tools=[{"type": "code_execution"}]
)

print(f"Total HT : {parsed.total_ht} EUR")
print(f"Total TTC : {parsed.total_ttc} EUR")

Architecture d’un pipeline robuste

Pour un usage en production, structurez votre pipeline en étapes :

# Étape 1 : Extraction brute
class ExtractionBrute(BaseModel):
    entites: list[str]
    dates: list[str]
    montants: list[str]

# Étape 2 : Enrichissement
class EntiteEnrichie(BaseModel):
    nom: str
    type: str
    details: str

# Étape 3 : Validation
class ResultatValide(BaseModel):
    entites: list[EntiteEnrichie]
    score_qualite: float
    alertes: list[str]

Chaque étape utilise un appel séparé avec un schéma adapté. Cette approche modulaire facilite le débogage et le monitoring.

Gestion des erreurs en production

try:
    response, parsed = client.chat.parse(
        model="grok-4.20-reasoning",
        messages=messages,
        response_format=MonSchema,
        tools=[{"type": "web_search"}]
    )
except Exception as e:
    # Fallback sans web search
    response, parsed = client.chat.parse(
        model="grok-4.20-reasoning",
        messages=messages,
        response_format=MonSchema
    )

Points clés à retenir

• L’extraction enrichie combine web search + structured outputs pour des données complètes
• La validation croisée vérifie les faits avec la recherche web
• Code execution garantit des calculs exacts dans les pipelines financiers
• Structurez en étapes séparées pour la robustesse et le débogage
• Prévoyez toujours un fallback en cas d’échec des outils