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

Extracție și validare cu instrumente

Lecția 10 din 12 Actualizată 30 iulie 2026 Dezvoltator
Pe această pagină
  1. Construirea unor fluxuri de extracție fiabile
  2. Model: extracție îmbogățită
  3. Model: validare încrucișată
  4. Model: calcul și structurare
  5. Arhitectura unui flux robust
  6. Gestionarea erorilor în producție
  7. Puncte cheie

Construirea unor fluxuri de extracție fiabile

Prin combinarea ieșirilor structurate cu instrumente (căutare web, executare de cod), puteți construi fluxuri robuste de extracție și validare. Această lecție vă arată cum să arhitecturați aceste fluxuri pentru utilizarea în producție.

Model: extracție îmbogățită

Cel mai comun model este îmbogățirea extracției de date cu căutarea pe web. Pornești de la un text brut, iar modelul extrage entitățile, apoi le îmbogățește cu informații găsite online.

from pydantic import BaseModel

class EntrepriseEnrichie(BaseModel):
    nom: str
    secteur: str
    pays_siege: str
    site_web: str | None
    description_courte: str
    nombre_employes_estime: str | None
    technologies_utilisees: list[str]

class ExtractionEnrichie(BaseModel):
    entreprises: list[EntrepriseEnrichie]
    relations: list[str]
    contexte: str

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Extract and enrich the companies mentioned in this text:

        'Mistral AI announced a partnership with Scaleway to
        host its models in France. Meanwhile, Hugging Face
        continues to collaborate with OVHcloud on open source
        infrastructure.'"""
    }],
    response_format=ExtractionEnrichie,
    tools=[{"type": "web_search"}]
)

Model: validare încrucișată

Validarea încrucișată utilizează căutarea pe web pentru a verifica informațiile extrase dintr-un document:

class FactCheck(BaseModel):
    affirmation: str
    verifie: bool
    source: str | None
    correction: str | None
    confiance: float

class RapportValidation(BaseModel):
    document_original: str
    verifications: list[FactCheck]
    fiabilite_globale: float
    resume: str

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Verify the facts in this text:
        'France has 68 million inhabitants. Paris is the
        largest city in Europe. France's GDP is the 7th
        largest worldwide.'"""
    }],
    response_format=RapportValidation,
    tools=[{"type": "web_search"}]
)

for v in parsed.verifications:
    status = "Verified" if v.verifie else "Unverified"
    print(f"[{status}] {v.affirmation}")
    if v.correction:
        print(f"  → Correction: {v.correction}")

Model: calcul și structurare

Combinați executarea de cod pentru calcule și ieșirile structurate pentru formatare:

class LigneFacture(BaseModel):
    description: str
    quantite: int
    prix_unitaire_ht: float
    montant_ht: float
    tva: float
    montant_ttc: float

class Facture(BaseModel):
    lignes: list[LigneFacture]
    total_ht: float
    total_tva: float
    total_ttc: float

response, parsed = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": """Calculate the invoice:
        - 3x Pro License at 299 EUR excl. VAT (VAT 20%)
        - 1x Training at 1500 EUR excl. VAT (VAT 20%)
        - 12x Monthly Support at 49 EUR excl. VAT (VAT 20%)"""
    }],
    response_format=Facture,
    tools=[{"type": "code_interpreter"}]
)

print(f"Total excl. VAT: {parsed.total_ht} EUR")
print(f"Total incl. VAT: {parsed.total_ttc} EUR")

Arhitectura unui flux robust

Pentru utilizarea în producție, structurați fluxul în pași distincți:

# Step 1: Raw extraction
class ExtractionBrute(BaseModel):
    entites: list[str]
    dates: list[str]
    montants: list[str]

# Step 2: Enrichment
class EntiteEnrichie(BaseModel):
    nom: str
    type: str
    details: str

# Step 3: Validation
class ResultatValide(BaseModel):
    entites: list[EntiteEnrichie]
    score_qualite: float
    alertes: list[str]

Fiecare pas utilizează un apel separat cu o schemă adaptată. Această abordare modulară simplifică depanarea și monitorizarea.

Gestionarea erorilor în producție

try:
    response, parsed = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=messages,
        response_format=MonSchema,
        tools=[{"type": "web_search"}]
    )
except Exception as e:
    # Fallback without web search
    response, parsed = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=messages,
        response_format=MonSchema
    )

Puncte cheie

  • Extracția îmbogățită combină căutarea web cu ieșirile structurate pentru date complete
  • Validarea încrucișată verifică faptele prin căutare pe web
  • Executarea de cod asigură calcule exacte în fluxurile financiare
  • Structurarea în pași separați asigură robustețe și ușurează depanarea
  • Planificați întotdeauna o soluție de rezervă în cazul în care instrumentele eșuează