Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Workflows et pipelines automatisés

Lektion 12 av 12 Uppdaterad 30 juli 2026 Utvecklare
På denna sida
  1. Passage en production
  2. Workflow : traitement de documents
  3. Pipeline de validation de données
  4. Architecture de pipeline multi-étapes
  5. Bonnes pratiques de production
  6. Résumé du cours
  7. Viktiga punkter
  8. Teste tes connaissances

Passage en production

Les leçons précédentes ont couvert les bases et des cas d’usage individuels. Cette dernière leçon rassemble le tout pour construire des workflows automatisés et des pipelines de validation prêts pour la production.

Workflow : traitement de documents

Un pipeline complet pour traiter automatiquement les documents entrants :

from pydantic import BaseModel
from typing import Literal

# Step 1: Document classification
class ClassificationDocument(BaseModel):
    type: Literal["facture", "contrat", "devis", "courrier", "autre"]
    langue: str
    urgence: Literal["basse", "normale", "haute"]
    departement: Literal["comptabilite", "juridique", "commercial", "direction"]

# Step 2: Extraction by type
class DonneesFacture(BaseModel):
    numero: str
    date_emission: str
    date_echeance: str
    emetteur: str
    montant_ht: float
    montant_ttc: float
    lignes: list[dict]

# Step 3: Validation
class ResultatValidation(BaseModel):
    document_valide: bool
    champs_manquants: list[str]
    anomalies: list[str]
    score_confiance: float
    action_recommandee: str

async def traiter_document(texte: str):
    # Classify
    _, classification = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=[{"role": "user", "content": f"Classify this document: {texte}"}],
        response_format=ClassificationDocument
    )

    # Extract by type
    if classification.type == "facture":
        _, donnees = client.chat.parse(
            model="grok-4.20-0309-reasoning",
            messages=[{"role": "user", "content": f"Extract data from this invoice: {texte}"}],
            response_format=DonneesFacture
        )

    # Validate
    _, validation = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=[{
            "role": "user",
            "content": f"Validate this extracted data: {donnees.model_dump_json()}"
        }],
        response_format=ResultatValidation
    )

    return classification, donnees, validation

Pipeline de validation de données

Utilise les sorties structurées pour valider et normaliser les données entrantes :

class AdresseNormalisee(BaseModel):
    ligne_1: str
    ligne_2: str | None
    code_postal: str
    ville: str
    pays: str
    format_valide: bool

class ContactNormalise(BaseModel):
    prenom: str
    nom: str
    email_valide: bool
    telephone_normalise: str | None
    adresse: AdresseNormalisee

class ResultatNormalisation(BaseModel):
    contacts: list[ContactNormalise]
    nombre_traites: int
    nombre_erreurs: int
    erreurs: list[str]

Ce pipeline prend des contacts dans divers formats et les normalise en une structure uniforme.

Architecture de pipeline multi-étapes

Voici le squelette d’un pipeline de production robuste :

class PipelineResult(BaseModel):
    etape: str
    succes: bool
    donnees: dict
    erreurs: list[str]
    duree_ms: int

def pipeline_complet(texte: str) -> list[PipelineResult]:
    resultats = []

    # Each step uses a dedicated schema
    etapes = [
        ("extraction", SchemaExtraction, "Extract data from this text"),
        ("enrichissement", SchemaEnrichi, "Enrich this data"),
        ("validation", SchemaValidation, "Validate this data"),
        ("formatage", SchemaFinal, "Format the final result"),
    ]

    donnees_courantes = texte
    for nom, schema, instruction in etapes:
        try:
            _, parsed = client.chat.parse(
                model="grok-4.20-0309-reasoning",
                messages=[{
                    "role": "user",
                    "content": f"{instruction}: {donnees_courantes}"
                }],
                response_format=schema
            )
            resultats.append(PipelineResult(
                etape=nom, succes=True,
                donnees=parsed.model_dump(),
                erreurs=[], duree_ms=0
            ))
            donnees_courantes = parsed.model_dump_json()
        except Exception as e:
            resultats.append(PipelineResult(
                etape=nom, succes=False,
                donnees={}, erreurs=[str(e)], duree_ms=0
            ))
            break

    return resultats

Bonnes pratiques de production

Idempotence

Conçois tes pipelines pour qu’ils puissent être relancés sans effets de bord. Un même document traité deux fois doit produire le même résultat.

Journalisation structurée

Journalise chaque appel avec le schéma utilisé, le nombre de jetons et le temps de réponse.

Nouvelle tentative avec backoff

import time

def appel_avec_retry(messages, schema, max_retries=3):
    for tentative in range(max_retries):
        try:
            return client.chat.parse(
                model="grok-4.20-0309-reasoning",
                messages=messages,
                response_format=schema
            )
        except Exception as e:
            if tentative < max_retries - 1:
                time.sleep(2 ** tentative)
            else:
                raise

Surveillance

Suis ces métriques pour chaque pipeline :

  • Taux de réussite par étape
  • Temps de traitement moyen
  • Nombre de jetons consommés
  • Fréquence de recours aux solutions de repli

Résumé du cours

Au cours de ces 12 leçons, tu as appris à :

  • Comprendre les sorties structurées et leurs garanties
  • Maîtriser les types pris en charge et leurs limites
  • Utiliser parse() et response_format selon tes besoins
  • Définir des schémas avec Pydantic (Python) et Zod (JavaScript)
  • Combiner les sorties structurées avec la recherche web et l’exécution de code
  • Construire des pipelines d’extraction, de classification et de validation

Les sorties structurées transforment les LLM d’outils conversationnels en composants logiciels fiables intégrables dans n’importe quelle architecture.

Viktiga punkter

  • Les workflows multi-étapes utilisent un schéma dédié par étape
  • La validation croisée compare les résultats d’extraction à des sources de référence
  • En production : idempotence, journalisation structurée, nouvelle tentative avec backoff, surveillance
  • Les sorties structurées sont le fondement de tout pipeline IA fiable
  • Combine schémas (structure) + prompts (contenu) + outils (données) pour des résultats optimaux

Teste tes connaissances

JSON garanti, schémas, pipelines : sortie structurée, version Grok.

1. Que garantit la sortie structurée par schéma ?

Réponse : Une sortie strictement conforme au schéma JSON déclaré — types, champs, structure — utilisable par le code sans analyse défensive : le format est contraint dès la génération.

2. Qu'apporte la méthode parse() par rapport à un response_format manuel ?

Réponse : La boucle entièrement automatisée : le modèle Pydantic (ou Zod en JS) déclare le schéma, et la réponse revient déjà validée et typée sous forme d’objet — zéro code de liaison.

3. Pourquoi connaître les types non pris en charge ?

Réponse : Parce qu’un schéma utilisant des constructions non prises en charge échoue ou se dégrade : tu conçois tes modèles dans le sous-ensemble accepté et valides en sortie.

4. Que permet la combinaison sorties structurées + recherche web ou exécution de code ?

Réponse : Des pipelines où la recherche ou le calcul alimentent une sortie structurée : des informations fraîches ou calculées arrivent directement dans tes champs typés.

5. Donne deux cas d'usage typiques en production.

Réponse : L’extraction et la classification d’entités (documents, tickets, contenus) connectées à tes systèmes — des workflows automatisés où l’IA remplit des structures, pas des paragraphes.

Schéma déclaré, génération contrainte, validation de sortie : la sortie structurée est l’interface entre Grok et ton logiciel — traite-la comme telle.