Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Darbplūsmas un cauruļvadi automatizācijai

Nodarbība 12 no 12 Atjaunota 2026. gada 30. jūlijs Programmētājs
Šajā lapā
  1. Pāreja uz produkcijas vidi
  2. Darbplūsma: dokumentu apstrāde
  3. Datu validācijas cauruļvads
  4. Daudzsoļu cauruļvada arhitektūra
  5. Labākā prakse produkcijas videi
  6. Kursu kopsavilkums
  7. Galvenās atziņas
  8. Pārbaudi savas zināšanas

Pāreja uz produkcijas vidi

Iepriekšējās nodarbībās apskatījām pamatus un atsevišķus lietošanas gadījumus. Šī noslēdzošā nodarbība visu apvieno, lai izveidotu automatizētas darbplūsmas un validācijas cauruļvadus, kas gatavi produkcijas videi.

Darbplūsma: dokumentu apstrāde

Pilns cauruļvads ienākošo dokumentu automātiskai apstrādei:

from pydantic import BaseModel
from typing import Literal

# 1. solis: Dokumentu klasifikācija
class ClassificationDocument(BaseModel):
    type: Literal["facture", "contrat", "devis", "courrier", "autre"]
    langue: str
    urgence: Literal["basse", "normale", "haute"]
    departement: Literal["comptabilite", "juridique", "commercial", "direction"]

# 2. solis: Datu izgūšana pēc veida
class DonneesFacture(BaseModel):
    numero: str
    date_emission: str
    date_echeance: str
    emetteur: str
    montant_ht: float
    montant_ttc: float
    lignes: list[dict]

# 3. solis: Validācija
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):
    # Klasificē
    _, classification = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=[{"role": "user", "content": f"Classify this document: {texte}"}],
        response_format=ClassificationDocument
    )

    # Izgūst datus pēc veida
    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
        )

    # Validē
    _, 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

Datu validācijas cauruļvads

Izmanto strukturētas izejas, lai validētu un normalizētu ienākošos datus:

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]

Šis cauruļvads paņem kontaktus dažādos formātos un normalizē tos vienotā struktūrā.

Daudzsoļu cauruļvada arhitektūra

Lūk, robusta produkcijas cauruļvada skelets:

class PipelineResult(BaseModel):
    etape: str
    succes: bool
    donnees: dict
    erreurs: list[str]
    duree_ms: int

def pipeline_complet(texte: str) -> list[PipelineResult]:
    resultats = []

    # Katrs solis izmanto savu shēmu
    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

Labākā prakse produkcijas videi

Idempotence

Veido savus cauruļvadus tā, lai tos varētu palaist atkārtoti bez blakusparādībām. Vienam un tam pašam dokumentam, apstrādātam divreiz, jārada vienāds rezultāts.

Strukturēta žurnālēšana

Žurnālē katru izsaukumu, norādot izmantoto shēmu, tokena skaitu un atbildes laiku.

Atkārtoti mēģinājumi ar eksponenciālu pauzi

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

Monitorings

Izseko šos rādītājus katram cauruļvadam:

  • Veiksmes procents katrā solī
  • Vidējais apstrādes laiks
  • Patērēto tokena skaits
  • Rezerves risinājumu (fallback) biežums

Kursu kopsavilkums

Šo 12 nodarbību laikā tu iemācījies:

  • Saprast strukturētās izejas un to garantijas
  • Apgūt atbalstītos tipus un to robežas
  • Izmantot parse() un response_format atbilstoši savām vajadzībām
  • Definēt shēmas, izmantojot Pydantic (Python) un Zod (JavaScript)
  • Kombinēt strukturētās izejas ar tīmekļa meklēšanu un koda izpildi
  • Izveidot datu izgūšanas, klasifikācijas un validācijas cauruļvadus

Strukturētās izejas pārvērš LLM no sarunu rīkiem uzticamos programmatūras komponentos, ko var integrēt jebkurā arhitektūrā.

Galvenās atziņas

  • Daudzsoļu darbplūsmas izmanto atsevišķu shēmu katram solim
  • Krusteniskā validācija salīdzina izgūtos rezultātus ar atsauces avotiem
  • Produkcijas vidē: idempotence, strukturēta žurnālēšana, atkārtoti mēģinājumi ar eksponenciālu pauzi, monitorings
  • Strukturētās izejas ir jebkura uzticama AI cauruļvada pamats
  • Apvieno shēmas (struktūra) + uzvednes (saturs) + rīki (dati), lai sasniegtu optimālus rezultātus

Pārbaudi savas zināšanas

Garantēts JSON, shēmas, cauruļvadi: strukturētā izeja, Grok versija.

1. Ko garantē strukturētā izeja pēc shēmas?

Atbilde: Izvadi, kas stingri atbilst deklarētajai JSON shēmai – tipi, lauki, struktūra –, ko kodā var izmantot bez aizsardzības parsēšanas: formāts tiek ierobežots jau ģenerēšanas brīdī.

2. Ko metode parse() pievieno salīdzinājumā ar manuālu response_format?

Atbilde: Pilnībā automatizētu ciklu: Pydantic modelis (vai Zod JS vidē) deklarē shēmu, un atbilde tiek atgriezta jau validēta un tipēta kā objekts – nulles papildu kodu rakstīšana.

3. Kāpēc ir svarīgi zināt neatbalstītos tipus?

Atbilde: Jo shēma, kas izmanto neatbalstītas konstrukcijas, neizdodas vai pasliktina kvalitāti: tu veido savus modeļus pieņemamajā apakškopā un validē izvadi.

4. Ko ļauj kombinēt strukturētās izejas ar tīmekļa meklēšanu vai koda izpildi?

Atbilde: Cauruļvadus, kuros meklēšana vai aprēķini baro strukturētu izvadi: svaiga vai aprēķināta informācija nonāk tieši taviem tipētajiem laukiem.

5. Nosauc divus tipiskus lietošanas gadījumus produkcijas vidē.

Atbilde: Entītiju izgūšana un klasifikācija (dokumenti, biļetes, saturs), kas savienota ar tavām sistēmām – automatizētas darbplūsmas, kurās AI aizpilda struktūras, nevis rindkopas.

Deklarēta shēma, ierobežota ģenerēšana, izejas validācija: strukturētā izeja ir saskarne starp Grok un tavu programmatūru – izturies pret to atbilstoši.