Przejdź do głównej treści
Polski— Wybierz język
Menu

Zautomatyzowane przepływy pracy i potoki danych

Lekcja 12 z 12 Zaktualizowano 30 lipca 2026 Programista
Na tej stronie
  1. Wdrożenie do produkcji
  2. Przepływ pracy: przetwarzanie dokumentów
  3. Potok walidacji danych
  4. Architektura potoku wieloetapowego
  5. Najlepsze praktyki produkcyjne
  6. Podsumowanie kursu
  7. Kluczowe wnioski
  8. Sprawdź swoją wiedzę

Wdrożenie do produkcji

Poprzednie lekcje omówiły podstawy i indywidualne przypadki użycia. Ta ostatnia lekcja scala całą wiedzę, aby zbudować zautomatyzowane przepływy pracy i potoki walidacji gotowe do środowiska produkcyjnego.

Przepływ pracy: przetwarzanie dokumentów

Kompletny potok do automatycznego przetwarzania przychodzących dokumentów:

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

Potok walidacji danych

Wykorzystaj strukturalne wyjścia do walidacji i normalizacji przychodzących danych:

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]

Ten potok przyjmuje kontakty w różnych formatach i normalizuje je do jednolitej struktury.

Architektura potoku wieloetapowego

Oto szkielet solidnego potoku produkcyjnego:

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

Najlepsze praktyki produkcyjne

Idempotentność

Projektuj swoje potoki tak, aby można je było uruchamiać wielokrotnie bez skutków ubocznych. Ten sam dokument przetworzony dwukrotnie musi dać ten sam wynik.

Ustrukturyzowane logowanie

Loguj każde wywołanie wraz z użytym schematem, liczbą tokenów i czasem odpowiedzi.

Ponawianie z wykładniczym opóźnieniem (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

Monitorowanie

Śledź następujące metryki dla każdego potoku:

  • Wskaźnik sukcesu na każdym etapie
  • Średni czas przetwarzania
  • Liczba zużytych tokenów
  • Częstotliwość uruchamiania mechanizmów awaryjnych (fallback)

Podsumowanie kursu

W ciągu tych 12 lekcji nauczyłeś się:

  • Rozumieć strukturalne wyjścia i ich gwarancje
  • Opanować obsługiwane typy i ich ograniczenia
  • Używać parse() i response_format zgodnie ze swoimi potrzebami
  • Definiować schematy za pomocą Pydantic (Python) i Zod (JavaScript)
  • Łączyć strukturalne wyjścia z wyszukiwaniem w sieci i wykonywaniem kodu
  • Budować potoki ekstrakcji, klasyfikacji i walidacji

Strukturalne wyjścia przekształcają LLM z narzędzi konwersacyjnych w niezawodne komponenty oprogramowania, które można integrować z dowolną architekturą.

Kluczowe wnioski

  • Przepływy pracy wieloetapowe wykorzystują dedykowany schemat dla każdego kroku
  • Walidacja krzyżowa porównuje wyniki ekstrakcji ze źródłami referencyjnymi
  • W produkcji: idempotentność, ustrukturyzowane logowanie, ponawianie z wykładniczym opóźnieniem, monitorowanie
  • Strukturalne wyjścia są fundamentem każdego niezawodnego potoku AI
  • Łącz schematy (struktura) + prompty (treść) + narzędzia (dane), aby uzyskać optymalne wyniki

Sprawdź swoją wiedzę

Gwarantowany JSON, schematy, potoki: strukturalne wyjście, wersja Grok.

1. Co gwarantuje strukturalne wyjście oparte na schemacie?

Odpowiedź: Wyjście ściśle zgodne z zadeklarowanym schematem JSON – typy, pola, struktura – gotowe do użycia przez kod bez konieczności defensywnego parsowania: format jest wymuszony już na etapie generowania.

2. Co dodaje metoda parse() w porównaniu do ręcznego ustawiania response_format?

Odpowiedź: W pełni zautomatyzowaną pętlę: model Pydantic (lub Zod w JS) deklaruje schemat, a odpowiedź wraca już zwalidowana i typowana jako obiekt – zero zbędnego kodu łączącego.

3. Dlaczego warto znać typy nieobsługiwane?

Odpowiedź: Ponieważ schemat wykorzystujący nieobsługiwane konstrukcje zakończy się niepowodzeniem lub ulegnie degradacji: projektujesz swoje modele w ramach akceptowalnego podzbioru i walidujesz wynik na wyjściu.

4. Na co pozwala połączenie strukturalnych wyjść z wyszukiwaniem w sieci lub wykonywaniem kodu?

Odpowiedź: Na tworzenie potoków, w których wyszukiwanie lub obliczenia zasilają strukturalne wyjście: świeże lub wyliczone informacje trafiają bezpośrednio do twoich typowanych pól.

5. Podaj dwa typowe przypadki użycia w środowisku produkcyjnym.

Odpowiedź: Ekstrakcja encji i klasyfikacja (dokumenty, zgłoszenia, treści) połączone z twoimi systemami – zautomatyzowane przepływy pracy, w których AI wypełnia struktury, a nie akapity tekstu.

Zadeklarowany schemat, ograniczone generowanie, walidacja wyjścia: strukturalne wyjście jest interfejsem między Grok a twoim oprogramowaniem – traktuj je jako takie.