Pracovní postupy a pipeline automatizace
Na této stránce
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()aresponse_formatpodle 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.