Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Workflows en pijplijnen automatiseren

Les 12 van 12 Bijgewerkt op 30 juli 2026 Ontwikkelaar
Op deze pagina
  1. Naar productie gaan
  2. Workflow: documentverwerking
  3. Pijplijn voor datavalidatie
  4. Architectuur van een meerstaps-pijplijn
  5. Best practices voor productie
  6. Samenvatting van de cursus
  7. Belangrijkste punten
  8. Test uw kennis

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() en response_format naar 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.