DOMINICODE

Tag: LLM

  • Cómo medir LLM Evals y Observabilidad en Producción

    Cómo medir LLM Evals y Observabilidad en Producción

    LLM Evals, Alignment y Observabilidad en Producción

    Tiempo estimado de lectura: 3 min

    • Ideas clave:
    • Las métricas operativas (Accuracy, Hallucination Rate, Latency, Cost per Task, Consistencia) son indispensables para pasar de prototipo a servicio escalable.
    • Construye un Golden Dataset, valida outputs estructurados y usa un modelo juez para tareas generativas.
    • Observabilidad en vivo (tracing, sampling, alertas) y guardrails de salida son necesarios para seguridad y estabilidad.

    Cómo medir si tu sistema AI realmente funciona en producción empieza por entender que “parece que responde bien” no es una métrica. LLM Evals, Alignment y Observabilidad en Producción son las piezas que convierten un prototipo bonito en infraestructura operable: Accuracy, Goal Completion, Toxicity, Hallucination Rate, Latency, Cost per Task y Consistencia. Si no mides esto, no escalas —solo maquillas el riesgo.

    Resumen rápido (lectores con prisa)

    LLM Evals: pruebas con un Golden Dataset y un modelo juez para medir factualidad y cumplimiento de objetivos. Observabilidad: tracing, sampling y alertas en vivo para detectar degradación y drift. Alineación y safety: guardrails en la salida y revisión humana cuando la confianza es baja.

    LLM Evals, Alignment y Observabilidad en Producción: qué medir y por qué

    La evaluación de modelos en producción debe ser multidimensional. Aquí están las métricas que importan y cómo interpretarlas:

    Métricas específicas

    Accuracy / Factuality

    ¿La respuesta es correcta? En sistemas RAG separa Context Recall (¿se recuperó lo relevante?) de Context Precision (¿la respuesta se basa en lo recuperado o lo inventa?).

    Hallucination Rate

    % de respuestas con información inventada. Target operativo: <3–5% según criticidad.

    Goal Completion

    Métrica binaria/medible ligada al negocio (email extraído, ticket resuelto). Es la métrica ROI.

    Toxicity / Safety

    Puntuaciones automáticas (ej. Perspective API) y guardrails para bloquear salidas peligrosas.

    Latency (TTFT y Total Latency)

    TTFT <2s para chat aceptable; objetivos más estrictos para aplicaciones UX sensibles.

    Cost per Task

    tokens * precio/modelo → $ por ejecución. Debe compararse con coste humano.

    Consistencia

    Desviación en resultados en ejecuciones repetidas; alta variabilidad indica prompts inestables o temperatura mal gestionada.

    Cómo construir Evals útiles (práctico)

    1. Golden Dataset

    Golden Dataset

    • Crea un conjunto curado de 100–500 ejemplos por workflow (80% casos comunes, 20% edge).
    • Human-label para ground truth inicial. Sin esto no hay baseline.

    Deterministic vs Model-Graded

    • Deterministic: para outputs estructurados valida formato/JSON con schema checks.
    • Model-graded: usa un LLM “juez” (más capaz) con una rúbrica para puntuar respuestas textuales. Ejemplo: pedir al juez “evalúa factualidad (1–5) y da evidencia”.

    Pipeline de CI

    • Ejecuta el Golden Dataset en cada PR que cambie prompts, chain logic o modelo.
    • Rechaza merges si Accuracy/Goal Completion bajan más de X%.

    Ejemplo simple (pseudocódigo de evaluación):

    # enviar respuesta + contexto + prompt de evaluación a un modelo juez
judge_prompt = "Evalúa si la respuesta es fiel al contexto. Score 1-5. Explica brevemente."
score = call_judge_model(input=context + answer, prompt=judge_prompt)

    Observabilidad en producción: trazas, sampling y alertas

    Las Evals funcionan offline; la Observabilidad te dice qué pasa en vivo.

    Tracing completo

    Registra input, documentos recuperados, prompts enviados, tokens, latencias por etapa. Usa LangSmith, LangFuse o Arize Phoenix para visualizar trace chains.

    Sampling inteligente

    Evalúa en línea entre 0.5–5% del tráfico para balancear coste y cobertura.

    Drift detection

    Monitoriza cambios en la distribución de inputs; alerta cuando un feature importante sale del rango esperado.

    Alertas por SLA

    Accuracy drop, Hallucination spike, o coste por task anómalo disparan rollback o canary throttling.

    Integra traces con OpenTelemetry para correlación con logs y métricas infra.

    Alineación operativa y safety

    • Implementa guardrails en la capa de salida (post‑processing) que validen seguridad y formato antes de exponer la respuesta (ej. NVIDIA NeMo Guardrails).
    • Para respuestas sensibles, requiere verificación secundaria: LLM-as-a-Judge + schema check + citation check (si es RAG).
    • Mantén un “human-in-the-loop” para casos de baja confianza: si la confianza < umbral, encolar para revisión humana.

    Métricas objetivo y SLOs realistas

    Define SLOs por workflow, p. ej.:

    • Accuracy > 95% en Golden Dataset.
    • Hallucination Rate < 3%.
    • TTFT < 2s.
    • Cost per Task < $0.05 (ajusta según caso de negocio).

    Monitoriza y versiona SLOs junto al código/infra.

    Errores comunes que debes evitar

    • No tener Golden Dataset.
    • Medir solo calidad, ignorar coste.
    • No versionar prompts ni modelos.
    • Silenciar drift: sin alertas el modelo se degrada sin aviso.

    Cierre operativo

    LLM Evals, Alignment y Observabilidad en Producción no son funciones accesorias: son el núcleo del ciclo de vida de una IA productiva. Empieza por construir tu Golden Dataset, versiona prompts como código, añade un juez para tareas generativas y despliega tracing por etapas. Con esas piezas, transformarás la IA de experimento a servicio confiable, escalable y justificable en costes.

    Lecturas y herramientas prácticas

    Para equipos que implementan pipelines de Evals y observabilidad como parte de workflows de producto, una continuación lógica es revisar recursos y experimentos prácticos disponibles en Dominicode Labs. Ahí puedes encontrar ejemplos aplicados y plantillas para integrar tracing y CI de evaluación en flujos de trabajo.

    FAQ

    ¿Qué es un Golden Dataset y por qué lo necesito?

    Un Golden Dataset es un conjunto curado y etiquetado de ejemplos (100–500 por workflow) que sirve como baseline para evaluar Accuracy y Goal Completion. Sin él no tienes una referencia objetiva para medir degradación o mejoras.

    ¿Cómo medir hallucinations en producción?

    Combina sampling en línea con evaluaciones humanas y modelos juez que comparen respuestas contra contexto o fuentes. Mide el porcentaje de respuestas con información inventada y fija umbrales operativos (<3–5%).

    ¿Qué es un modelo juez (model-graded)?

    Es un LLM más capaz que puntúa respuestas humanas/modelo según una rúbrica (p. ej. factualidad 1–5) y devuelve evidencia o explicación para el score.

    ¿Cuánto tráfico debo muestrear para Evals en línea?

    Generalmente entre 0.5–5% del tráfico, para equilibrar coste y cobertura. Ajusta según criticidad y coste por task.

    ¿Qué abandonar ante un spike de hallucinations?

    Accionar alertas: revertir cambios recientes (rollback), activar canary throttling, aumentar muestreo y encolar casos para revisión humana hasta estabilizar la tasa.

    ¿Cómo integrar tracing con OpenTelemetry?

    Instrumenta puntos clave (entrada, recuperación de documentos, llamada al modelo, post‑processing), exporta traces a tu backend y correlaciona con logs y métricas infra para análisis de causa raíz.

    ¿Cuáles son SLOs realistas para chatbots?

    Ejemplos: Accuracy >95% en Golden Dataset, Hallucination Rate <3%, TTFT <2s. Ajusta según el workflow y coste/humano de fallback.

  • Guía para implementar Langfuse y optimizar LLMs en producción

    Guía para implementar Langfuse y optimizar LLMs en producción

    Como empezar con langfuse: guía práctica para llevar LLMs a producción

    Tiempo estimado de lectura: 5 min

    • Instrumentar primero: arrancar con trazas por token, spans y versionado de prompts para entender coste y fallos.
    • Despliegue según necesidad: cloud para PoC rápido, self-hosted para cumplimiento y control de datos.
    • Integración mínima: usar @observe o CallbackHandler en LangChain para trazabilidad sin reescribir la app.
    • Métricas desde el día 1: coste por trace, latencia p95, tokens por prompt y tasa de fallos.

    Como empezar con langfuse es la primera pregunta que hace cualquier equipo cuando la prueba de concepto con un LLM deja de ser un hobby y empieza a costar dinero. Si quieres dejar de adivinar por qué un prompt alucina, cuánto te cuesta cada conversación o dónde se cuelga tu pipeline RAG, Langfuse es la herramienta que necesitas instrumentar primero.

    En las próximas secciones verás pasos concretos, ejemplos de código y criterios técnicos para decidir despliegue, métricas a monitorear y cómo integrar Langfuse con LangChain. Documentación oficial — repositorio — cloud

    Resumen rápido (lectores con prisa)

    Qué es: plataforma de observabilidad para aplicaciones LLM que captura generaciones, spans, versionado de prompts y datasets de evaluación.

    Cuándo usarlo: cuando necesitas coste por usuario/prompt, reproducibilidad y trazas jerárquicas.

    Por qué importa: permite decidir modelo/prompt/retriever basándose en métricas reales.

    Cómo funciona: instrumentas SDK o CallbackHandler y obtienes traces con spans, tokens y costes.

    ¿Qué hace Langfuse y por qué importa?

    Langfuse es una plataforma de observabilidad y gestión para aplicaciones LLM. No es solo trazas: captura generaciones (tokens, coste), spans (retrieval, postprocessing), versionado de prompts y datasets de evaluación. Eso significa dos cosas:

    • Puedes detectar coste por usuario, por prompt y por modelo.
    • Puedes depurar cadenas complejas (retriever → LLM → herramientas) con trazas jerárquicas.

    Si pagas por token y dependes de resultados reproducibles, no es opcional.

    Paso 1 — Elegir despliegue: Cloud vs Self-hosted

    Cloud (rápido): Regístrate en cloud.langfuse.com, crea un proyecto y copia PUBLIC_KEY / SECRET_KEY. Ideal para PoC y equipos que quieren empezar en horas.

    Self-hosted (compliance): Clona github.com/langfuse/langfuse y levanta con Docker Compose si necesitas controlar datos y cumplir regulaciones.

    Ejemplo mínimo: docker-compose

    services:
  langfuse:
    image: ghcr.io/langfuse/langfuse
    ports: ["3000:3000"]
    environment:
      DATABASE_URL: postgresql://user:pass@db:5432/langfuse
      NEXTAUTH_SECRET: your-secret

    Paso 2 — SDK e instrumentación básica

    Instala el SDK (elige tu stack):

    • Python: pip install langfuse
    • Node.js: npm install langfuse

    Variables de entorno mínimas:

    LANGFUSE_PUBLIC_KEY=pk-lf-...
LANGFUSE_SECRET_KEY=sk-lf-...
LANGFUSE_HOST=https://cloud.langfuse.com
OPENAI_API_KEY=sk-...

    Instrumentación rápida en Python

    from langfuse.decorators import observe
from langfuse.openai import openai

@observe()
def answer_user(query: str):
    res = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role":"user","content":query}],
        name="answer-v1"
    )
    return res.choices[0].message.content

    Resultado: una Trace en el dashboard con spans y generación (tokens, coste, parámetros).

    Paso 3 — Integración con LangChain y orquestadores

    Si usas LangChain o LlamaIndex, no decoras todo: añades un CallbackHandler.

    from langfuse.callback import CallbackHandler
from langchain.chains import LLMChain
from langchain_openai import OpenAI
from langchain.prompts import PromptTemplate

handler = CallbackHandler()
llm = OpenAI()
prompt = PromptTemplate.from_template("Resume: {text}")
chain = LLMChain(llm=llm, prompt=prompt)

result = chain.run("Documento grande...", callbacks=[handler])

    Langfuse trazará retrievals, llamadas a LLM y pasos intermedios, con breakdown de latencia.

    Paso 4 — Prompt Registry y control de cambios

    No hardcodees prompts. Usa el Prompt Registry para versionado y A/B:

    1. Crea prompt en el dashboard: summarizer-v1.
    2. En código pide la versión “production” y compila variables.
    3. Cambia el prompt desde UI sin redeploy.
    from langfuse import Langfuse
lf = Langfuse()
prompt = lf.get_prompt("summarizer-v1")
compiled = prompt.compile(text="texto largo")

    Métricas y alertas que debes configurar desde el día 1

    • Coste por trace y coste por usuario (alerta si crece >20%).
    • Latencia p95 (alerta si >2s en >5% traces).
    • Tokens input por prompt (detecta drift del prompt).
    • Rate de fallos/completions incompletos.

    Estas métricas convierten intuición en decisiones: cambiar a modelo más barato, optimizar retriever o ajustar tiempo de espera.

    Buenas prácticas operativas

    • Empieza por instrumentar solo 3 endpoints críticos (hot-paths).
    • Mantén modo solo-lectura primero (trazas, sin escrituras al modelo).
    • Añade guardrails para escrituras: simulación y aprobaciones manuales.
    • Versiona eventos y prompts; añade pruebas automáticas contra datasets (Langfuse Datasets).

    Limitaciones y costes

    • Curva inicial: entender Trace/Span toma horas.
    • Coste cloud: gratuito en niveles bajos; luego pago por traces. Revisa precios en cloud.langfuse.com.
    • Ecosistema joven: integra pruebas y rollbacks para evitar dependencias fuertes en early-stage.

    Checklist de lanzamiento (lista corta)

    1. Levantar proyecto en cloud o self-host.
    2. Instrumentar 3 funciones LLM con @observe o CallbackHandler.
    3. Crear 2 prompts versionados y un dataset de evaluación.
    4. Configurar alertas: coste diario, latencia p95, tokens.
    5. Medir 2 semanas, optimizar prompts/modelos/retriever.

    Conclusión — empezar y aprender rápido

    Como empezar con langfuse no es un ritual largo: en horas puedes tener trazas reales y en días tomar decisiones de coste y calidad. Lo que cambia es la disciplina: medir antes de optimizar. Haz la primera integración hoy, monitorea 100 traces y actúa sobre los tres mayores consumidores de tokens — esa es la ingeniería que realmente reduce coste y riesgo. Esto no acaba aquí: instrumenta, compara y deja que los datos guíen las siguientes iteraciones.

    Si trabajas en flujos de automatización o sistemas que combinan agentes y workflows, es útil complementar la instrumentación con prácticas de operación y experimentación. Para recursos y experimentos prácticos adicionales considera Dominicode Labs como continuación lógica de pruebas y validación en pipelines de IA.

    FAQ

    ¿Qué es Langfuse?

    Langfuse es una plataforma de observabilidad para aplicaciones LLM que captura generaciones, spans, versionado de prompts y datasets de evaluación.

    ¿Cuándo debo usar cloud vs self-hosted?

    Usa cloud para PoC y despliegues rápidos. Elige self-hosted si necesitas control de datos, cumplimiento o auditoría completa.

    ¿Cómo integro Langfuse en un proyecto existente?

    Puedes instrumentar funciones clave con @observe en Python o añadir un CallbackHandler en LangChain para trazabilidad sin reescribir toda la app.

    ¿Qué métricas son esenciales desde el inicio?

    Coste por trace/usuario, latencia p95, tokens por prompt y tasa de fallos. Configura alertas para cambios significativos.

    ¿Puedo versionar prompts sin redeploy?

    Sí. Usa el Prompt Registry en el dashboard para versionado y A/B; compila la versión desde el SDK en tiempo de ejecución.

    ¿Cuál es el coste típico de usar Langfuse?

    Hay niveles gratuitos bajos y luego pago por traces en cloud. Revisa precios y modelos en cloud.langfuse.com.

    ¿Funciona con LangChain y otros orquestadores?

    Sí. Langfuse proporciona CallbackHandler para LangChain y puede trazar retrievals, llamadas LLM y pasos intermedios.