Arbejdsgange og pipelines til automatisering
På denne side
Overgang til produktion
De tidligere lektioner har dækket grundprincipperne og individuelle brugstilfælde. Denne sidste lektion samler det hele for at opbygge automatiserede arbejdsgange og valideringspipelines, der er klar til produktion.
Arbejdsgang: Dokumentbehandling
En komplet pipeline til automatisk behandling af indkommende dokumenter:
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 til datavalidering
Brug strukturerede outputs til at validere og normalisere indkommende data:
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]
Denne pipeline tager kontakter i forskellige formater og normaliserer dem til en ensartet struktur.
Arkitektur for flertrins-pipelines
Her er skelettet til en robust produktionspipeline:
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 til produktion
Idempotens
Design dine pipelines, så de kan køres igen uden bivirkninger. Det samme dokument bearbejdet to gange skal give det samme resultat.
Struktureret logning
Log hvert opkald med det anvendte skema, antal tokens og svartid.
Genforsøg med 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
Overvågning
Følg disse nøgletal for hver pipeline:
- Succesrate pr. trin
- Gennemsnitlig behandlingstid
- Antal forbrugte tokens
- Hyppighed af fallback-løsninger
Opsamling på kurset
I løbet af disse 12 lektioner har du lært at:
- Forstå strukturerede outputs og deres garantier
- Beherske understøttede typer og deres begrænsninger
- Bruge
parse()ogresponse_formatefter dine behov - Definere skemaer med Pydantic (Python) og Zod (JavaScript)
- Kombinere strukturerede outputs med websøgning og kodeeksekvering
- Opbygge pipelines til udtræk, klassificering og validering
Strukturerede outputs transformerer LLM’er fra samtaleværktøjer til pålidelige softwarekomponenter, der kan integreres i enhver arkitektur.
Vigtige pointer
- Flertrins-arbejdsgange bruger et dedikeret skema pr. trin
- Krydsvalidering sammenligner udtræksresultater med referencekilder
- I produktion: idempotens, struktureret logning, genforsøg med backoff, overvågning
- Strukturerede outputs er fundamentet for enhver pålidelig AI-pipeline
- Kombiner skemaer (struktur) + prompts (indhold) + værktøjer (data) for optimale resultater
Test din viden
Garanteret JSON, skemaer, pipelines: struktureret output, Grok-version.
1. Hvad garanterer struktureret output via skema?
Svar: Output, der strengt overholder det erklærede JSON-skema – typer, felter, struktur – som kan bruges af kode uden defensiv parsing: formatet er begrænset under genereringen.
2. Hvad tilføjer metoden parse() sammenlignet med manuel response_format?
Svar: Den fuldt automatiserede løkke: Pydantic-modellen (eller Zod i JS) erklærer skemaet, og svaret kommer tilbage allerede valideret og typet som et objekt – nul rørleggerarbejde.
3. Hvorfor er det vigtigt at kende til ikke-understøttede typer?
Svar: Fordi et skema, der bruger ikke-understøttede konstruktioner, vil fejle eller forringes: du designer dine modeller inden for den accepterede delmængde og validerer ved output.
4. Hvad muliggør kombinationen af strukturerede outputs + websøgning eller kodeeksekvering?
Svar: Pipelines, hvor søgning eller beregning fodrer et struktureret output: friske eller beregnede oplysninger lander direkte i dine typede felter.
5. Nævn to typiske brugstilfælde i produktion.
Svar: Udtræk og klassificering af enheder (dokumenter, tickets, indhold) koblet til dine systemer – automatiserede arbejdsgange, hvor AI udfylder strukturer, ikke afsnit.
Erklæret skema, begrænset generering, output-validering: struktureret output er grænsefladen mellem Grok og din software – behandl det derefter.