Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Työnkulut ja putket automatisoituna

Oppitunti 12 / 12 Päivitetty 30. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Siirtyminen tuotantoympäristöön
  2. Työnkulku: asiakirjojen käsittely
  3. Datatien validointiputki
  4. Monivaiheisen putken arkkitehtuuri
  5. Tuotannon parhaat käytännöt
  6. Kurssin yhteenveto
  7. Keskeiset asiat
  8. Testaa tietämyksesi

Siirtyminen tuotantoympäristöön

Aiemmissa tunneissa käsittelimme perusteita ja yksittäisiä käyttötapauksia. Tämä viimeinen tunti sitoo kaiken yhteen rakentaaksesi automatisoituja työnkulkuja ja validointiputkia, jotka ovat valmiita tuotantokäyttöön.

Työnkulku: asiakirjojen käsittely

Täydellinen putki saapuvien asiakirjojen automaattiseen käsittelyyn:

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

Datatien validointiputki

Käytä jäsennettyjä tulosteita saapuvan datan validointiin ja normalisointiin:

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]

Tämä putki ottaa vastaan yhteystietoja eri muodoissa ja normalisoi ne yhtenäiseksi rakenteeksi.

Monivaiheisen putken arkkitehtuuri

Tässä on vankan tuotantoputken runko:

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

Tuotannon parhaat käytännöt

Idempotenssi

Suunnittele putkesi siten, että ne voidaan suorittaa uudelleen ilman sivuvaikutuksia. Sama asiakirja käsiteltynä kahdesti tuottaa saman tuloksen.

Jäsennetty lokitus

Lokita jokainen kutsu käyttämällä schema-tiedostoa, token-määrää ja vasteaikaa.

Uudelleenyritys viiveellä (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

Monitorointi

Seuraa näitä mittareita jokaiselle putkelle:

  • Onnistumisprosentti vaihetta kohden
  • Keskimääräinen käsittelyaika
  • Kulutettujen tokenien määrä
  • Varajärjestelmän käyttöönoton tiheys

Kurssin yhteenveto

Näiden 12 tunnin aikana olet oppinut:

  • Ymmärtämään jäsennetyt tulosteet ja niiden takuut
  • Hallitsemaan tuettuja tyyppejä ja niiden rajoituksia
  • Käyttämään parse()- ja response_format-toimintoja tarpeidesi mukaan
  • Määrittelemään skeemoja Pydanticilla (Python) ja Zodilla (JavaScript)
  • Yhdistämään jäsennetyt tulosteet verkkohakuun ja koodin suorittamiseen
  • Rakentamaan ekstraktio-, luokittelu- ja validointiputkia

Jäsennetyt tulosteet muuttavat kielimallit keskustelutyökaluista luotettaviksi ohjelmistokomponenteiksi, jotka voidaan integroida mihin tahansa arkkitehtuuriin.

Keskeiset asiat

  • Monivaiheiset työnkulut käyttävät omaa skeemaansa jokaista vaihetta kohden
  • Ristivalidointi vertaa ekstrahointituloksia lähdeaineistoihin
  • Tuotannossa: idempotenssi, jäsennetty lokitus, uudelleenyritys viiveellä, monitorointi
  • Jäsennetyt tulosteet ovat minkä tahansa luotettavan tekoälyputken perusta
  • Yhdistä skeemat (rakenne) + kehotteet (sisältö) + työkalut (data) saavuttaaksesi optimaaliset tulokset

Testaa tietämyksesi

Taattu JSON, skeemat, putket: jäsennetty tuloste, Grok-versio.

1. Mitä skeeman mukainen jäsennetty tuloste takaa?

Vastaus: Tulosteen noudattaa ehdottomasti ilmoitettua JSON-skeemaa – tyypit, kentät, rakenne – joten koodi voi käyttää sitä ilman puolustavaa jäsennystä: muoto on rajoitettu jo generointivaiheessa.

2. Mitä `parse()`-metodi lisää verrattuna manuaaliseen `response_format`-käyttöön?

Vastaus: Täysin automatisoidun silmukan: Pydantic-malli (tai Zod JS:ssä) määrittelee skeeman, ja vastaus palautuu jo validoituena ja tyypitettynä objektina – ei ylimääräistä koodia tarvita.

3. Miksi on tärkeää tietää, mitkä tyypit eivät ole tuettuja?

Vastaus: Koska skeema, joka käyttää tukemattomia rakenteita, epäonnistuu tai heikkenee: suunnittelet mallisi hyväksytyn osajoukon puitteissa ja validoitat tulosteen.

4. Mitä mahdollistaa jäsennettyjen tulosteiden yhdistäminen verkkohakuun tai koodin suorittamiseen?

Vastaus: Putkia, joissa haku tai laskenta syöttää tietoa jäsennettyyn tulosteeseen: tuore tai laskettu tieto saapuu suoraan tyypitettyihin kenttiisi.

5. Nimeä kaksi tyypillistä käyttö tapausta tuotannossa.

Vastaus: Entiteettien ekstraktio ja luokittelu (asiakirjat, tiketit, sisältö) kytkettynä järjestelmiisi – automatisoidut työnkulut, joissa tekoäly täyttää rakenteita, ei kappaleita.

Ilmoitettu skeema, rajoitettu generointi, tulosteen validointi: jäsennetty tuloste on rajapinta Grokin ja ohjelmistosi välillä – kohtele sitä sellaisena.