Fluxos de Trabalho e Pipelines Automatizados
Nesta página
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()eresponse_formatde 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.