Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Extraction et validation avec des outils

Paskaita 10 iš 12 Atnaujinta 2026 m. liepos 30 d. Kūrėjas
Šiame puslapyje
  1. Construis des pipelines d’extraction fiables
  2. Modèle : extraction enrichie
  3. Modèle : validation croisée
  4. Modèle : calcul et structuration
  5. Architecture d’un pipeline robuste
  6. Gestion des erreurs en production
  7. Svarbiausi punktai

Construis des pipelines d’extraction fiables

En combinant des sorties structurées avec des outils (recherche web, exécution de code), tu peux bâtir des pipelines d’extraction et de validation robustes. Cette leçon t’explique comment architecturer ces pipelines pour un usage en production.

Modèle : extraction enrichie

Le modèle le plus courant consiste à enrichir l’extraction de données par une recherche web. Tu pars d’un texte brut, 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-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Extract and enrich the companies mentioned in this text:

        'Mistral AI announced a partnership with Scaleway to
        host its models in France. Meanwhile, Hugging Face
        continues to collaborate with OVHcloud on open source
        infrastructure.'"""
    }],
    response_format=ExtractionEnrichie,
    tools=[{"type": "web_search"}]
)

Modèle : validation croisée

La validation croisée utilise la recherche web pour vérifier les 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-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Verify the facts in this text:
        'France has 68 million inhabitants. Paris is the
        largest city in Europe. France's GDP is the 7th
        largest worldwide.'"""
    }],
    response_format=RapportValidation,
    tools=[{"type": "web_search"}]
)

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

Modèle : calcul et structuration

Combine l’exécution de code pour les calculs et des sorties structurées pour le formatage :

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-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Calculate the invoice:
        - 3x Pro License at 299 EUR excl. VAT (VAT 20%)
        - 1x Training at 1500 EUR excl. VAT (VAT 20%)
        - 12x Monthly Support at 49 EUR excl. VAT (VAT 20%)"""
    }],
    response_format=Facture,
    tools=[{"type": "code_interpreter"}]
)

print(f"Total excl. VAT: {parsed.total_ht} EUR")
print(f"Total incl. VAT: {parsed.total_ttc} EUR")

Architecture d’un pipeline robuste

Pour un usage en production, structure ton pipeline en étapes distinctes :

# Step 1: Raw extraction
class ExtractionBrute(BaseModel):
    entites: list[str]
    dates: list[str]
    montants: list[str]

# Step 2: Enrichment
class EntiteEnrichie(BaseModel):
    nom: str
    type: str
    details: str

# Step 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 simplifie le débogage et la surveillance.

Gestion des erreurs en production

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

Svarbiausi punktai

  • L’extraction enrichie combine recherche web et sorties structurées pour obtenir des données complètes
  • La validation croisée vérifie les faits grâce à la recherche web
  • L’exécution de code garantit des calculs exacts dans les pipelines financiers
  • Structure ton processus en étapes séparées pour plus de robustesse et de facilité de débogage
  • Prévois toujours une solution de repli si les outils échouent