Flujos de trabajo automatizados y canalizaciones
En esta página
Paso a producción
Las lecciones anteriores han cubierto los fundamentos y casos de uso individuales. Esta última lección integra todos los conceptos para construir flujos de trabajo automatizados y canalizaciones de validación listos para producción.
Flujo de trabajo: procesamiento de documentos
Una canalización completa para procesar documentos entrantes de forma automática:
from pydantic import BaseModel
from typing import Literal
# Paso 1: Clasificación del documento
class ClassificationDocument(BaseModel):
type: Literal["facture", "contrat", "devis", "courrier", "autre"]
langue: str
urgence: Literal["basse", "normale", "haute"]
departement: Literal["comptabilite", "juridique", "commercial", "direction"]
# Paso 2: Extracción por tipo
class DonneesFacture(BaseModel):
numero: str
date_emission: str
date_echeance: str
emetteur: str
montant_ht: float
montant_ttc: float
lignes: list[dict]
# Paso 3: Validación
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):
# Clasificar
_, classification = client.chat.parse(
model="grok-4.20-0309-reasoning",
messages=[{"role": "user", "content": f"Classify this document: {texte}"}],
response_format=ClassificationDocument
)
# Extraer según el tipo
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
)
# Validar
_, 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
Canalización de validación de datos
Utiliza salidas estructuradas para validar y normalizar datos entrantes:
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]
Esta canalización toma contactos en diversos formatos y los normaliza en una estructura uniforme.
Arquitectura de canalización en varios pasos
Aquí tienes el esqueleto de una canalización de producción robusta:
class PipelineResult(BaseModel):
etape: str
succes: bool
donnees: dict
erreurs: list[str]
duree_ms: int
def pipeline_complet(texte: str) -> list[PipelineResult]:
resultats = []
# Cada paso utiliza un esquema dedicado
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
Buenas prácticas para producción
Idempotencia
Diseña tus canalizaciones para que puedan volver a ejecutarse sin efectos secundarios. El mismo documento procesado dos veces debe producir el mismo resultado.
Registro estructurado
Registra cada llamada con el esquema utilizado, el recuento de tokens y el tiempo de respuesta.
Reintento con retroceso exponencial
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
Monitorización
Realiza un seguimiento de estas métricas para cada canalización:
- Tasa de éxito por paso
- Tiempo medio de procesamiento
- Número de tokens consumidos
- Frecuencia de uso de mecanismos de respaldo (fallback)
Resumen del curso
A lo largo de estas 12 lecciones, has aprendido a:
- Comprender las salidas estructuradas y sus garantías
- Dominar los tipos admitidos y sus límites
- Utilizar
parse()yresponse_formatsegún tus necesidades - Definir esquemas con Pydantic (Python) y Zod (JavaScript)
- Combinar salidas estructuradas con búsqueda web y ejecución de código
- Construir canalizaciones de extracción, clasificación y validación
Las salidas estructuradas transforman los LLM de herramientas conversacionales en componentes de software fiables integrables en cualquier arquitectura.
Puntos clave
- Los flujos de trabajo en varios pasos utilizan un esquema dedicado por paso
- La validación cruzada compara los resultados de la extracción con fuentes de referencia
- En producción: idempotencia, registro estructurado, reintento con retroceso exponencial, monitorización
- Las salidas estructuradas son la base de cualquier canalización de IA fiable
- Combina esquemas (estructura) + prompts (contenido) + herramientas (datos) para obtener resultados óptimos
Pon a prueba tus conocimientos
JSON garantizado, esquemas, canalizaciones: salida estructurada, versión de Grok.
1. ¿Qué garantiza la salida estructurada mediante esquema?
Respuesta: Una salida estrictamente conforme al esquema JSON declarado: tipos, campos y estructura; utilizable por el código sin necesidad de análisis defensivo, ya que el formato se restringe durante la generación.
2. ¿Qué aporta el método parse() en comparación con response_format manual?
Respuesta: El bucle totalmente automatizado: el modelo Pydantic (o Zod en JS) declara el esquema y la respuesta regresa ya validada y tipada como un objeto; cero código repetitivo.
3. ¿Por qué es importante conocer los tipos no admitidos?
Respuesta: Porque un esquema que utilice construcciones no admitidas fallará o se degradará: debes diseñar tus modelos dentro del subconjunto aceptado y validar en la salida.
4. ¿Qué permite combinar salidas estructuradas con búsqueda web o ejecución de código?
Respuesta: Canalizaciones donde la búsqueda o el cálculo alimentan una salida estructurada: la información actualizada o calculada llega directamente a tus campos tipados.
5. Cita dos casos de uso típicos en producción.
Respuesta: Extracción de entidades y clasificación (documentos, tickets, contenido) conectados a tus sistemas: flujos de trabajo automatizados donde la IA rellena estructuras, no párrafos.
Esquema declarado, generación restringida, validación de salida: la salida estructurada es la interfaz entre Grok y tu software; trátala como tal.