Workflows en pijplijnen automatiseren
Op deze pagina
Naar productie gaan
De vorige lessen behandelden de basisprincipes en individuele use cases. Deze laatste les brengt alles samen om geautomatiseerde workflows en validatiepijplijnen te bouwen die klaar zijn voor productie.
Workflow: documentverwerking
Een complete pijplijn om inkomende documenten automatisch te verwerken:
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
Pijplijn voor datavalidatie
Gebruik gestructureerde uitvoer om inkomende gegevens te valideren en te normaliseren:
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]
Deze pijplijn neemt contactpersonen in verschillende formaten aan en normaliseert ze naar een uniforme structuur.
Architectuur van een meerstaps-pijplijn
Hier is het skelet van een robuuste productiepijplijn:
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
Best practices voor productie
Idempotentie
Ontwerp uw pijplijnen zo dat ze opnieuw kunnen worden uitgevoerd zonder neveneffecten. Twee keer verwerken van hetzelfde document moet hetzelfde resultaat opleveren.
Gestructureerde logging
Log elke aanroep met het gebruikte schema, het aantal tokens en de responstijd.
Opnieuw proberen met 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
Monitoring
Houd voor elke pijplijn de volgende statistieken bij:
- Slaagpercentage per stap
- Gemiddelde verwerkingstijd
- Aantal verbruikte tokens
- Frequentie van fallbacks
Samenvatting van de cursus
Tijdens deze 12 lessen heeft u geleerd om:
- Gestruceerde uitvoer en de garanties ervan te begrijpen
- Ondersteunde typen en hun limieten te beheersen
parse()enresponse_formatnaar behoefte te gebruiken- Schema’s te definiëren met Pydantic (Python) en Zod (JavaScript)
- Gestruceerde uitvoer te combineren met webzoekopdrachten en code-uitvoering
- Extractie-, classificatie- en validatiepijplijnen te bouwen
Gestructureerde uitvoer transformeert LLM’s van conversationele tools naar betrouwbare softwarecomponenten die in elke architectuur kunnen worden geïntegreerd.
Belangrijkste punten
- Meerstaps-workflows gebruiken per stap een toegewijd schema
- Kruisvalidatie vergelijkt extractieresultaten met referentiebronnen
- In productie: idempotentie, gestructureerde logging, opnieuw proberen met backoff, monitoring
- Gestruceerde uitvoer vormt de basis van elke betrouwbare AI-pijplijn
- Combineer schema’s (structuur) + prompts (inhoud) + tools (gegevens) voor optimale resultaten
Test uw kennis
Gegarandeerde JSON, schema’s, pijplijnen: gestructureerde uitvoer, Grok-versie.
1. Wat garandeert gestructureerde uitvoer via een schema?
Antwoord: Uitvoer die strikt conform het gedeclareerde JSON-schema is—typen, velden, structuur—bruikbaar door code zonder defensieve parsing: het formaat wordt al tijdens de generatie afgedwongen.
2. Wat voegt de methode parse() toe ten opzichte van handmatige response_format?
Antwoord: De volledig geautomatiseerde lus: het Pydantic-model (of Zod in JS) declareert het schema, en het antwoord komt al gevalideerd en getypt als object terug—geen extra code nodig.
3. Waarom is het belangrijk om niet-ondersteunde typen te kennen?
Antwoord: Omdat een schema dat niet-ondersteunde constructies gebruikt, faalt of degradeert: u ontwerpt uw modellen binnen de geaccepteerde subset en valideert bij de uitvoer.
4. Wat maakt de combinatie van gestructureerde uitvoer + webzoekopdrachten of code-uitvoering mogelijk?
Antwoord: Pijplijnen waarbij zoekopdrachten of berekeningen een gestructureerde uitvoer voeden: verse of berekende informatie komt direct in uw getypte velden terecht.
5. Noem twee typische use cases in productie.
Antwoord: Entiteitsextractie en classificatie (documenten, tickets, content) gekoppeld aan uw systemen—geautomatiseerde workflows waarbij AI structuren vult, geen alinea’s.
Gedeclareerd schema, afgedwongen generatie, uitvoervalidatie: gestructureerde uitvoer is de interface tussen Grok en uw software—behandel het als zodanig.