Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Delovni tokovi in cevovodi avtomatizacije

Lekcija 12 od 12 Posodobljeno 30. julij 2026 Razvijalec
Na tej strani
  1. Prehod v proizvodno okolje
  2. Delovni tok: obdelava dokumentov
  3. Cevovod za validacijo podatkov
  4. Arhitektura večstopenjskega cevovoda
  5. Najboljše prakse za proizvodno okolje
  6. Povzetek tečaja
  7. Ključne ugotovitve
  8. Preveri svoje znanje

Prehod v proizvodno okolje

Prejšnje lekcije so pokrile osnove in posamezne primere uporabe. Ta zadnja lekcija vse poveže v celoto, da bi zgradil avtomatizirane delovne tokove in validacijske cevovode, pripravljene za proizvodno uporabo.

Delovni tok: obdelava dokumentov

Popoln cevovod za samodejno obdelavo dohodnih dokumentov:

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

Cevovod za validacijo podatkov

Uporabi strukturirane izhode za validacijo in normalizacijo dohodnih podatkov:

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]

Ta cevovod prevzame stike v različnih formatih in jih normalizira v enotno strukturo.

Arhitektura večstopenjskega cevovoda

Tukaj je ogrodje robustnega proizvodnega cevovoda:

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

Najboljše prakse za proizvodno okolje

Idempotentnost

Svoje cevovode zasnuj tako, da jih lahko ponovno zaženeš brez stranskih učinkov. Isti dokument, obdelan dvakrat, mora proizvesti enak rezultat.

Strukturirano beleženje dogodkov

Zabeleži vsak klic z uporabljeno shemo, številom žetonov in časom odziva.

Ponovni poskusi z eksponentnim zamikom

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

Nadzor

Sledi tem metrikam za vsak cevovod:

  • Stopnja uspešnosti na korak
  • Povprečni čas obdelave
  • Število porabljenih žetonov
  • Pogostost uporabe nadomestnih rešitev

Povzetek tečaja

V teh 12 lekcijah si se naučil:

  • Razumeti strukturirane izhode in njihova jamstva
  • Obvladati podprte tipe in njihove omejitve
  • Uporabljati parse() in response_format glede na svoje potrebe
  • Definirati sheme s Pydantic (Python) in Zod (JavaScript)
  • Kombinirati strukturirane izhode z iskanjem po spletu in izvajanjem kode
  • Zgraditi cevovode za ekstrakcijo, klasifikacijo in validacijo

Strukturirani izhodi preoblikujejo velike jezikovne modele iz pogovornih orodij v zanesljive programske komponente, integrabilne v katero koli arhitekturo.

Ključne ugotovitve

  • Večstopenjski delovni tokovi uporabljajo namensko shemo za vsak korak
  • Navzkrižna validacija primerja rezultate ekstrakcije z referenčnimi viri
  • V proizvodnji: idempotentnost, strukturirano beleženje dogodkov, ponovni poskusi z eksponentnim zamikom, nadzor
  • Strukturirani izhodi so temelj vsakega zanesljivega cevovoda umetne inteligence
  • Združi sheme (struktura) + pozive (vsebina) + orodja (podatki) za optimalne rezultate

Preveri svoje znanje

Zagotovljen JSON, sheme, cevovodi: strukturirani izhod, različica Grok.

1. Kaj zagotavlja strukturirani izhod po shemi?

Odgovor: Izhod, ki je strogo skladen z deklarirano shemo JSON – tipi, polja, struktura – uporaben za kodo brez obrambnega razčlenjevanja: format je omejen že med generiranjem.

2. Kaj metoda parse() doda v primerjavi z ročnim response_format?

Odgovor: Popolnoma avtomatizirano zanko: model Pydantic (ali Zod v JS) deklarira shemo, odgovor pa se vrne že validiran in tipiziran kot objekt – brez dodatne kode za povezovanje.

3. Zakaj je pomembno poznati nepodprte tipe?

Odgovor: Ker shema, ki uporablja nepodprte konstrukte, odpove ali se poslabša: svoje modele zasnuješ znotraj sprejetega podmnožice in validiraš na izhodu.

4. Kaj omogoča kombinacija strukturiranih izhodov + iskanje po spletu ali izvajanje kode?

Odgovor: Cevovode, kjer iskanje ali izračun napajata strukturirani izhod: sveže ali izračunane informacije prispejo neposredno v tvoja tipizirana polja.

5. Navedi dva tipična primera uporabe v proizvodnji.

Odgovor: Ekstrakcija entitet in klasifikacija (dokumenti, zahtevki, vsebina), povezana s tvojimi sistemi – avtomatizirani delovni tokovi, kjer AI polni strukture, ne odstavkov.

Deklarirana shema, omejeno generiranje, validacija izhoda: strukturirani izhod je vmesnik med Grokom in tvojo programsko opremo – obravnavaj ga kot takega.