Flux de lucru automate și pipeline-uri de validare
Pe această pagină
Trecerea la producție
Lecțiile anterioare au acoperit noțiunile de bază și cazurile de utilizare individuale. Această ultimă lecție reunește toate elementele pentru a construi fluxuri de lucru automate și pipeline-uri de validare pregătite pentru producție.
Flux de lucru: procesarea documentelor
Un pipeline complet pentru procesarea automată a documentelor primite:
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 de validare a datelor
Utilizați ieșirile structurate pentru a valida și normaliza datele primite:
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]
Acest pipeline preia contacte în diverse formate și le normalizează într-o structură uniformă.
Arhitectura pipeline-ului în mai mulți pași
Iată scheletul unui pipeline robust pentru producție:
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
Cele mai bune practici pentru producție
Idempotență
Proiectați pipeline-urile astfel încât să poată fi rulate din nou fără efecte secundare. Același document procesat de două ori trebuie să producă același rezultat.
Jurnalizare structurată
Înregistrați fiecare apel cu schema utilizată, numărul de tokeni și timpul de răspuns.
Reîncercare cu backoff exponențial
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
Monitorizare
Urmăriți acești indicatori pentru fiecare pipeline:
- Rata de succes pe fiecare etapă
- Timpul mediu de procesare
- Numărul de tokeni consumați
- Frecvența mecanismelor de fallback
Rezumatul cursului
De-a lungul acestor 12 lecții, ați învățat să:
- Înțelegeți ieșirile structurate și garanțiile lor
- Stăpâniți tipurile suportate și limitele acestora
- Utilizați
parse()șiresponse_formatîn funcție de nevoile dumneavoastră - Definiți scheme cu Pydantic (Python) și Zod (JavaScript)
- Combinați ieșirile structurate cu căutarea pe web și executarea de cod
- Construiți pipeline-uri de extragere, clasificare și validare
Ieșirile structurate transformă LLM-urile din instrumente conversaționale în componente software fiabile, integrabile în orice arhitectură.
Puncte cheie
- Fluxurile de lucru în mai mulți pași utilizează o schemă dedicată pentru fiecare etapă
- Validarea încrucișată compară rezultatele extragerii cu surse de referință
- În producție: idempotență, jurnalizare structurată, reîncercare cu backoff, monitorizare
- Ieșirile structurate stau la baza oricărui pipeline de IA fiabil
- Combinați schemele (structură) + prompturile (conținut) + instrumentele (date) pentru rezultate optime
Testați-vă cunoștințele
JSON garantat, scheme, pipeline-uri: ieșire structurată, versiune Grok.
1. Ce garantează ieșirea structurată prin schemă?
Răspuns: O ieșire strict conformă cu schema JSON declarată – tipuri, câmpuri, structură – utilizabilă direct de cod fără analiză defensivă: formatul este constrâns chiar la generare.
2. Ce aduce metoda parse() față de response_format manual?
Răspuns: Bucla complet automatizată: modelul Pydantic (sau Zod în JS) declară schema, iar răspunsul revine deja validat și tipizat ca obiect – zero cod boilerplate.
3. De ce este important să cunoașteți tipurile nesuportate?
Răspuns: Pentru că o schemă care utilizează construcții nesuportate va eșua sau se va degrada: trebuie să vă proiectați modelele în cadrul subsetului acceptat și să validați la ieșire.
4. Ce permite combinarea ieșirilor structurate cu căutarea pe web sau executarea de cod?
Răspuns: Pipeline-uri în care căutarea sau calculul alimentează o ieșire structurată: informațiile proaspete sau calculate ajung direct în câmpurile dumneavoastră tipizate.
5. Menționați două cazuri de utilizare tipice în producție.
Răspuns: Extragerea entităților și clasificarea (documente, tichete, conținut) conectate la sistemele dumneavoastră – fluxuri de lucru automate în care IA completează structuri, nu paragrafe.
Schemă declarată, generare constrânsă, validarea ieșirii: ieșirea structurată este interfața dintre Grok și software-ul dumneavoastră – tratați-o ca atare.