Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Automatizované pracovné postupy a pipeline

Lekcia 12 z 12 Aktualizované 30. júla 2026 Vývojár
Na tejto strane
  1. Prechod do produkcie
  2. Pracovný postup: spracovanie dokumentov
  3. Pipeline validácie dát
  4. Architektúra viacstupňového pipeline
  5. Najlepšie postupy pre produkciu
  6. Zhrnutie kurzu
  7. Kľúčové poznatky
  8. Otestuj si svoje vedomosti

Prechod do produkcie

Predchádzajúce lekcie pokryli základy a jednotlivé prípady použitia. Táto záverečná lekcia všetko spája dohromady, aby vybudovala automatizované pracovné postupy a validačné pipeline pripravené na nasadenie do produkcie.

Pracovný postup: spracovanie dokumentov

Kompletný pipeline na automatické spracovanie prichádzajúcich 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

Pipeline validácie dát

Využi štruktúrované výstupy na validáciu a normalizáciu prichádzajúcich dát:

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]

Tento pipeline prijíma kontakty v rôznych formátoch a normalizuje ich do jednotnej štruktúry.

Architektúra viacstupňového pipeline

Tu je kostra robustného produkčného pipeline:

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

Najlepšie postupy pre produkciu

Idempotentnosť

Navrhuj svoje pipeline tak, aby bolo možné ich znovu spustiť bez vedľajších účinkov. Ten istý dokument spracovaný dvakrát musí vyprodukovať rovnaký výsledok.

Štruktúrované logovanie

Loguj každý volanie s použitou schémou, počtom tokenov a časom odozvy.

Opakovanie s exponenciálnym oneskorením (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

Monitorovanie

Sleduj tieto metriky pre každý pipeline:

  • Miera úspešnosti na každý krok
  • Priemerný čas spracovania
  • Počet spotrebovaných tokenov
  • Frekvencia využitia záložných riešení

Zhrnutie kurzu

Počas týchto 12 lekcií si sa naučil:

  • Pochopiť štruktúrované výstupy a ich záruky
  • Ovládať podporované typy a ich obmedzenia
  • Používať parse() a response_format podľa svojich potrieb
  • Definovať schémy pomocou Pydantic (Python) a Zod (JavaScript)
  • Kombinovať štruktúrované výstupy s webovým vyhľadávaním a vykonávaním kódu
  • Budovať pipeline na extrakciu, klasifikáciu a validáciu

Štruktúrované výstupy transformujú veľké jazykové modely z konverzačných nástrojov na spoľahlivé softvérové komponenty, ktoré možno integrovať do akejkoľvek architektúry.

Kľúčové poznatky

  • Viacstupňové pracovné postupy využívajú vyhradenú schému pre každý krok
  • Krížová validácia porovnáva výsledky extrakcie s referenčnými zdrojmi
  • V produkcii: idempotentnosť, štruktúrované logovanie, opakovanie s oneskorením, monitorovanie
  • Štruktúrované výstupy sú základom každého spoľahlivého AI pipeline
  • Kombinuj schémy (štruktúra) + prompty (obsah) + nástroje (dáta) pre optimálne výsledky

Otestuj si svoje vedomosti

Garantované JSON, schémy, pipeline: štruktúrovaný výstup, verzia Grok.

1. Čo garantuje štruktúrovaný výstup podľa schémy?

Odpoveď: Výstup striktne zodpovedajúci deklarovanej JSON schéme – typy, polia, štruktúra – použiteľný kódom bez obranného parsovania: formát je obmedzený už pri generovaní.

2. Čo pridáva metóda parse() v porovnaní s manuálnym response_format?

Odpoveď: Plne automatizovanú slučku: Pydantic model (alebo Zod v JS) deklaruje schému a odpoveď sa vráti už validovaná a typovaná ako objekt – žiadna zbytočná infraštruktúra navyše.

3. Prečo je dôležité poznať nepodporované typy?

Odpoveď: Pretože schéma využívajúca nepodporované konštrukcie zlyhá alebo sa degraduje: svoje modely navrhuješ v rámci akceptovanej podmnožiny a validuješ ich na výstupe.

4. Čo umožňuje kombinácia štruktúrovaných výstupov + webové vyhľadávanie alebo vykonávanie kódu?

Odpoveď: Pipeline, kde vyhľadávanie alebo výpočty napájajú štruktúrovaný výstup: čerstvé alebo vypočítané informácie prichádzajú priamo do tvojich typovaných polí.

5. Uveď dva typické prípady použitia v produkcii.

Odpoveď: Extrakcia entít a klasifikácia (dokumenty, ticketty, obsah) prepojená s tvojimi systémami – automatizované pracovné postupy, kde AI vypĺňa štruktúry, nie odseky.

Deklarovaná schéma, obmedzená generácia, validácia výstupu: štruktúrovaný výstup je rozhraním medzi Grok a tvojím softvérom – zaobchádzaj s ním ako s takým.