Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Flussi ta' Ħidma Awtomatizzati u Pipelines

Lezzjoni 12 / 12 Aġġornat 30 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Passaġġ għall-produzzjoni
  2. Flus ta’ Ħidma: ipproċessar ta’ dokumenti
  3. Pipeline ta’ validazzjoni tad-data
  4. Arkitettura ta’ pipeline b’diversi passi
  5. L-aħjar prattiki għall-produzzjoni
  6. Sommarju tal-kors
  7. Punti Ewlenin
  8. Ittestja l-għarfien tiegħek

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() u response_format skont 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.