Concepto clave

Un pipeline de prompts es una secuencia estructurada de prompts que trabajan juntos para resolver problemas complejos, similar a una línea de ensamblaje en una fábrica donde cada estación agrega valor específico. En lugar de enviar un solo prompt enorme a la API, dividimos el problema en pasos manejables donde la salida de un prompt se convierte en la entrada del siguiente.

Imagina que estás construyendo un sistema de recomendación de restaurantes. En lugar de pedirle a la API que "recomiende restaurantes basados en preferencias, ubicación y presupuesto, y luego genere una descripción personalizada", crearías un pipeline: (1) prompt para analizar preferencias del usuario, (2) prompt para filtrar restaurantes por ubicación, (3) prompt para ajustar según presupuesto, (4) prompt para generar descripciones atractivas. Esto mejora la precisión, facilita el debugging y permite reutilizar componentes.

Cómo funciona en la práctica

Vamos a construir un pipeline simple para generar resúmenes de artículos técnicos con análisis de complejidad. El pipeline tendrá tres etapas:

Extracción de puntos clave: Identificar los conceptos principales del artículo
Evaluación de complejidad: Determinar el nivel técnico (principiante, intermedio, avanzado)
Generación de resumen: Crear un resumen adaptado al nivel identificado

Ejemplo paso a paso:

Primero, enviamos el artículo completo al primer prompt para extraer puntos clave
Tomamos la respuesta (lista de puntos clave) y la enviamos al segundo prompt para evaluar complejidad
Finalmente, combinamos puntos clave y nivel de complejidad en un tercer prompt para generar el resumen final

Código en acción

Aquí tienes un ejemplo funcional usando la API de OpenAI (GPT) en Python:

import openai

# Configuración inicial
openai.api_key = 'tu-api-key-aqui'

# Pipeline de 3 etapas para resumen de artículos
def pipeline_resumen_tecnico(articulo_completo):
    # Etapa 1: Extracción de puntos clave
    prompt_etapa1 = f"""Extrae los 5 puntos clave más importantes de este artículo técnico.
    Devuelve solo una lista numerada.
    
    Artículo: {articulo_completo}"""
    
    respuesta_etapa1 = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt_etapa1}]
    )
    puntos_clave = respuesta_etapa1.choices[0].message.content
    
    # Etapa 2: Evaluación de complejidad
    prompt_etapa2 = f"""Basado en estos puntos clave, evalúa el nivel de complejidad del artículo.
    Opciones: principiante, intermedio, avanzado.
    Justifica brevemente tu elección.
    
    Puntos clave: {puntos_clave}"""
    
    respuesta_etapa2 = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt_etapa2}]
    )
    analisis_complejidad = respuesta_etapa2.choices[0].message.content
    
    # Etapa 3: Generación de resumen adaptado
    prompt_etapa3 = f"""Genera un resumen del artículo técnico adaptado al nivel identificado.
    
    Puntos clave: {puntos_clave}
    Nivel de complejidad: {analisis_complejidad}
    
    El resumen debe ser claro para el nivel identificado y no exceder 200 palabras."""
    
    respuesta_etapa3 = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt_etapa3}]
    )
    
    return {
        "puntos_clave": puntos_clave,
        "analisis_complejidad": analisis_complejidad,
        "resumen_final": respuesta_etapa3.choices[0].message.content
    }

# Ejemplo de uso
articulo_ejemplo = """El machine learning supervisado utiliza datos etiquetados...
(contenido completo del artículo aquí)"""

resultado = pipeline_resumen_tecnico(articulo_ejemplo)
print("Resumen generado:", resultado["resumen_final"])

Refactorización para mejor manejo de errores (ANTES vs DESPUÉS):

ANTES (sin manejo de errores):

respuesta = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": prompt}]
)

DESPUÉS (con manejo robusto):

import time

def llamada_api_segura(prompt, max_intentos=3):
    for intento in range(max_intentos):
        try:
            respuesta = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": prompt}],
                timeout=30
            )
            return respuesta.choices[0].message.content
        except openai.error.RateLimitError:
            time.sleep(2 ** intento)  # Backoff exponencial
        except Exception as e:
            if intento == max_intentos - 1:
                raise e
            time.sleep(1)
    return None

Errores comunes

Acoplamiento excesivo entre etapas: Diseñar prompts que dependen demasiado del formato exacto de la etapa anterior. Solución: Usar formatos consistentes (JSON, listas) y validar la salida antes de pasar a la siguiente etapa.
Falta de manejo de errores: Asumir que cada llamada a la API siempre tendrá éxito. Solución: Implementar retries con backoff exponencial y fallback strategies.
Pipeline demasiado largo: Crear pipelines con más de 5-6 etapas sin justificación clara. Solución: Evaluar si etapas pueden combinarse o si el problema realmente requiere tanta segmentación.
Ignorar el contexto acumulado: No pasar información relevante de etapas anteriores a las siguientes. Solución: Diseñar un objeto de contexto que viaje a través del pipeline.
No medir rendimiento: Implementar pipelines sin métricas para evaluar su efectividad. Solución: Agregar logging y tracking de tiempo/calidad por etapa.

Checklist de dominio

✓ Puedo identificar cuándo un problema necesita pipeline vs un solo prompt
✓ Sé diseñar prompts independientes que funcionen bien en secuencia
✓ Implemento manejo de errores robusto en cada etapa del pipeline
✓ Uso formatos consistentes (JSON, YAML) para pasar datos entre etapas
✓ Mido y optimizo el tiempo total de ejecución del pipeline
✓ Documento claramente el flujo de datos entre etapas
✓ Tengo estrategias de fallback cuando una etapa falla

Construye un pipeline de análisis de sentimiento en reseñas de productos

En este ejercicio práctico, crearás un pipeline de 3 etapas para analizar reseñas de productos de e-commerce. El objetivo es transformar reseñas crudas en insights accionables para el equipo de producto.

Prepara tu entorno:
- Crea un nuevo script Python
- Configura tu API key (usa variables de entorno para seguridad)
- Prepara 3-5 reseñas de ejemplo (puedes inventarlas o usar datos reales)
Diseña el pipeline:
- Etapa 1: Clasificación de sentimiento (positivo, negativo, neutral)
- Etapa 2: Extracción de temas principales (calidad, precio, entrega, etc.)
- Etapa 3: Generación de recomendación de acción para el equipo
Implementa cada etapa:
- Crea una función para cada prompt
- Asegúrate de que la salida de cada etapa sea el input adecuado para la siguiente
- Agrega logging para ver qué sucede en cada paso
Prueba y refina:
- Ejecuta el pipeline con diferentes reseñas
- Identifica puntos de falla y mejora los prompts
- Optimiza para consistencia en los resultados
Documenta:
- Crea un README que explique el flujo del pipeline
- Documenta los formatos de entrada/salida de cada etapa
- Incluye ejemplos de ejecución exitosa

Pistas

Considera usar JSON como formato intermedio para pasar datos entre etapas
Agrega validación básica después de cada etapa para catch errores temprano
Prueba con reseñas ambiguas para ver cómo maneja casos límite el pipeline

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Práctica: Creación de tu primer pipeline de prompts