Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Pracovní postupy a pipeline automatizace

Lekce 12 z 12 Aktualizováno 30. července 2026 Vývojář
Na této stránce
  1. Nasazení do produkce
  2. Pracovní postup: zpracování dokumentů
  3. Pipeline validace dat
  4. Architektura víceúrovňové pipeline
  5. Osvědčené postupy pro produkci
  6. Shrnutí kurzu
  7. Klíčové poznatky
  8. Ověř si své znalosti

Nasazení do produkce

Předchozí lekce pokryly základy a jednotlivé příklady využití. Tato závěrečná lekce vše spojuje dohromady, abychom vybudovali automatizované pracovní postupy a validační pipeline připravené pro produkční prostředí.

Pracovní postup: zpracování dokumentů

Kompletní pipeline pro automatické zpracování příchozích dokumentů:

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 validace dat

Využij strukturované výstupy k validaci a normalizaci příchozích dat:

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]

Tato pipeline přijímá kontakty v různých formátech a normalizuje je do jednotné struktury.

Architektura víceúrovňové pipeline

Zde je kostra robustní produkční 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

Osvědčené postupy pro produkci

Idempotence

Navrhuj své pipeline tak, aby bylo možné je znovu spustit bez vedlejších účinků. Stejný dokument zpracovaný dvakrát musí vyprodukovat stejný výsledek.

Strukturované logování

Loguj každý požadavek včetně použitého schématu, počtu tokenů a doby odezvy.

Opakování s exponenciálním zpětným čekání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

Monitorování

Sleduj tyto metriky pro každou pipeline:

  • Míra úspěšnosti na jednotlivých krocích
  • Průměrná doba zpracování
  • Počet spotřebovaných tokenů
  • Frekvence využití záložních řešení

Shrnutí kurzu

Během těchto 12 lekcí ses naučil:

  • Porozumět strukturovaným výstupům a jejich zárukám
  • Ovládnout podporované typy a jejich limity
  • Používat parse() a response_format podle svých potřeb
  • Definovat schémata pomocí Pydantic (Python) a Zod (JavaScript)
  • Kombinovat strukturované výstupy s webovým vyhledáváním a prováděním kódu
  • Budovat pipeline pro extrakci, klasifikaci a validaci

Strukturované výstupy transformují velké jazykové modely z konverzačních nástrojů na spolehlivé softwarové komponenty, které lze integrovat do jakékoli architektury.

Klíčové poznatky

  • Víceúrovňové pracovní postupy využívají pro každý krok vyhrazené schéma
  • Křížová validace porovnává výsledky extrakce s referenčními zdroji
  • V produkci: idempotence, strukturované logování, opakování s backoffem, monitorování
  • Strukturované výstupy jsou základem jakékoli spolehlivé AI pipeline
  • Pro optimální výsledky kombinuj schémata (struktura) + prompty (obsah) + nástroje (data)

Ověř si své znalosti

Zaručené JSON, schémata, pipeline: strukturovaný výstup, verze Grok.

1. Co garantuje strukturovaný výstup pomocí schématu?

Odpověď: Výstup striktně odpovídající deklarovanému schématu JSON – typy, pole, struktura – použitelný kódem bez obranného parsování; formát je vynucen již při generování.

2. Co přidává metoda parse() oproti ručnímu nastavení response_format?

Odpověď: Plně automatizovanou smyčku: model Pydantic (nebo Zod v JS) deklaruje schéma a odpověď přijde již validovaná a typovaná jako objekt – nulová složitost s propojením.

3. Proč je důležité znát nepodporované typy?

Odpověď: Protože schéma využívající nepodporované konstrukce selže nebo degraduje: své modely navrhuješ v rámci akceptované podmnožiny a validaci provádíš až na výstupu.

4. Co umožňuje kombinace strukturovaných výstupů s webovým vyhledáváním nebo prováděním kódu?

Odpověď: Pipeline, kde vyhledávání nebo výpočty napájejí strukturovaný výstup: čerstvé nebo vypočtené informace přicházejí přímo do tvých typovaných polí.

5. Uveď dva typické příklady využití v produkci.

Odpověď: Extrakce entit a klasifikace (dokumenty, tickety, obsah) propojené s tvými systémy – automatizované pracovní postupy, kde AI vyplňuje struktury, nikoli odstavce.

Deklarované schéma, řízené generování, validace výstupu: strukturovaný výstup je rozhraním mezi Grok a tvým softwarem – zacházej s ním jako s takovým.