MLOps para indies

Tiempo: ~25 min de teoría + 40 min de práctica

Lo esencial

MLOps suena a algo de una empresa como Netflix con cien ingenieros. En realidad es la respuesta a una sola pregunta: "¿mi IA funciona igual de bien que hace una semana?". Para quien desarrolla por su cuenta (indie), MLOps son tres cosas: vigilar el costo, vigilar la calidad y no romper lo que ya funciona.

🎨 Imagínalo así: abriste una cafetería. Ajustaste la receta del espresso una vez y listo. Pero al mes el proveedor cambió el grano, la presión de la máquina se desajustó y el barista empezó a compactar el café un poco distinto. El café sale "más o menos igual". Los clientes no se quejan abiertamente: simplemente dejan de venir. MLOps es probar tu propio café todos los días.

Conceptos clave

Prompt drift: el prompt se degrada con el tiempo sin cambios en el código
LangSmith: trazas y monitoreo de las llamadas a Claude
Promptfoo: pruebas de regresión para prompts
Cost monitoring: alertas de presupuesto y gastos anómalos
Versionado de prompts: Git para los prompts, no solo para el código
Baseline metrics: métricas de calidad de referencia para comparar con el tiempo

Teoría

Qué es el prompt drift y por qué ocurre

Escribiste un prompt hace tres meses. El código no cambió. Pero de pronto notas que las respuestas son más largas, o menos concretas, o tienen un tono un poco distinto. No tocaste nada, ¿qué pasó?

Causas del prompt drift:

Cambió el modelo: en el código hay un alias en lugar de una versión concreta, o retiraron el modelo anterior de la API y pasaste a uno nuevo. El comportamiento cambia un poco o bastante. Fija la versión del modelo en el código y sigue la lista de modelos y retiros de la API: Lo vigente.
Cambió el contexto: tus usuarios empezaron a escribir de otra forma, las preguntas cambiaron, aparecieron patrones nuevos que el prompt no contemplaba.
Se desfasó la cadena de agentes: un agente empezó a entregar un formato un poco distinto → el siguiente agente dejó de interpretarlo bien.
El prompt de sistema quedó viejo: describiste un contexto que ya no aplica.

🎨 Imagínalo así: un GPS con los mapas del año pasado. La carretera es la misma, pero un centro comercial nuevo cerró tu ruta de siempre. El GPS te guía con toda seguridad, y tú terminas frente a una barda.

LangSmith: trazas de las llamadas a Claude

LangSmith (de LangChain) es una plataforma de observabilidad para IA. Registra cada llamada: el prompt de entrada, la respuesta, la latencia, el costo y las etiquetas.

Para qué sirve:

Ver qué pasa realmente dentro de una cadena de agentes
Comparar respuestas de "ahora vs. hace una semana"
Encontrar llamadas caras que se pueden optimizar
Depurar cuando algo se rompe en producción

Integración con el SDK de Anthropic:

python

import anthropic
from langsmith import traceable
from langsmith.wrappers import wrap_anthropic

# wrap_anthropic registra los tokens y el costo de cada llamada
client = wrap_anthropic(anthropic.Anthropic())

@traceable(name="content-generator")
def generate_content(topic: str, style: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=1000,
        messages=[{
            "role": "user",
            "content": f"Escribe contenido sobre el tema '{topic}' con estilo {style}"
        }]
    )
    return "".join(b.text for b in response.content if b.type == "text")

# Todas las llamadas llegan automáticamente al dashboard de LangSmith
result = generate_content("email marketing", "amigable")

Qué ves en el dashboard:

Cada llamada con el prompt y la respuesta completos
Percentiles de latencia (p50, p90, p99)
Costo por cada endpoint
Anomalías (una llamada que tardó 10 veces más de lo normal)

Promptfoo: pruebas de prompts

Promptfoo es una herramienta de línea de comandos para correr pruebas de regresión sobre prompts. Funciona como las pruebas unitarias, pero para IA. En marzo de 2026 OpenAI compró Promptfoo; según la empresa, el proyecto sigue siendo de código abierto, pero conviene seguir de cerca su evolución.

bash

npm install -g promptfoo

Configuración de la prueba (promptfooconfig.yaml):

yaml

prompts:
  - "Analiza esta reseña y determina el sentimiento: {{review}}"

providers:
  - anthropic:messages:claude-haiku-4-5

tests:
  - vars:
      review: "¡Excelente producto, quedé muy contento!"
    assert:
      - type: contains
        value: "positiv"
      - type: not-contains
        value: "negativ"
  
  - vars:
      review: "Pésima calidad, no vuelvo a comprar"
    assert:
      - type: contains
        value: "negativ"
      - type: llm-rubric
        value: "La respuesta debe identificar un sentimiento negativo"
  
  - vars:
      review: "Normal, nada especial"
    assert:
      - type: contains-any
        value: ["neutr", "mixto", "indefinido"]

bash

# Correr las pruebas
promptfoo eval

# Comparar dos versiones del prompt
promptfoo eval --prompts v1-prompt.txt v2-prompt.txt

Integración con CI/CD:

yaml

# .github/workflows/prompt-tests.yml
name: Prompt Regression Tests

on: [push, pull_request]

jobs:
  test-prompts:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - run: npm install -g promptfoo
      - run: promptfoo eval --no-progress-bar
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Ahora las pruebas corren en cada push. Si el prompt empeoró, promptfoo termina con error y el CI falla.

Cost monitoring: el dinero bajo control

Para un indie, el dinero es lo más importante. Un solo error en un prompt puede multiplicar el gasto diario.

Monitoreo de costo integrado:

python

import anthropic
from datetime import datetime, timezone
import json
import os

class CostTracker:
    def __init__(self, daily_budget_usd: float = 20.0):
        self.client = anthropic.Anthropic()
        self.daily_budget = daily_budget_usd
        self.today_cost = 0.0
        self.log_file = "cost_log.jsonl"
    
    # Precios por 1 millón de tokens a octubre de 2026. Cambian: los vigentes están en la página
    # «Lo vigente» (../actual.html). Agrega otros modelos con el mismo esquema.
    COSTS = {
        "claude-sonnet-5-5": {"input": 2.0, "output": 10.0},
        "claude-haiku-4-5": {"input": 1.0, "output": 5.0},
    }
    
    def track_call(self, model: str, input_tokens: int, output_tokens: int, endpoint: str):
        rates = self.COSTS.get(model, self.COSTS["claude-sonnet-5-5"])
        cost = (input_tokens / 1_000_000 * rates["input"] + 
                output_tokens / 1_000_000 * rates["output"])
        
        self.today_cost += cost
        
        entry = {
            "ts": datetime.now(timezone.utc).isoformat(),
            "model": model,
            "endpoint": endpoint,
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "cost_usd": round(cost, 6)
        }
        
        with open(self.log_file, "a") as f:
            f.write(json.dumps(entry) + "\n")
        
        # Alerta al pasar el 80% del presupuesto
        if self.today_cost > self.daily_budget * 0.8:
            self.send_alert(f"⚠️ Se gastaron ${self.today_cost:.2f} de un presupuesto de ${self.daily_budget}")
        
        return cost
    
    def send_alert(self, message: str):
        # Aviso por Telegram (puedes cambiarlo por el canal que uses: email, Slack)
        import requests
        requests.post(
            f"https://api.telegram.org/bot{os.environ['TELEGRAM_BOT_TOKEN']}/sendMessage",
            json={"chat_id": os.environ['TELEGRAM_CHAT_ID'], "text": message}
        )

tracker = CostTracker(daily_budget_usd=20.0)

Gastos anómalos:

python

def detect_cost_anomaly(log_file: str, window_days: int = 7):
    """Compara el gasto de hoy con el promedio de la semana."""
    import statistics
    
    with open(log_file) as f:
        entries = [json.loads(line) for line in f]
    
    today = datetime.now(timezone.utc).date()
    daily_costs = {}
    
    for entry in entries:
        date = datetime.fromisoformat(entry['ts']).date()
        daily_costs[date] = daily_costs.get(date, 0) + entry['cost_usd']
    
    recent = [cost for date, cost in daily_costs.items() 
              if (today - date).days <= window_days and date != today]
    
    if len(recent) < 3:
        return False
    
    avg = statistics.mean(recent)
    std = statistics.stdev(recent)
    today_cost = daily_costs.get(today, 0)
    
    # Anomalía: hoy cuesta más que el promedio por más de 2 desviaciones estándar
    if today_cost > avg + 2 * std:
        return f"🚨 ¡Anomalía! Hoy: ${today_cost:.2f}, promedio: ${avg:.2f}"
    
    return False

Versionar los prompts como código

Los prompts son código. Deben estar en Git con su historial de cambios.

Estructura del repositorio:

Código

prompts/
  v1/
    system-prompt.md     # Versión 1.0
    user-template.md
  v2/
    system-prompt.md     # Versión 2.0: cambiamos el tono
    user-template.md
  current -> v2/         # Enlace simbólico a la versión actual
  CHANGELOG.md           # Qué cambió y por qué

CHANGELOG.md para prompts:

markdown

## v2.0 — 2026-04-15

### Cambios
- Quité la instrucción "sé breve": las respuestas quedaban demasiado cortas para correos de negocios
- Agregué ejemplos de formato
- Cambié el tono de formal a "amigable y profesional"

### Métricas antes/después (promptfoo)
- Longitud promedio de la respuesta: 150 → 280 palabras ✅
- Prueba "incluye saludo": 60% → 95% ✅
- Prueba "no usa 'Estimado señor'": 100% (sin cambio) ✅

### Reversión
git checkout v1/ si v2 resulta peor

Práctica

Paso 1: Instalar las herramientas

bash

# Promptfoo para probar prompts
npm install -g promptfoo

# LangSmith (para las trazas)
pip install langsmith

# Variables de entorno
export LANGSMITH_TRACING="true"   # sin esto las trazas no se activan
export LANGSMITH_API_KEY="ls__xxx"
export LANGSMITH_PROJECT="my-ai-app"

Paso 2: Escribir las primeras pruebas del prompt

Crea un archivo promptfooconfig.yaml para tu prompt principal. Inventa de 5 a 10 casos de prueba, incluidos casos límite: entrada vacía, texto muy largo, texto en varios idiomas, una solicitud potencialmente maliciosa.

bash

promptfoo eval
# Revisa qué pasó y qué falló

Paso 3: Configurar el seguimiento de costos

python

# cost_tracker.py
# Copia el código de la lección y reemplaza TELEGRAM_BOT_TOKEN y TELEGRAM_CHAT_ID
# Agrega una llamada a tracker.track_call() después de cada messages.create()

Paso 4: Monitoreo básico

Ejecútalo una vez al día:

bash

# Resumen del día
python -c "
import json
from datetime import datetime, timezone

today = datetime.now(timezone.utc).date().isoformat()
total = 0
calls = 0

with open('cost_log.jsonl') as f:
    for line in f:
        e = json.loads(line)
        if e['ts'].startswith(today):
            total += e['cost_usd']
            calls += 1

print(f'Hoy: {calls} llamadas, \${total:.4f}')
"

Paso 5: Tarea

Toma cualquier prompt de tu proyecto
Escribe 10 pruebas en promptfoo
Corre las pruebas y registra tu baseline (cuántas pasaron)
Haz un cambio pequeño en el prompt
Córrelas otra vez: ¿mejoró o empeoró?
Haz commit de ambas versiones en Git con la descripción de los cambios

Herramientas y recursos

LangSmith: smith.langchain.com (tiene plan gratis; revisa los límites en el sitio)
Promptfoo: promptfoo.dev — npm install -g promptfoo
Helicone: alternativa a LangSmith, helicone.ai (en marzo de 2026 Mintlify compró la empresa; el servicio funciona en modo de mantenimiento sin funciones nuevas; para un proyecto nuevo es mejor elegir otra herramienta)
Braintrust: otra plataforma de evaluación y monitoreo, braintrust.dev
Weights & Biases: MLOps empresarial, wandb.ai

Conclusiones clave

MLOps para indies no es DevOps, es disciplina. Tres reglas: prueba los prompts antes de desplegar (Promptfoo), vigila los gastos con alertas (cost tracker) y registra todo en LangSmith para tener dónde mirar cuando algo salga mal. El prompt drift es un asesino silencioso de la calidad. Sin pruebas no lo notarás hasta que los clientes empiecen a irse.

Siguiente lección

→ Production Observability: qué monitorear cuando el agente está en producción

MLOps para indies: monitoreo, drift y reentrenamiento sin un equipo de DevOps

Lo esencial

Conceptos clave

Teoría

Qué es el prompt drift y por qué ocurre

LangSmith: trazas de las llamadas a Claude

Promptfoo: pruebas de prompts

Cost monitoring: el dinero bajo control

Versionar los prompts como código

Práctica

Paso 1: Instalar las herramientas

Paso 2: Escribir las primeras pruebas del prompt

Paso 3: Configurar el seguimiento de costos

Paso 4: Monitoreo básico

Paso 5: Tarea

Herramientas y recursos

Conclusiones clave

Siguiente lección