Flussi ta' Ħidma Awtomatizzati u Pipelines
F'din il-paġna
Passaġġ għall-produzzjoni
Il-lezzjonijiet preċedenti koprew il-bażi u każijiet ta’ użu individwali. Din il-lezzjoni finali tgħaqqad kollox flimkien biex tibni flussi ta’ ħidma awtomatizzati u pipelines ta’ validazzjoni lesti għall-produzzjoni.
Flus ta’ Ħidma: ipproċessar ta’ dokumenti
Pipeline sħiħa biex tipproċessa dokumenti li jaslu awtomatikament:
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 ta’ validazzjoni tad-data
Uża outputs strutturati biex tivvalida u tinnormalizza d-data li tasal:
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]
Dan il-pipeline jieħu kuntatti f’formati varji u jinnormalizzahom f’istruttura uniformi.
Arkitettura ta’ pipeline b’diversi passi
Hawnhekk hemm l-istruttura bażika ta’ pipeline robusta għall-produzzjoni:
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
L-aħjar prattiki għall-produzzjoni
Idempotenza
Iddisinja l-pipelines tiegħek biex ikunu jistgħu jerġgħu jiġu eżegwiti mingħajr effetti sekondarji. L-istess dokument ipproċessat darbtejn irid jipproduċi l-istess riżultat.
Reġistrazzjoni strutturata
Irreġistra kull sejħa bl-iskema użata, in-numru ta’ tokens, u l-ħin tar-rispons.
Riprovwa b’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
Monitoraġġ
Segwi dawn il-metriċi għal kull pipeline:
- Rata ta’ suċċess għal kull pass
- Ħin medju ta’ pproċessar
- Numru ta’ tokens ikkunsmati
- Frekwenza tal-fallimenti (fallback)
Sommarju tal-kors
Matul dawn il-12-il lezzjoni, tgħallimt kif:
- Tifhem l-outputs strutturati u l-garanziji tagħhom
- Timmanipula it-tipi appoġġjati u l-limiti tagħhom
- Tuża
parse()uresponse_formatskont il-ħtiġijiet tiegħek - Tiddefinixxi skemi b’Pydantic (Python) u Zod (JavaScript)
- Tgħaqqad outputs strutturati mat-tiftix fuq il-web u l-eżekuzzjoni tal-kodiċi
- Tibni pipelines ta’ estrazzjoni, klassifikazzjoni u validazzjoni
L-outputs strutturati jibdlu l-LLMs minn għodod konversazzjonali f’komponenti tas-softwer affidabbli integrabbli f’kull arkitettura.
Punti Ewlenin
- Il-flussi ta’ ħidma b’diversi passi jużaw skema ddedikata għal kull pass
- Il-validazzjoni trasversali tqabbel ir-riżultati tal-estrazzjoni ma’ sorsi ta’ referenza
- Fil-produzzjoni: idempotenza, reġistrazzjoni strutturata, riprovwa b’backoff, monitoraġġ
- L-outputs strutturati huma l-fondazzjoni ta’ kull pipeline tal-AI affidabbli
- Għaqqad skemi (struttura) + prompts (kontenut) + għodod (data) għal riżultati ottimali
Ittestja l-għarfien tiegħek
JSON garantit, skemi, pipelines: output strutturat, verżjoni ta’ Grok.
1. X'jiggarantixxi l-output strutturat permezz ta' skema?
Tweġiba: Output li jikkonforma strettament mal-iskema JSON iddikjarata—tipi, oqsma, struttura—użabbli mill-kodiċi mingħajr parsing difensiv: il-format huwa mrażżan fil-ġenerazzjoni.
2. X'jżid il-metodu parse() meta mqabbel ma' response_format manwali?
Tweġiba: Iċ-ċiklu kompletament awtomatizzat: il-mudell Pydantic (jew Zod f’JS) jiddikjara l-iskema, u r-rispons jerġa’ lura diġà vvalidat u ttipjat bħala oġġett—ebda plumbing meħtieġ.
3. Għaliex huwa importanti li tkun taf it-tipi mhux appoġġjati?
Tweġiba: Għax skema li tuża kostruzzjonijiet mhux appoġġjati tfalli jew tiddegrada: inti tiddisinja l-mudelli tiegħek fis-subsett aċċettat u tivvalida fl-output.
4. X'jippermetti l-għaqda ta' outputs strutturati + tiftix fuq il-web jew eżekuzzjoni tal-kodiċi?
Tweġiba: Pipelines fejn it-tiftix jew il-kalkolu jipprovdu data għal output strutturat: informazzjoni friska jew ikkalkolata tasal direttament fl-oqsma ttipjati tiegħek.
5. Agħti żewġ każijiet ta' użu tipiċi fil-produzzjoni.
Tweġiba: Estrazzjoni ta’ entitajiet u klassifikazzjoni (dokumenti, tickets, kontenut) konnessi mas-sistemi tiegħek—flussi ta’ ħidma awtomatizzati fejn l-AI jimla strutturi, mhux paragrafi.
Skema ddikjarata, ġenerazzjoni mrażżna, validazzjoni tal-output: l-output strutturat huwa l-interfaċċa bejn Grok u s-softwer tiegħek—itrattah bħala tali.