Monitorea Gastos de Tokens IA en Grafana: Claude, Codex y Ollama

En el mundo del homelab y los experimentos con LLMs, es fácil perder el control del consumo de recursos. Ya sea que ejecutes ollama localmente o consumas APIs de Anthropic (Claude) y OpenAI (Codex), cada solicitud transforma tokens en dinero o en ciclos de CPU/GPU. Sin visibilidad, una sesión de pruebas puede traducirse en facturas sorpresa o en cuellos de botella silenciosos. En este tutorial práctico te muestro cómo centralizar el rastreo de tokens, costos y métricas de rendimiento en Grafana, usando Prometheus como motor de métricas.

El enfoque combina exporters ligeros para cada fuente de datos, una configuración mínima de Prometheus y dashboards reutilizables. Al final, podrás visualizar en tiempo real cuántos tokens consumes, cuánto cuesta tu inferencia local vs. cloud, y recibir alertas antes de que tu presupuesto o tu hardware se agoten.

Arquitectura mínima y comparativa de fuentes

Antes de tocar configuraciones, definamos qué métricas necesitamos y de dónde vienen para segmentar correctamente el gasto:

• Ollama (local): Métricas de inferencia por puerto (exporter integrado en v0.1.62+). Incluye tokens generados, latencia, uso de VRAM/CPU y estado del modelo en caché.
• Claude (API cloud): Anthropic no expone métricas nativas en Prometheus. Necesitamos un sidecar o proxy (como litellm) que intercepte requests y exponga contadores de input/output y costo por request.
• Codex/OpenAI (API cloud): OpenAI tampoco publica endpoints de métricas públicas. Usaremos litellm proxy o un exporter personalizado que cuente tokens por modelo y aplique tarifas oficiales por 1M de tokens.

La ventaja de centralizar en Prometheus es que unificas todo bajo el mismo lenguaje de consulta (PromQL). No importa si el token se genera en tu GPU dedicada o en la nube: Grafana verá métricas consistentes y comparables.

Requisitos previos

Para seguir este setup necesitas:

• Docker y Docker Compose instalados
• Un servidor o VPS con al menos 4 GB de RAM (Prometheus + Grafana pueden consumir 1-2 GB en reposo, más memoria si retienes métricas a largo plazo)
• Línea de comandos con acceso a los endpoints de Ollama y a tus API keys de Anthropic/OpenAI
• Conocimientos básicos de YAML y PromQL (aunque el tutorial incluye las queries listas para copiar)

Paso 1: Exponer las métricas de Ollama y APIs cloud

Ollama ya viene con un exporter de Prometheus integrado. Solo necesitas exponer el puerto 8081. Si usas Docker, así:

version: '3.8'
services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
      - "8081:8081"
    volumes:
      - ollama_data:/root/.ollama
volumes:
  ollama_data:

Verifica que funcione visitando http://tu-ip:8081/metrics. Deberías ver líneas como ollama_prompt_tokens_total y ollama_generation_tokens_total con labels por modelo.

Para Claude y Codex, la vía más rápida y mantenible es usar litellm proxy, que actúa como intermediario y expone métricas Prometheus automáticamente. Crea un archivo de configuración con tus claves:

model_list:
  - model_name: claude-3-opus
    litellm_params:
      model: anthropic/claude-3-opus-20240229
      api_key: $ANTHROPIC_KEY
  - model_name: gpt-4o-codex
    litellm_params:
      model: openai/gpt-4o
      api_key: $OPENAI_KEY

server_config:
  port: 4000
  metrics_port: 9000
  save_metrics: true
  prometheus_enabled: true

Con litellm, cada request pasa por el proxy y se generan métricas como litellm_llm_completion_time y litellm_request_count. Además, puedes calcular costos en tiempo real si configuras las tarifas base en el YAML, eliminando la necesidad de scripts externos.

Paso 2: Configurar Prometheus para recolección

Ahora unificamos los endpoints. Tu prometheus.yml debe apuntar a Ollama y al proxy de litellm:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'ollama'
    static_configs:
      - targets: ['host.docker.internal:8081']

  - job_name: 'litellm'
    static_configs:
      - targets: ['litellm-proxy:9000']

  - job_name: 'grafana'
    static_configs:
      - targets: ['grafana:3000']

Nota: Si Prometheus y Ollama están en el mismo host, usa host.docker.internal o la IP local. En Docker Compose, reemplaza por el nombre del servicio. Añade relabel_configs si necesitas etiquetar el origen (ej. source: local vs source: cloud) para segmentar costos después. Prometheus agregará automáticamente el timestamp y la métrica base.

Paso 3: Importar y personalizar dashboards en Grafana

Grafana no trae un dashboard nativo para IA, pero puedes crear uno desde cero o importar uno basado en métricas de LLMs. Aquí va la estructura recomendada para tener control total:

• Panel 1: Tokens por modelo (por hora) → Usa sum(rate(ollama_generation_tokens_total[1h])) by (model) or sum(rate(litellm_token_count[1h])) by (model)
• Panel 2: Costo estimado acumulado → Si calculaste costos en el proxy, usa sum(rate(litellm_cost_total[1h])). Si no, aplica tarifas manuales con PromQL o en el exporter.
• Panel 3: Latencia p95 → histogram_quantile(0.95, sum(rate(litellm_llm_completion_time_bucket[5m])) by (le, model))
• Panel 4: Uso de recursos locales → VRAM/CPU de Ollama con node_memory_Active_bytes o métricas específicas de GPU (como nvidia_smi_memory_used si usas nvidia-docker-exporter)

Para calcular costos manuales sin proxy avanzado, usa una constante en PromQL. Ejemplo para Claude Haiku: ~0.00025 USD por 1K tokens de entrada y ~0.00125 USD por salida. La query sería:

(sum(rate(litellm_request_count{model="anthropic/claude-haiku"}[1h])) * 0.00025) +
 (sum(rate(litellm_request_count{model="anthropic/claude-haiku-output"}[1h])) * 0.00125)

Adapta los multiplicadores según la hoja de precios oficial. Grafana soporta transformaciones de datos y unidades monetarias nativas, así que puedes configurar el eje Y como currencies/USD. Además, te recomiendo añadir un campo de variable ${model} en el dashboard para filtrar por familia de modelo sin editar todas las queries manualmente.

Paso 4: Alertas y optimización de recursos

El monitoreo sin alertas es solo historial. Configura umbrales en Grafana para evitar sorpresas y mantener tu homelab estable:

• Límite de gasto: sum(litellm_cost_total) > 50 → Notificación por email o webhook si supera 50 USD diarios. Útil para sesiones de fine-tuning o pruebas intensivas.
• Cuello de botella local: node_gpu_utilization > 95% durante 10 minutos → Escala CPU o reduce batch size. Si la VRAM se satura, Ollama empezará a paginar en RAM y la latencia se disparará.
• Fallback a local: Si la latencia de API cloud > 2s, redirige tráfico a Ollama. Esto se gestiona en la capa de aplicación, pero tus dashboards te dirán exactamente cuándo activar el switch.

En infraestructuras homelab, la optimización real viene de comparar el costo de ejecución local vs cloud. Ollama tiene costo eléctrico y de hardware, pero cero tarifa por token. Claude/Codex tienen costo por token pero cero mantenimiento. Usa Grafana para calcular tu costo por inferencia completada y decide dónde rankear cada workload. Por ejemplo, si tu GPU está ociosa más del 60%, mover pruebas a local puede ahorrar un 70% en costos. Si necesitas baja latencia y alta precisión para producción, el cloud justifica su precio.

Buenas prácticas para el largo plazo

• Etiqueta todas las métricas con environment, model y source para segmentar reportes y auditorías.
• Usa retention corta en Prometheus (7-14 días) si solo te interesa gasto reciente; archiva en S3/MinIO si necesitas cumplimiento o análisis trimestral.
• Revisa dashboards semanalmente; los patrones de consumo de LLMs cambian rápido con nuevas versiones de modelos y prompts más verbosos.
• Considera un sidecar de logging (Loki) correlacionado con métricas para debug de prompts fallidos, tokens truncados o errores de rate-limit.
• Automatiza el reseteo de contadores diarios usando count_over_time con rate a medianoche si necesitas reportes de consumo fijo.

Conclusión

Implementar este pipeline te quita la incertidumbre del gasto en IA y te da control real sobre tu infraestructura. No se trata de evitar el uso de cloud, sino de saber exactamente qué estás pagando y cuándo conviene ejecutar localmente. Prueba el stack, ajusta las queries a tus tarifas y limita la retención según tu capacidad de disco. Con visibilidad total, tus experimentos con LLMs dejan de ser un gasto ciego y se convierten en un recurso optimizable.