Ir al contenido principal
Español— Elegir un idioma
Menú

Flujos de trabajo automatizados y canalizaciones

Lección 12 de 12 Actualizado el 30 de julio de 2026 Desarrollador
En esta página
  1. Paso a producción
  2. Flujo de trabajo: procesamiento de documentos
  3. Canalización de validación de datos
  4. Arquitectura de canalización en varios pasos
  5. Buenas prácticas para producción
  6. Resumen del curso
  7. Puntos clave
  8. Pon a prueba tus conocimientos

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() y response_format segú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.