Ingreso a Langfuse (Monitor 2026)

La creación e implementación de aplicaciones que utilizan modelos de verbo alto (LLM) conlleva su propio conjunto de problemas. Los LLM tienen una naturaleza no determinista, pueden difundir información plausible pero falsa y rastrear sus acciones en secuencias complicadas puede ser muy problemático. En esta rumbo, veremos cómo Langfuse surge como un aparato esencial para resolver estos problemas, al ofrecer una pulvínulo sólida para la observabilidad, evaluación y manejo rápido de las solicitudes de LLM.

¿Qué es Langfuse?

Langfuse es una innovadora plataforma de evaluación y observabilidad de código descubierto y creada específicamente para aplicaciones LLM. Es la pulvínulo para rastrear, ver y depurar todas las etapas de una interacción LLM, desde el mensaje original hasta la respuesta final, ya sea una simple emplazamiento o una complicada conversación de varios turnos entre agentes.

Langfuse no es solo una utensilio de registro, sino además un medio para evaluar sistemáticamente el desempeño del LLM, realizar pruebas A/B de indicaciones y compilar comentarios de los usuarios, lo que a su vez ayuda a cerrar el ciclo de feedback esencial para la mejoramiento iterativa. El punto principal de su valía es la transparencia que aporta al mundo de los LLM, permitiendo así a los desarrolladores:

• Comprenda el comportamiento de LLM: Descubra las indicaciones exactas que se enviaron, las respuestas que se recibieron y los pasos intermedios en una solicitud de varias etapas.
• Apañarse problemas: Localice rápidamente el origen de los errores, el bajo rendimiento o los resultados inesperados.
• Evaluación de calidad: La eficiencia de las respuestas de LLM se puede calcular con respecto a las métricas predefinidas con medidas tanto manuales como automatizadas.
• Refinar y mejorar: La información basada en datos se puede utilizar para perfeccionar indicaciones, modelos y razonamiento de aplicaciones.
• Manejar indicaciones: controle la lectura de las indicaciones y pruébelas para obtener el mejor LLM.

Características y conceptos esencia

Hay varias características esencia que ofrece Langfuse, como:

1. Seguimiento y seguimiento

Langfuse nos ayuda a capturar los rastros detallados de cada interacción que tiene LLM. El ‘rastreo’ es básicamente la representación de una solicitud de agraciado de un extremo a otro o un flujo de aplicación. En el interior de una traza, las unidades lógicas de trabajo se indican mediante «intervalos» y las llamadas a un LLM se refieren a «generaciones».

2. Evaluación

Langfuse además permite la evaluación tanto manual como programáticamente. Los desarrolladores pueden concretar métricas personalizadas que luego pueden estar de moda para ejecutar evaluaciones para diferentes conjuntos de datos y luego integrarse como evaluadores basados ​​en LLM.

3. Papeleo Rápida

Langfuse proporciona control directo sobre la dirección rápida conexo con capacidades de almacenamiento y control de versiones. Es posible probar varios mensajes mediante pruebas A/B y al mismo tiempo abastecer la precisión en diversos lugares, lo que además allana el camino para la optimización de mensajes basada en datos.

4. Colección de comentarios

Langfuse absorbe las sugerencias de los usuarios y las incorpora directamente a sus líneas. Podrá vincular comentarios particulares o calificaciones de usuarios a la interacción LLM precisa que resultó en un resultado, brindándonos así comentarios en tiempo existente para solucionar problemas y mejorar.

¿Por qué Langfuse? El problema que resuelve

Las herramientas de observabilidad de software tradicionales tienen características muy diferentes y no satisfacen los criterios de las aplicaciones impulsadas por LLM en los siguientes aspectos:

• No determinismo: Los LLM no siempre producirán el mismo resultado, incluso para una entrada idéntica, lo que hace que la depuración sea sobrado desafiante. Langfuse, a su vez, registra la entrada y salida de cada interacción, dando una imagen clara de la operación en ese momento.
• Sensibilidad inmediata: Cualquier cambio último en una pregunta podría alterar completamente la respuesta de LLM. Langfuse está ahí para ayudar a realizar un seguimiento de las versiones rápidas conexo con sus métricas de rendimiento.
• Cadenas complejas: La mayoría de las aplicaciones de LLM se caracterizan por una combinación de múltiples llamadas de LLM, diferentes herramientas y recuperación de datos (p. ej., TRAPO arquitecturas). La única modo de conocer el flujo y situar el emplazamiento donde se encuentra el cuello de botella o el error es el rastreo. Langfuse presenta una estría de tiempo visual para estas interacciones.
• Calidad subjetiva: El término «bondad» para la respuesta de un LLM suele ser parecido de opinión personal. Langfuse permite evaluaciones de calidad tanto objetivas (p. ej., latencia, recuento de tokens) como subjetivas (feedback humana, evaluación basada en LLM).
• Papeleo de costos: Gustar a las API de LLM tiene un precio. Comprender y optimizar sus costos será más manejable si Langfuse monitorea el uso de sus tokens y el convexidad de llamadas.
• Equivocación de visibilidad: El desarrollador no puede ver cómo se están desempeñando sus aplicaciones LLM en el mercado y, por lo tanto, les resulta difícil mejorarlas gradualmente oportuno a la desatiendo de observabilidad.

Langfuse no sólo ofrece un método sistemático para LLM interacción, pero además transforma el proceso de mejora en una disciplina de ingeniería iterativa basada en datos en emplazamiento de prueba y error.

Primeros pasos con Langfuse

Antiguamente de poder comenzar a usar Langfuse, primero debe instalar la biblioteca cliente y configurarla para transmitir datos a una instancia de Langfuse, que podría estar alojada en la aglomeración o autohospedada.

Instalación

Langfuse tiene bibliotecas cliente disponibles tanto para Python como para JavaScript/TypeScript.

Cliente Python

pip install langfuse 

Cliente JavaScript/TypeScript

npm install langfuse 

O

yarn add langfuse 

Configuración

Luego de la instalación, recuerde configurar el cliente con las claves y el host de su tesina. Puede encontrarlos en la configuración de su tesina Langfuse.

• clave_publica: Esto es para aplicaciones frontend o para casos en los que solo se envían datos limitados y no confidenciales.
• clave_secreta: Esto es para aplicaciones backend y escenarios donde la observabilidad total, incluidas las entradas/panorama sensibles, es un requisito.
• huésped: Esto se refiere a la URL de su instancia de Langfuse (por ejemplo, https://cloud.langfuse.com).
• hábitat: Esta es una esclavitud opcional que se puede utilizar para distinguir entre diferentes entornos (por ejemplo, producción, preparación, mejora).

Por razones de seguridad y flexibilidad, se considera una buena maña definirlas como variables de entorno.

export LANGFUSE_PUBLIC_KEY="pk-lf-..." 
export LANGFUSE_SECRET_KEY="sk-lf-..." 
export LANGFUSE_HOST="https://cloud.langfuse.com" 
export LANGFUSE_ENVIRONMENT="development"

Luego, inicialice el cliente Langfuse en su aplicación:

Ejemplo de Python

from langfuse import Langfuse
import os

langfuse = Langfuse(public_key=os.environ.get("LANGFUSE_PUBLIC_KEY"),    secret_key=os.environ.get("LANGFUSE_SECRET_KEY"),    host=os.environ.get("LANGFUSE_HOST"))

Ejemplo de JavaScript/TypeScript

import { Langfuse } from "langfuse";

const langfuse = new Langfuse({  publicKey: process.env.LANGFUSE_PUBLIC_KEY,  secretKey: process.env.LANGFUSE_SECRET_KEY,  host: process.env.LANGFUSE_HOST});

Configurando su primer rastreo

La dispositivo fundamental de observabilidad en Langfuse es la traza. Un seguimiento normalmente representa una única interacción de agraciado o un ciclo de vida completo de una solicitud. En el interior de un seguimiento, registra llamadas LLM individuales (reproducción) y pasos computacionales arbitrarios (intervalo).

Ilustremos con una simple emplazamiento LLM usando API de OpenAI.

Ejemplo de Python

import os
from openai import OpenAI
from langfuse import Langfuse
from langfuse.model import InitialGeneration

# Initialize Langfuse
langfuse = Langfuse(
    public_key=os.environ.get("LANGFUSE_PUBLIC_KEY"),
    secret_key=os.environ.get("LANGFUSE_SECRET_KEY"),
    host=os.environ.get("LANGFUSE_HOST"),
)

# Initialize OpenAI client
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def simple_llm_call_with_trace(user_input: str):
    # Start a new trace
    trace = langfuse.trace(
        name="simple-query",
        input=user_input,
        metadata={"user_id": "user-123", "session_id": "sess-abc"},
    )

    try:
        # Create a generation within the trace
        generation = trace.generation(
            name="openai-generation",
            input=user_input,
            model="gpt-4o-mini",
            model_parameters={"temperature": 0.7, "max_tokens": 100},
            metadata={"prompt_type": "standard"},
        )

        # Make the presente LLM call
        chat_completion = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=({"role": "user", "content": user_input}),
            temperature=0.7,
            max_tokens=100,
        )

        response_content = chat_completion.choices(0).message.content

        # Update generation with the output and usage
        generation.update(
            output=response_content,
            completion_start_time=chat_completion.created,
            usage={
                "prompt_tokens": chat_completion.usage.prompt_tokens,
                "completion_tokens": chat_completion.usage.completion_tokens,
                "total_tokens": chat_completion.usage.total_tokens,
            },
        )

        print(f"LLM Response: {response_content}")
        return response_content

    except Exception as e:
        # Record errors in the trace
        trace.update(
            level="ERROR",
            status_message=str(e)
        )
        print(f"An error occurred: {e}")
        raise

    finally:
        # Ensure all data is sent to Langfuse before exit
        langfuse.flush()


# Example call
simple_llm_call_with_trace("What is the haber of France?")

Eventualmente, su venidero paso posteriormente de ejecutar este código sería ir a la interfaz de Langfuse. Habrá una nueva «consulta simple» de seguimiento que consta de una reproducción de «reproducción openai». Es posible hacer clic en él para ver la entrada, la salida, el maniquí utilizado y otros metadatos.

Funcionalidad principal en detalle

Instruirse a trabajar con objetos de seguimiento, extensión y reproducción es el principal requisito para usar Langfuse.

Seguimiento de llamadas de LLM

• langfuse.trace(): Este comando inicia un nuevo rastreo. El contenedor de primer nivel para toda una operación.
  • nombre: Nombre muy descriptivo de la traza.
  • aporte: La primera entrada de todo el procedimiento.
  • metadatos: un diccionario de cualquier par clave-valor para filtrado y observación (p. ej., user_id, session_id, AB_test_variant).
  • id_sesión: (Opcional) Un identificador compartido por todos los seguimientos que provienen de la misma sesión de agraciado.
  • ID_usuario: (Opcional) Un identificador compartido por todas las interacciones de un agraciado en particular.

• trace.span(): Este es un paso metódico u operación último adentro de un seguimiento que no es una interacción directa de entrada-salida con el LLM. De esta modo se pueden rastrear llamadas a herramientas, búsquedas en bases de datos o cálculos complejos.
  • nombre: Nombre del intervalo (por ejemplo, “retrieve-docs”, “parse-json”).
  • aporte: La entrada relevante para este gazapo.
  • producción: La salida creada por este gazapo.
  • metadatos: Los metadatos del intervalo tienen el formato adicional.
  • nivel: El nivel de alcance (INFO, ADVERTENCIA, ERROR, DEPURACIÓN).
  • mensaje_estado: un mensaje vinculado al estado (por ejemplo, detalles del error).
  • id_observación_padre: conecta este tramo a un tramo principal o traza para estructuras anidadas.

• trace.generation(): Significa una invocación LLM particular.
  • nombre: El nombre de la reproducción (por ejemplo, “respuesta original”, “paso de refinamiento”).
  • aporte: El mensaje o mensajes que se comunicaron al LLM.
  • producción: La respuesta recibida del LLM.
  • maniquí: El maniquí LLM preciso que se empleó (por ejemplo, “gpt-4o-mini“, “claude-3-opus“).
  • parámetros_modelo: Un diccionario de parámetros de maniquí particulares (como temperature, max_tokens, top_p).
  • uso: Un diccionario que muestra la cantidad de tokens utilizados (prompt_tokens, completion_tokens, total_tokens).
  • metadatos: Metadatos adicionales para la invocación de LLM.
  • id_observación_padre: vincula esta reproducción a un tramo o seguimiento principal.
  • inmediato: (Opcional) Puede identificar una plantilla de aviso particular que esté bajo distribución en Langfuse.

Conclusión

Langfuse hace que el mejora y mantenimiento de aplicaciones basadas en LLM sea una tarea menos agotadora al convertirlo en un proceso estructurado y basado en datos. Para ello, brinda a los desarrolladores entrada a las interacciones con el LLM como nunca antaño a través de un seguimiento minucioso, una evaluación sistemática y una potente dirección rápida.

Por otra parte, anima a los desarrolladores a depurar su trabajo con certeza, acelerar el proceso de iteración y seguir mejorando sus productos de IA en términos de calidad y rendimiento. Por lo tanto, Langfuse proporciona los instrumentos necesarios para certificar que las aplicaciones LLM sean confiables, rentables y efectivamente poderosas, sin importar si está desarrollando un chatbot cardinal o un agente autónomo sofisticado.

Preguntas frecuentes