Workflows et pipelines automatisés
Na ovoj stranici
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 dans 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. Le 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()etresponse_formatselon 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.
Ključne točke
- 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 à 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 comme un objet – zéro tuyauterie.
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 : Extraction et 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.