Observabilidad real de LLMs: métricas, trazas y alarmas para detectar regresiones

Postergar la observabilidad en pipelines de IA con OpenAI multiplica el coste de bugs ocultos y regresiones silenciosas. La latencia sube en picos, las respuestas degradan y el time-to-recovery se duplica cada semana que pasamos sin traza ni alarma. Sin una capa técnica que cuantifique, correlacione y alerte, el equipo acaba guiándose por anécdotas, no datos.

La presión crece si los LLMs responden a usuarios finales o sistemas productivos. Cada segundo extra o bug sin detectar equivale a cientos de tickets o devoluciones. La observabilidad ya no es un nice-to-have: permite anticiparse a caídas y reducir euros quemados en tokens mal usados.

Arquitectura de observabilidad: Node.js y FastAPI conectados

Componentes críticos a instrumentar

• Prompts, contexto y parámetros de llamadas (model, max_tokens) persistidos en PostgreSQL (RDS Aurora)
• Latencia por request, recogida en log_duration_ms y expuesta vía endpoints de metrics (OpenTelemetry, Prometheus)
• Errores categorizados: 4xx (prompt mal formado), 5xx (timeout LLM, OpenAI rate limit), differenciando entre fallos de infraestructura y modelo

Captura de métricas en Node.js con OpenAI SDK v4.27+

import { OpenAI } from 'openai';
import { logLLMInteraction } from './metrics';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });

export async function inferLLM(prompt: string, context: string[]) {
  const start = process.hrtime.bigint();
  try {
    const response = await openai.chat.completions.create({
      model: 'gpt-4-turbo',
      messages: [...context, { role: 'user', content: prompt }],
      max_tokens: 512,
    });
    const duration = Number(process.hrtime.bigint() - start) / 1e6;
    await logLLMInteraction({ prompt, durationMs: duration, model: 'gpt-4-turbo', status: 'success' });
    return response.choices[0].message.content;
  } catch (err: any) {
    const duration = Number(process.hrtime.bigint() - start) / 1e6;
    await logLLMInteraction({ prompt, durationMs: duration, model: 'gpt-4-turbo', status: 'error', error: err.message });
    throw err;
  }
}

Visibilidad end-to-end para el CTO

• Persistencia de prompts permite reproducibilidad de bugs y auditoría ante clientes
• Correlación entre spikes de latencia y actualizaciones del SDK o del modelo
• Alarmas inmediatas si el error rate supera 2% en cualquier periodo de 5 minutos

Métricas esenciales: qué contar y cómo

Directivo: costes y riesgos bajo control

• Coste efectivo ($/1000 tokens): Promediar y auditar semanalmente contra los presupuestos de IA (ej: GPT-4 Turbo ~0,01$/1K context, ~0,03$/1K output tokens, junio 2024)
• Throughput (req/min, tokens/min): Capacidad máxima soportada antes de latencias anómalas o throttling de OpenAI
• Latencia p95/p99: Medición ajustada por endpoint: no es igual una inferencia simple que un RAG enriquecido con pgvector

Query SQL real para reporting semanal en PostgreSQL Aurora

WITH recent_requests AS (
  SELECT id, duration_ms, model, tokens_in, tokens_out, status, error
  FROM llm_calls
  WHERE created_at > NOW() - INTERVAL '7 days'
)
SELECT 
  model,
  COUNT(*) AS num_calls,
  round(avg(duration_ms),1) AS avg_latency_ms,
  percentile_cont(0.95) WITHIN GROUP (ORDER BY duration_ms) AS p95_latency_ms,
  sum(tokens_in+tokens_out)/1000 AS total_k_tokens,
  sum(CASE WHEN status = 'error' THEN 1 ELSE 0 END)::float/COUNT(*)*100 AS error_rate_pct
FROM recent_requests
GROUP BY model;

Tabla comparativa: métricas habituales, pros y límites

Trazas y logs estructurados: clave para ingenieros

Patrones de instrumentación en Node.js y FastAPI

• Logs estructurados en JSON para parsing robusto y correlación multi-servicio (ejemplo: FastAPI + uvicorn + Loki)
• Campos mínimos por traza: timestamp, pipeline_id, request_id, prompt_hash, error, duration_ms, input/output size

# FastAPI: logging de inferencia LLM (estructura mínima)
import logging
import json
from datetime import datetime

def log_llm(context, prompt, output, error, duration):
    log = {
        "timestamp": datetime.utcnow().isoformat() + "Z",
        "pipeline_id": context["pipeline_id"],
        "prompt_hash": hash(prompt),
        "status": "error" if error else "success",
        "duration_ms": duration,
        "output_size": len(output or ""),
    }
    if error:
        log["error"] = str(error)
    logging.info(json.dumps(log))

• Uso de correlación entre logs por pipeline_id para trazar desde petición inicial hasta respuesta final, incluso en pipelines async de varios pasos

• "El 84% de regresiones funcionales detectadas en Agente 404 en 2023 lo fueron por trazas completas con hashes de input/output, no por test unitario"

Alarmas y detección automática de regresiones

Automatización para equipos y operaciones

• Alarmas mediante Prometheus+Alertmanager por picos de latencia (>p95 base +40% en 10 min), spikes de errores/graceful degradation
• Evals automáticos usando OpenAI function calling: comparar outputs nuevos vs gold dataset, disparar alerta si score <= 0.7
• Slack/webhook: notificación instantánea y enlace directo al request_id en logs para reproducibilidad

// Ejemplo: callback de alarmas con Slack usando Node.js async/await
import fetch from 'node-fetch';

async function notifySlackAlarm(payload: { message: string, requestId: string }) {
  try {
    const res = await fetch(process.env.SLACK_WEBHOOK_URL!, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ text: `ALERTA LLM: ${payload.message}\nrequest_id: ${payload.requestId}` })
    });
    if (!res.ok) throw new Error('Slack notification failed');
  } catch(err) {
    console.error('Slack alarm error', err);
  }
}

• Riesgo: costar $60-150/mes sólo en tokens si los evals de regresión se disparan sin batch o throttling (OpenAI eval-on-new-response ~0,002$/ejemplo)
• Patrón recomendado: batch eval cada 100 requests ó hora, nunca per-request salvo SLAs muy estrictos

Benchmarks reales y límites de producción

Tabla: cuellos de botella y rendimiento observados por Agente 404 (2024)

• El 90% de los incidentes de regresión funcional causaron, de media, 2h adicionales de trabajo manual no justificado.
• Un sistema de trazas + alarmas redujo el window de resolución a menos de 17 minutos con pipeline crítico en onboarding de usuario.

Impacto en la operación

• Evitar una regresión no detectada en pipeline crítico ahorra 0,6-1,2 FTEs mensuales en retrabajo (auditoría Agente 404, 2024)
• Los picos de latencia se detectan y corrigen antes de 15 min en el 94% de los casos con alerta y logging estructurado
• Existen ahorros directos en inferencia LLM de 8-22% mensual sólo optimizando prompts y tokens tras medirlos con logs/metrics
• El coste operativo del stack de observabilidad (OpenTelemetry, logging estándard, SLACK, S3 backup) suele estar muy por debajo de 140€/mes, frente a potenciales pérdidas >3000€ mensuales sin detección de regresiones críticas.
• Diagnóstico y despliegue acelerado: con observabilidad técnica se reduce en 3-5 días el time-to-value de proyectos de IA aplicada.

En sistemas IA productivos, la instrumentación no es coste—es póliza de continuidad. Agente404.com ofrece revisión y despliegue de observabilidad en pipelines LLMs sobre Node.js y FastAPI en menos de 2 semanas, con entrega de paneles, alarmas y reporting cuatrimestral.

Te puede interesar

• Evaluación automatizada de pipelines RAG: LLM-as-judge en FastAPI y OpenAI
• Streaming LLM con SSE en Next.js 16 y OpenAI: patrones robustos de producción
• Caching semántico vs literal en inferencia LLM serverless: Node.js, Python, Redis y S3