Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Arbejdsgange og pipelines til automatisering

Lektion 12 af 12 Opdateret 30. juli 2026 Udvikler
På denne side
  1. Overgang til produktion
  2. Arbejdsgang: Dokumentbehandling
  3. Pipeline til datavalidering
  4. Arkitektur for flertrins-pipelines
  5. Best practices til produktion
  6. Opsamling på kurset
  7. Vigtige pointer
  8. Test din viden

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() og response_format efter 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.