Zautomatyzowane przepływy pracy i potoki danych
Na tej stronie
Wdrożenie do produkcji
Poprzednie lekcje omówiły podstawy i indywidualne przypadki użycia. Ta ostatnia lekcja scala całą wiedzę, aby zbudować zautomatyzowane przepływy pracy i potoki walidacji gotowe do środowiska produkcyjnego.
Przepływ pracy: przetwarzanie dokumentów
Kompletny potok do automatycznego przetwarzania przychodzących dokumentów:
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
Potok walidacji danych
Wykorzystaj strukturalne wyjścia do walidacji i normalizacji przychodzących danych:
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]
Ten potok przyjmuje kontakty w różnych formatach i normalizuje je do jednolitej struktury.
Architektura potoku wieloetapowego
Oto szkielet solidnego potoku produkcyjnego:
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
Najlepsze praktyki produkcyjne
Idempotentność
Projektuj swoje potoki tak, aby można je było uruchamiać wielokrotnie bez skutków ubocznych. Ten sam dokument przetworzony dwukrotnie musi dać ten sam wynik.
Ustrukturyzowane logowanie
Loguj każde wywołanie wraz z użytym schematem, liczbą tokenów i czasem odpowiedzi.
Ponawianie z wykładniczym opóźnieniem (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
Monitorowanie
Śledź następujące metryki dla każdego potoku:
- Wskaźnik sukcesu na każdym etapie
- Średni czas przetwarzania
- Liczba zużytych tokenów
- Częstotliwość uruchamiania mechanizmów awaryjnych (fallback)
Podsumowanie kursu
W ciągu tych 12 lekcji nauczyłeś się:
- Rozumieć strukturalne wyjścia i ich gwarancje
- Opanować obsługiwane typy i ich ograniczenia
- Używać
parse()iresponse_formatzgodnie ze swoimi potrzebami - Definiować schematy za pomocą Pydantic (Python) i Zod (JavaScript)
- Łączyć strukturalne wyjścia z wyszukiwaniem w sieci i wykonywaniem kodu
- Budować potoki ekstrakcji, klasyfikacji i walidacji
Strukturalne wyjścia przekształcają LLM z narzędzi konwersacyjnych w niezawodne komponenty oprogramowania, które można integrować z dowolną architekturą.
Kluczowe wnioski
- Przepływy pracy wieloetapowe wykorzystują dedykowany schemat dla każdego kroku
- Walidacja krzyżowa porównuje wyniki ekstrakcji ze źródłami referencyjnymi
- W produkcji: idempotentność, ustrukturyzowane logowanie, ponawianie z wykładniczym opóźnieniem, monitorowanie
- Strukturalne wyjścia są fundamentem każdego niezawodnego potoku AI
- Łącz schematy (struktura) + prompty (treść) + narzędzia (dane), aby uzyskać optymalne wyniki
Sprawdź swoją wiedzę
Gwarantowany JSON, schematy, potoki: strukturalne wyjście, wersja Grok.
1. Co gwarantuje strukturalne wyjście oparte na schemacie?
Odpowiedź: Wyjście ściśle zgodne z zadeklarowanym schematem JSON – typy, pola, struktura – gotowe do użycia przez kod bez konieczności defensywnego parsowania: format jest wymuszony już na etapie generowania.
2. Co dodaje metoda parse() w porównaniu do ręcznego ustawiania response_format?
Odpowiedź: W pełni zautomatyzowaną pętlę: model Pydantic (lub Zod w JS) deklaruje schemat, a odpowiedź wraca już zwalidowana i typowana jako obiekt – zero zbędnego kodu łączącego.
3. Dlaczego warto znać typy nieobsługiwane?
Odpowiedź: Ponieważ schemat wykorzystujący nieobsługiwane konstrukcje zakończy się niepowodzeniem lub ulegnie degradacji: projektujesz swoje modele w ramach akceptowalnego podzbioru i walidujesz wynik na wyjściu.
4. Na co pozwala połączenie strukturalnych wyjść z wyszukiwaniem w sieci lub wykonywaniem kodu?
Odpowiedź: Na tworzenie potoków, w których wyszukiwanie lub obliczenia zasilają strukturalne wyjście: świeże lub wyliczone informacje trafiają bezpośrednio do twoich typowanych pól.
5. Podaj dwa typowe przypadki użycia w środowisku produkcyjnym.
Odpowiedź: Ekstrakcja encji i klasyfikacja (dokumenty, zgłoszenia, treści) połączone z twoimi systemami – zautomatyzowane przepływy pracy, w których AI wypełnia struktury, a nie akapity tekstu.
Zadeklarowany schemat, ograniczone generowanie, walidacja wyjścia: strukturalne wyjście jest interfejsem między Grok a twoim oprogramowaniem – traktuj je jako takie.