Guía de uso de Langfuse y Helicone para observabilidad de LLMs

Cuando un LLM está en producción, necesitas saber tres cosas: qué tan rápido responde, cuánto cuesta cada llamada y qué prompt generó cada respuesta. Langfuse y Helicone son dos plataformas de observabilidad que te dan exactamente eso — tracing de extremo a extremo, seguimiento de costos, análisis de latencia y un playground para debuggear prompts sin tocar código de producción.

Tip Pro: No esperes a tener un problema para instalar observabilidad. Pon Langfuse o Helicone desde el primer deploy en producción. El costo de integrarlo después es mucho mayor.

Contexto

La observabilidad en LLMs no es opcional cuando tu aplicación depende de un modelo que puede cambiar de comportamiento sin que tú cambies una línea de código. Las herramientas tradicionales de APM (Datadog, New Relic) no entienden de prompts, tokens ni tool calls — necesitas algo diseñado para el stack de IA generativa.

Tanto Langfuse como Helicone son plataformas open-source (con opción cloud o self-hosted) que interceptan las llamadas a las APIs de LLMs (OpenAI, Anthropic, Gemini, etc.) y registran:

• Traces: la secuencia completa desde que el usuario envía un mensaje hasta que recibe la respuesta, incluyendo tool calls y retrievals.
• Spans: cada paso individual dentro de un trace (una llamada a la API, una consulta a BD, un tool_call).
• Costos: cuántos tokens de input y output consumió cada llamada y su equivalente en dólares.
• Latencia: cuánto tardó cada paso y el total.
• Feedback: calificaciones de usuarios o evaluaciones automáticas vinculadas a traces específicos.

Langfuse ofrece un producto más maduro con un dashboard rico, generación de datasets para evaluación y un playground. Helicone es más ligero, con una API simple y énfasis en caché y rate limiting.

Nota: Ambas herramientas funcionan como proxy o como integración directa vía SDK. No modifican el comportamiento del LLM — solo registran lo que pasa.

Configuración / setup

Langfuse

Langfuse tiene SDKs para Python, Node.js y acceso vía API directa.

pip install langfuse

from langfuse import Langfuse
 
langfuse = Langfuse(
    secret_key="sk-lf-...",
    public_key="pk-lf-...",
    host="https://cloud.langfuse.com"  # o tu instancia self-hosted
)
 
# Rastrear una llamada
trace = langfuse.trace(name="chat-completion")
 
span = trace.span(
    name="openai-call",
    input={"model": "gpt-4o", "messages": [{"role": "user", "content": "Hola"}]}
)
 
# Después de la llamada real a OpenAI...
span.end(
    output={"content": "¡Hola! ¿En qué puedo ayudarte?"},
    usage={"input": 5, "output": 8}  # tokens
)
 
trace.end()

Con OpenAI nativamente:

Langfuse se integra directamente con el SDK de OpenAI:

from langfuse.openai import openai
 
# Ahora todas las llamadas a openai se tracean automáticamente
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "¿Qué tiempo hace?"}]
)

Cada llamada queda registrada en el dashboard con su prompt, respuesta, tokens, latencia y costo.

Advertencia: La integración automática de Langfuse con el SDK de OpenAI modifica el módulo openai. Si usas parches de terceros, verifica compatibilidad.

Middleware para frameworks web (FastAPI):

from langfuse import Langfuse
from langfuse.decorators import observe
 
langfuse = Langfuse()
 
@observe()
def chat_with_user(message: str) -> str:
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": message}]
    )
    return response.choices[0].message.content

Helicone

Helicone funciona como proxy — apuntas tus llamadas a su endpoint y él reenvía al proveedor:

pip install helicone

from helicone.openai import openai
 
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "¿Qué clima hace?"}],
    headers={
        "Helicone-Auth": "Bearer YOUR_API_KEY",
        "Helicone-User-Id": "user-123",
        "Helicone-Property-App": "my-app"
    }
)

Alternativamente, puedes apuntar directo al proxy:

import openai
 
openai.api_key = "sk-..."
openai.base_url = "https://oai.hconeai.com/v1"  # proxy de Helicone
 
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hola"}]
)

Helicone también soporta caching automático: si envías el mismo prompt, devuelve la respuesta en caché sin llamar al proveedor, ahorrando costos y latencia.

Tip Pro: Activa el caché de Helicone en prompts que sabes que se repiten (ej: mensajes de sistema, consultas frecuentes a una base de conocimiento). Puedes reducir costos hasta un 40%.

Ejemplos

Ejemplo 1: Trazar una conversación multiturno con Langfuse

from langfuse import Langfuse
from langfuse.openai import openai
 
langfuse = Langfuse()
 
# Inicia un trace por sesión de usuario
trace = langfuse.trace(
    name="customer-support",
    user_id="user-42",
    session_id="sess-001"
)
 
# Turno 1
generation = trace.generation(
    name="turn-1",
    model="gpt-4o",
    input="Necesito cancelar mi suscripción"
)
 
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Necesito cancelar mi suscripción"}]
)
 
generation.end(
    output=response.choices[0].message.content,
    usage={
        "input": response.usage.prompt_tokens,
        "output": response.usage.completion_tokens
    }
)

En el dashboard de Langfuse ves cada turno, su costo, latencia y el feedback del usuario si lo agregas.

Ejemplo 2: Monitorear costos por usuario con Helicone

Helicone etiqueta automáticamente las requests por Helicone-User-Id, permitiéndote filtrar costos por usuario en el dashboard:

# Tus headers de Helicone
headers = {
    "Helicone-Auth": "Bearer YOUR_KEY",
    "Helicone-User-Id": user_id,
    "Helicone-Property-Plan": "premium"  # metadatos adicionales
}

Luego en el dashboard ves: "User-42 gastó $12.30 este mes con 4,500 llamadas". Esto es útil para facturación por uso o para detectar abuso.

Ejemplo 3: Evaluación vs producción con Langfuse

Langfuse permite adjuntar evaluaciones manuales o automáticas a traces:

# Evaluación manual (humana o LLM-as-judge)
trace.score(
    name="accuracy",
    value=1.0,  # 0.0 a 1.0
    comment="Respuesta correcta y bien referenciada"
)

Esto te permite correlacionar la calidad de las respuestas con el prompt, el modelo y el costo de cada trace.

Nota: Langfuse también tiene un playground donde puedes editar prompts y ver cómo cambia la respuesta sin tocar tu código. Útil para debuggear en caliente.

Particularidades

¿Cuál elegir?

• Elige Langfuse si necesitas un dashboard completo, trazabilidad multiturno, generación de datasets para evaluación y un playground para debuggear. Es la opción más completa para equipos que construyen aplicaciones conversacionales complejas.

• Elige Helicone si priorizas simplicidad, caching, rate limiting y un setup mínimo (solo cambiar el endpoint). Es ideal para equipos pequeños que quieren observabilidad sin agregar complejidad al stack.

Tip Pro: Puedes usar ambos. Helicone como proxy para caché y rate limiting, y Langfuse para tracing profundo y evaluación. No son excluyentes.

Historia y evolución