Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Fluxos de Trabalho e Pipelines Automatizados

Aula 12 de 12 Atualizada a 30 de julho de 2026 Programador
Nesta página
  1. Passagem para produção
  2. Fluxo de trabalho: processamento de documentos
  3. Pipeline de validação de dados
  4. Arquitetura de pipeline em várias etapas
  5. Boas práticas de produção
  6. Resumo do curso
  7. Pontos-chave
  8. Teste os seus conhecimentos

Passagem para produção

As lições anteriores cobriram os fundamentos e casos de uso individuais. Esta última lição reúne tudo para construir fluxos de trabalho automatizados e pipelines de validação prontos para produção.

Fluxo de trabalho: processamento de documentos

Um pipeline completo para processar automaticamente documentos recebidos:

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

Pipeline de validação de dados

Utilize saídas estruturadas para validar e normalizar dados recebidos:

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]

Este pipeline recebe contactos em vários formatos e normaliza-os numa estrutura uniforme.

Arquitetura de pipeline em várias etapas

Eis o esqueleto de um pipeline de produção robusto:

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

Boas práticas de produção

Idempotência

Desenhe os seus pipelines para poderem ser reexecutados sem efeitos secundários. O mesmo documento processado duas vezes deve produzir o mesmo resultado.

Registo estruturado

Registe cada chamada com o esquema utilizado, a contagem de tokens e o tempo de resposta.

Nova tentativa com espera progressiva (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

Monitorização

Acompanhe estas métricas para cada pipeline:

  • Taxa de sucesso por etapa
  • Tempo médio de processamento
  • Número de tokens consumidos
  • Frequência de recurso a mecanismos de fallback

Resumo do curso

Ao longo destas 12 lições, aprendeu a:

  • Compreender as saídas estruturadas e as suas garantias
  • Dominar os tipos suportados e os seus limites
  • Utilizar parse() e response_format de acordo com as suas necessidades
  • Definir esquemas com Pydantic (Python) e Zod (JavaScript)
  • Combinar saídas estruturadas com pesquisa na web e execução de código
  • Construir pipelines de extração, classificação e validação

As saídas estruturadas transformam os LLM de ferramentas conversacionais em componentes de software fiáveis, integráveis em qualquer arquitetura.

Pontos-chave

  • Fluxos de trabalho em várias etapas utilizam um esquema dedicado por etapa
  • A validação cruzada compara os resultados da extração com fontes de referência
  • Em produção: idempotência, registo estruturado, nova tentativa com espera progressiva, monitorização
  • As saídas estruturadas são a base de qualquer pipeline de IA fiável
  • Combine esquemas (estrutura) + prompts (conteúdo) + ferramentas (dados) para obter resultados ótimos

Teste os seus conhecimentos

JSON garantido, esquemas, pipelines: saída estruturada, versão Grok.

1. O que garante a saída estruturada por esquema?

Resposta: Uma saída estritamente conforme com o esquema JSON declarado — tipos, campos, estrutura — utilizável pelo código sem análise defensiva: o formato é restringido na geração.

2. O que acrescenta o método parse() em comparação com response_format manual?

Resposta: O ciclo totalmente automatizado: o modelo Pydantic (ou Zod em JS) declara o esquema e a resposta retorna já validada e tipada como um objeto — zero configuração manual.

3. Por que razão é importante conhecer os tipos não suportados?

Resposta: Porque um esquema que utilize construções não suportadas falha ou degrada-se: deve desenhar os seus modelos dentro do subconjunto aceite e validar na saída.

4. O que permite combinar saídas estruturadas + pesquisa na web ou execução de código?

Resposta: Pipelines onde a pesquisa ou o cálculo alimentam uma saída estruturada: informações atualizadas ou calculadas chegam diretamente aos seus campos tipados.

5. Indique dois casos de uso típicos em produção.

Resposta: Extração e classificação de entidades (documentos, tickets, conteúdos) ligadas aos seus sistemas — fluxos de trabalho automatizados onde a IA preenche estruturas, não parágrafos.

Esquema declarado, geração restringida, validação de saída: a saída estruturada é a interface entre o Grok e o seu software — trate-a como tal.