Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Munkafolyamatok és folyamatcsövek automatizálása

12. lecke 12 közül Frissítve 2026. július 30. Fejlesztő
Ezen az oldalon
  1. Éles környezetbe helyezés
  2. Munkafolyamat: dokumentumfeldolgozás
  3. Adatellenőrzési folyamatcső
  4. Többlépéses folyamatcső-architektúra
  5. Éles környezeti legjobb gyakorlatok
  6. A kurzus összefoglalása
  7. Főbb megállapítások
  8. Teszteld a tudásod

Éles környezetbe helyezés

Az előző leckék az alapokat és az egyes használati eseteket tárgyalták. Ez a záró lecke mindent egybefog, hogy automatizált munkafolyamatokat és ellenőrzési folyamatcsöveket építs, amelyek készen állnak az éles környezetre.

Munkafolyamat: dokumentumfeldolgozás

Egy teljes folyamatcső a beérkező dokumentumok automatikus feldolgozásához:

from pydantic import BaseModel
from typing import Literal

# 1. lépés: Dokumentumosztályozás
class ClassificationDocument(BaseModel):
    type: Literal["facture", "contrat", "devis", "courrier", "autre"]
    langue: str
    urgence: Literal["basse", "normale", "haute"]
    departement: Literal["comptabilite", "juridique", "commercial", "direction"]

# 2. lépés: Kinyerés típus szerint
class DonneesFacture(BaseModel):
    numero: str
    date_emission: str
    date_echeance: str
    emetteur: str
    montant_ht: float
    montant_ttc: float
    lignes: list[dict]

# 3. lépés: Érvényesítés
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):
    # Osztályozás
    _, classification = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=[{"role": "user", "content": f"Classify this document: {texte}"}],
        response_format=ClassificationDocument
    )

    # Kinyerés típus szerint
    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
        )

    # Érvényesítés
    _, 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

Adatellenőrzési folyamatcső

Használj strukturált kimeneteket a beérkező adatok ellenőrzésére és normalizálására:

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]

Ez a folyamatcső különböző formátumú kapcsolatokat vesz át, és egységes szerkezetbe normalizálja azokat.

Többlépéses folyamatcső-architektúra

Íme egy robusztus, éles környezeti folyamatcső váza:

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

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

    # Minden lépés dedicated sémát használ
    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

Éles környezeti legjobb gyakorlatok

Idempotencia

Úgy tervezd meg a folyamatcsöveidet, hogy mellékhatások nélkül újra lefuttathatók legyenek. Ugyanannak a dokumentumnak kétszeri feldolgozása ugyanazt az eredményt kell hogy produkálja.

Strukturált naplózás

Minden hívást naplózz a használt sémával, a tokenek számával és a válaszidővel.

Újrapróbálkozás exponenciális várakozással (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

Monitorozás

Kövesd nyomon ezeket a metrikákat minden folyamatcsőnél:

  • Sikerráta lépésenként
  • Átlagos feldolgozási idő
  • Felhasznált tokenek száma
  • Tartalék megoldások (fallback) gyakorisága

A kurzus összefoglalása

Ezen 12 lecke során megtanultad:

  • Megérteni a strukturált kimeneteket és azok garanciáit
  • Elsajátítani a támogatott típusokat és azok korlátait
  • Használni a parse() metódust és a response_format paramétert az igényeid szerint
  • Meghatározni sémákat Pydantic (Python) és Zod (JavaScript) segítségével
  • Kombinálni a strukturált kimeneteket webes kereséssel és kódvégrehajtással
  • Felépíteni kinyerési, osztályozási és ellenőrzési folyamatcsöveket

A strukturált kimenetek a beszélgető eszközökből megbízható szoftverkomponensekké alakítják az LLM-eket, amelyek bármilyen architektúrába integrálhatók.

Főbb megállapítások

  • A többlépéses munkafolyamatok lépésenként dedikált sémát használnak
  • A keresztellenőrzés összehasonlítja a kinyert eredményeket referenciaforrásokkal
  • Éles környezetben: idempotencia, strukturált naplózás, újrapróbálkozás exponenciális várakozással, monitorozás
  • A strukturált kimenetek bármely megbízható AI-folyamatcső alapjai
  • Kombináld a sémákat (szerkezet) + az utasításokat (tartalom) + az eszközöket (adat) az optimális eredmények érdekében

Teszteld a tudásod

Garantált JSON, sémák, folyamatcsövek: strukturált kimenet, Grok verzió.

1. Mit garantál a séma szerinti strukturált kimenet?

Válasz: Szigorúan a deklarált JSON-sémának megfelelő kimenetet – típusok, mezők, szerkezet –, amely védekező elemzés nélkül használható a kódban: a formátum már generálás során korlátozva van.

2. Mit ad hozzá a parse() metódus a kézi response_formathez képest?

Válasz: A teljesen automatizált ciklust: a Pydantic-modell (vagy JS-ben a Zod) deklarálja a sémát, és a válasz már ellenőrizve és objektumként típusozva érkezik vissza – nulla extra kódolás szükséges.

3. Miért fontos ismerni a nem támogatott típusokat?

Válasz: Mert a nem támogatott konstrukciókat használó séma meghibásodik vagy degradálódik: a modelljeidet az elfogadott részhalmazon belül tervezed meg, és kimenetkor ellenőrzöd azokat.

4. Mit tesz lehetővé a strukturált kimenetek + webes keresés vagy kódvégrehajtás kombinálása?

Válasz: Olyan folyamatcsöveket, ahol a keresés vagy számítás táplálja a strukturált kimenetet: a friss vagy kiszámított információk közvetlenül a típusozott mezőidbe kerülnek.

5. Nevezz meg két tipikus használati esetet éles környezetben.

Válasz: Entitáskinyerés és osztályozás (dokumentumok, jegyek, tartalmak) a rendszereidhez kapcsolva – automatizált munkafolyamatok, ahol az AI struktúrákat tölt ki, nem bekezdéseket.

Deklarált séma, korlátozott generálás, kimenet-ellenőrzés: a strukturált kimenet a felület a Grok és a szoftvered között – kezeld is úgy.