Salt la conținutul principal
Română— Alege o limbă
Meniu

Flux de lucru automate și pipeline-uri de validare

Lecția 12 din 12 Actualizată 30 iulie 2026 Dezvoltator
Pe această pagină
  1. Trecerea la producție
  2. Flux de lucru: procesarea documentelor
  3. Pipeline de validare a datelor
  4. Arhitectura pipeline-ului în mai mulți pași
  5. Cele mai bune practici pentru producție
  6. Rezumatul cursului
  7. Puncte cheie
  8. Testați-vă cunoștințele

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() și response_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.