Премини към основното съдържание
Български— Изберете език
Меню

Работни потоци и конвейери с автоматизация

Урок 12 от 12 Обновен 30 юли 2026 г. Програмист
На тази страница
  1. Преминаване към продукционна среда
  2. Работен поток: обработка на документи
  3. Конвейер за валидация на данни
  4. Архитектура на многоетапен конвейер
  5. Най-добри практики за продукционна среда
  6. Обобщение на курса
  7. Ключови изводи
  8. Проверете знанията си

Преминаване към продукционна среда

Предишните уроци обхванаха основите и отделните случаи на употреба. Този финален урок обединява всичко изградено до момента, за да създаде автоматизирани работни потоци и конвейери за валидация, готови за продукционна експлоатация.

Работен поток: обработка на документи

Пълен конвейер за автоматична обработка на входящи документи:

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

Конвейер за валидация на данни

Използвайте структурирани изходи, за да валидирате и нормализирате входящи данни:

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]

Този конвейер приема контакти в различни формати и ги нормализира в единна структура.

Архитектура на многоетапен конвейер

Ето скелета на надежден продукционен конвейер:

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

Най-добри практики за продукционна среда

Идемпотентност

Проектирайте конвейерите си така, че да могат да се изпълняват повторно без странични ефекти. Един и същ документ, обработен два пъти, трябва да даде един и същ резултат.

Структурирано записване в дневник (Logging)

Записвайте всяко извикване с използваната схема, броя токени и времето за отговор.

Повторни опити с експоненциално забавяне (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

Мониторинг

Следете тези метрики за всеки конвейер:

  • Процент на успех за всяка стъпка
  • Средно време за обработка
  • Брой използвани токени
  • Честота на задействане на резервни механизми (fallback)

Обобщение на курса

През тези 12 урока Вие научихте как да:

  • Разберете структурираните изходи и техните гаранции
  • Овладеете поддържаните типове и техните ограничения
  • Използвате parse() и response_format според Вашите нужди
  • Дефинирате схеми с Pydantic (Python) и Zod (JavaScript)
  • Комбинирате структурирани изходи с уеб търсене и изпълнение на код
  • Изградите конвейери за извличане, класификация и валидация

Структурираните изходи трансформират големите езикови модели (LLM) от разговорни инструменти в надеждни софтуерни компоненти, интегрируеми във всяка архитектура.

Ключови изводи

  • Многоетапните работни потоци използват отделна схема за всяка стъпка
  • Кръстосаната валидация сравнява резултатите от извличането с референтни източници
  • В продукционна среда: идемпотентност, структурирано записване в дневник, повторни опити с експоненциално забавяне, мониторинг
  • Структурираните изходи са основата на всеки надежден AI конвейер
  • Комбинирайте схеми (структура) + промптове (съдържание) + инструменти (данни) за оптимални резултати

Проверете знанията си

Гарантиран JSON, схеми, конвейери: структуриран изход, версия на Grok.

1. Какво гарантира структурираният изход чрез схема?

Отговор: Изход, строго съответстващ на обявената JSON схема – типове, полета, структура – използваем от код без защитно парсиране: форматът е ограничен още при генерирането.

2. Какво добавя методът parse() в сравнение с ръчното задаване на response_format?

Отговор: Напълно автоматизиран цикъл: Pydantic моделът (или Zod в JS) декларира схемата, а отговорът се връща вече валидиран и типизиран като обект – нулева допълнителна обработка.

3. Защо е важно да знаете кои типове не се поддържат?

Отговор: Защото схема, използваща неподдържани конструкции, ще се провали или ще деградира: Вие проектирате моделите си в рамките на приетото подмножество и валидирате на изхода.

4. Какво позволява комбинирането на структурирани изходи + уеб търсене или изпълнение на код?

Отговор: Конвейери, при които търсенето или изчисленията захранват структуриран изход: актуална или изчислена информация постъпва директно във Вашите типизирани полета.

5. Посочете два типични случая на употреба в продукционна среда.

Отговор: Извличане на entities и класификация (документи, тикети, съдържание), свързани с Вашите системи – автоматизирани работни потоци, при които AI попълва структури, а не параграфи.

Обявена схема, ограничено генериране, валидация на изхода: структурираният изход е интерфейсът между Grok и Вашия софтуер – третирайте го като такъв.