Erste Schritte mit Langfuse (Leitfaden 2026)

Die Erstellung und Bereitstellung von Anwendungen, die Massive Language Fashions (LLMs) nutzen, bringt ihre eigenen Probleme mit sich. LLMs sind nicht-deterministischer Natur, können believable, aber falsche Informationen generieren und die Verfolgung ihrer Aktionen in verschachtelten Sequenzen kann sehr mühsam sein. In diesem Leitfaden werden wir sehen, wie sich Langfuse als wesentliches Instrument zur Lösung dieser Probleme erweist, indem es eine solide Grundlage für die vollständige Beobachtbarkeit, Bewertung und schnelle Bearbeitung von LLM-Anwendungen bietet.

Was ist Langfuse?

Langfuse ist eine bahnbrechende Beobachtbarkeits- und Bewertungsplattform, die Open Supply ist und speziell für LLM-Anwendungen entwickelt wurde. Es ist die Grundlage für die Verfolgung, Anzeige und Fehlerbehebung aller Phasen einer LLM-Interaktion, angefangen von der ersten Aufforderung bis hin zur endgültigen Antwort, unabhängig davon, ob es sich um einen einfachen Anruf oder ein kompliziertes Gespräch mit mehreren Gesprächen zwischen Agenten handelt.

Langfuse ist nicht nur ein Protokollierungstool, sondern auch ein Mittel zur systematischen Bewertung der LLM-Leistung, zum A/B-Testen von Eingabeaufforderungen und zum Sammeln von Benutzerfeedback, was wiederum dazu beiträgt, die Feedbackschleife zu schließen, die für iterative Verbesserungen unerlässlich ist. Der Hauptvorteil liegt in der Transparenz, die es in die LLM-Welt bringt und den Entwicklern so ermöglicht:

• LLM-Verhalten verstehen: Informieren Sie sich über die genauen gesendeten Aufforderungen, die eingegangenen Antworten und die Zwischenschritte in einer mehrstufigen Bewerbung.
• Probleme finden: Lokalisieren Sie schnell die Quelle von Fehlern, geringer Leistung oder unerwarteten Ausgaben.
• Qualitätsbewertung: Die Wirksamkeit von LLM-Antworten kann anhand der vordefinierten Metriken sowohl manuell als auch automatisiert gemessen werden.
• Verfeinern und verbessern: Datengesteuerte Erkenntnisse können zur Perfektionierung von Eingabeaufforderungen, Modellen und Anwendungslogik genutzt werden.
• Behandeln Sie Eingabeaufforderungen: Kontrollieren Sie die Model der Eingabeaufforderungen und testen Sie sie, um das beste LLM zu erhalten.

Hauptmerkmale und Konzepte

Langfuse bietet verschiedene Hauptfunktionen wie:

1. Rückverfolgung und Überwachung

Langfuse hilft uns dabei, die detaillierten Spuren jeder Interaktion zu erfassen, die LLM durchführt. Der „Hint“ ist im Grunde die Darstellung einer Finish-to-Finish-Benutzeranfrage oder eines Anwendungsflusses. Innerhalb eines Hint werden logische Arbeitseinheiten durch „Spans“ bezeichnet und Aufrufe eines LLM beziehen sich auf „Generationen“.

2. Auswertung

Langfuse ermöglicht die Auswertung sowohl manuell als auch programmgesteuert. Von den Entwicklern können benutzerdefinierte Metriken definiert werden, mit denen dann Auswertungen für verschiedene Datensätze durchgeführt und dann als LLM-basierte Evaluatoren integriert werden können.

3. Prompte Verwaltung

Langfuse bietet direkte Kontrolle über das Immediate-Administration sowie Speicher- und Versionierungsfunktionen. Es ist möglich, verschiedene Eingabeaufforderungen durch A/B-Checks zu testen und gleichzeitig die Genauigkeit über verschiedene Orte hinweg aufrechtzuerhalten, was auch den Weg für eine datengesteuerte Eingabeaufforderungsoptimierung ebnet.

4. Suggestions-Sammlung

Langfuse nimmt die Benutzervorschläge auf und integriert sie direkt in Ihre Spuren. Sie können bestimmte Bemerkungen oder Benutzerbewertungen mit der genauen LLM-Interaktion verknüpfen, die zu einer Ausgabe geführt hat, und uns so in Echtzeit Suggestions zur Fehlerbehebung und Verbesserung geben.

Warum Langfuse? Das Downside, das es löst

Herkömmliche Software program-Observability-Instruments weisen sehr unterschiedliche Eigenschaften auf und erfüllen die Kriterien für LLM-basierte Anwendungen in folgenden Aspekten nicht:

• Nichtdeterminismus: LLMs liefern selbst bei identischer Eingabe nicht immer das gleiche Ergebnis, was das Debuggen zu einer ziemlichen Herausforderung macht. Langfuse wiederum zeichnet die Eingaben und Ausgaben jeder Interaktion auf und liefert so ein klares Bild des Vorgangs in diesem Second.
• Sofortige Empfindlichkeit: Jede geringfügige Änderung an einer Eingabeaufforderung kann die Antwort von LLM vollständig ändern. Langfuse hilft dabei, den Überblick über Immediate-Versionen und deren Leistungsmetriken zu behalten.
• Komplexe Ketten: Die meisten LLM-Anwendungen zeichnen sich durch eine Kombination aus mehreren LLM-Aufrufen, verschiedenen Instruments und dem Abrufen von Daten (z. B. LAPPEN Architekturen). Die einzige Möglichkeit, den Fluss zu kennen und die Stelle zu lokalisieren, an der der Engpass oder der Fehler liegt, ist die Rückverfolgung. Langfuse präsentiert eine visuelle Zeitleiste für diese Interaktionen.
• Subjektive Qualität: Der Begriff „intestine“ für die Antwort eines LLM ist oft gleichbedeutend mit persönlicher Meinung. Langfuse ermöglicht sowohl objektive (z. B. Latenz, Token-Anzahl) als auch subjektive (menschliches Suggestions, LLM-basierte Bewertung) Qualitätsbewertungen.
• Kostenmanagement: Der Aufruf von LLM-APIs ist mit einem Preis verbunden. Das Verstehen und Optimieren Ihrer Kosten wird einfacher, wenn Langfuse Ihre Token-Nutzung und Ihr Anrufvolumen überwacht.
• Mangelnde Sichtbarkeit: Der Entwickler kann nicht sehen, wie sich seine LLM-Anwendungen auf dem Markt entwickeln, und daher ist es für ihn aufgrund der mangelnden Beobachtbarkeit schwierig, diese Anwendungen schrittweise zu verbessern.

Langfuse bietet nicht nur eine systematische Methode für LLM Interaktion, aber es verwandelt den Entwicklungsprozess auch in eine datengesteuerte, iterative Ingenieursdisziplin statt in Versuch und Irrtum.

Erste Schritte mit Langfuse

Bevor Sie Langfuse verwenden können, müssen Sie zunächst die Consumer-Bibliothek installieren und für die Übertragung von Daten an eine Langfuse-Instanz einrichten, bei der es sich entweder um eine in der Cloud gehostete oder eine selbst gehostete Instanz handeln kann.

Set up

Langfuse verfügt über Consumer-Bibliotheken, die sowohl für Python als auch für JavaScript/TypeScript verfügbar sind.

Python-Consumer

pip set up langfuse 

JavaScript/TypeScript-Consumer

npm set up langfuse 

Oder

yarn add langfuse 

Konfiguration

Denken Sie nach der Set up daran, den Consumer mit Ihren Projektschlüsseln und Ihrem Host einzurichten. Sie finden diese in Ihren Langfuse-Projekteinstellungen.

• public_key: Dies gilt für Frontend-Anwendungen oder für Fälle, in denen nur begrenzte und nicht vertrauliche Daten gesendet werden.
• geheimer_Schlüssel: Dies gilt für Backend-Anwendungen und -Szenarien, bei denen die vollständige Beobachtbarkeit, einschließlich sensibler Ein-/Ausgaben, erforderlich ist.
• Gastgeber: Dies bezieht sich auf die URL Ihrer Langfuse-Instanz (z. B. https://cloud.langfuse.com).
• Umfeld: Dies ist eine optionale Zeichenfolge, die zur Unterscheidung zwischen verschiedenen Umgebungen (z. B. Produktion, Staging, Entwicklung) verwendet werden kann.

Aus Sicherheits- und Flexibilitätsgründen wird es als bewährte Praxis angesehen, diese als Umgebungsvariablen zu definieren.

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

Initialisieren Sie dann den Langfuse-Consumer in Ihrer Anwendung:

Python-Beispiel

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"))

JavaScript/TypeScript-Beispiel

import { Langfuse } from "langfuse";

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

Einrichten Ihres ersten Hint

Die grundlegende Einheit der Beobachtbarkeit in Langfuse ist die Spur. Ein Hint stellt typischerweise eine einzelne Benutzerinteraktion oder einen vollständigen Anforderungslebenszyklus dar. Innerhalb eines Hint protokollieren Sie einzelne LLM-Aufrufe (Generierung) und beliebige Rechenschritte (Span).

Lassen Sie uns dies anhand eines einfachen LLM-Aufrufs veranschaulichen OpenAIs API.

Python-Beispiel

import os
from openai import OpenAI
from langfuse import Langfuse
from langfuse.mannequin 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 consumer
consumer = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def simple_llm_call_with_trace(user_input: str):
    # Begin a brand new hint
    hint = langfuse.hint(
        identify="simple-query",
        enter=user_input,
        metadata={"user_id": "user-123", "session_id": "sess-abc"},
    )

    strive:
        # Create a technology throughout the hint
        technology = hint.technology(
            identify="openai-generation",
            enter=user_input,
            mannequin="gpt-4o-mini",
            model_parameters={"temperature": 0.7, "max_tokens": 100},
            metadata={"prompt_type": "customary"},
        )

        # Make the precise LLM name
        chat_completion = consumer.chat.completions.create(
            mannequin="gpt-4o-mini",
            messages=({"function": "person", "content material": user_input}),
            temperature=0.7,
            max_tokens=100,
        )

        response_content = chat_completion.decisions(0).message.content material

        # Replace technology with the output and utilization
        technology.replace(
            output=response_content,
            completion_start_time=chat_completion.created,
            utilization={
                "prompt_tokens": chat_completion.utilization.prompt_tokens,
                "completion_tokens": chat_completion.utilization.completion_tokens,
                "total_tokens": chat_completion.utilization.total_tokens,
            },
        )

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

    besides Exception as e:
        # Document errors within the hint
        hint.replace(
            degree="ERROR",
            status_message=str(e)
        )
        print(f"An error occurred: {e}")
        elevate

    lastly:
        # Guarantee all knowledge is distributed to Langfuse earlier than exit
        langfuse.flush()


# Instance name
simple_llm_call_with_trace("What's the capital of France?")

Schließlich besteht Ihr nächster Schritt nach der Ausführung dieses Codes darin, zur Langfuse-Schnittstelle zu wechseln. Es wird einen neuen Hint „simple-query“ geben, der aus einer Technology „openai-generation“ besteht. Sie können darauf klicken, um die Eingabe, Ausgabe, das verwendete Modell und andere Metadaten anzuzeigen.

Kernfunktionen im Element

Das Erlernen des Umgangs mit Hint-, Span- und Generierungsobjekten ist die wichtigste Voraussetzung, um Langfuse nutzen zu können.

LLM-Anrufe verfolgen

• langfuse.hint(): Dieser Befehl startet einen neuen Hint. Der Container der obersten Ebene für einen gesamten Vorgang.
  • Identify: Der sehr aussagekräftige Identify der Spur.
  • Eingang: Die erste Eingabe des gesamten Verfahrens.
  • Metadaten: Ein Wörterbuch beliebiger Schlüssel-Wert-Paare zum Filtern und Analysieren (z. B. user_id, session_id, AB_test_variant).
  • Sitzungs-ID: (Optionally available) Eine Kennung, die von allen Traces gemeinsam genutzt wird, die aus derselben Benutzersitzung stammen.
  • Benutzer-ID: (Optionally available) Eine Kennung, die von allen Interaktionen eines bestimmten Benutzers gemeinsam genutzt wird.

• hint.span(): Dies ist ein logischer Schritt oder eine kleinere Operation innerhalb eines Hint, bei dem es sich nicht um eine direkte Eingabe-Ausgabe-Interaktion mit dem LLM handelt. Toolaufrufe, Datenbankabfragen oder komplexe Berechnungen können so nachvollzogen werden.
  • Identify: Identify des Spans (z. B. „retrieve-docs“, „parse-json“).
  • Eingang: Die für diese Spanne relevante Eingabe.
  • Ausgabe: Die von dieser Spanne erstellte Ausgabe.
  • Metadaten: Die Span-Metadaten werden als zusätzlich formatiert.
  • Ebene: Der Schweregrad (INFO, WARNUNG, FEHLER, DEBUG).
  • status_message: Eine Meldung, die mit dem Standing verknüpft ist (z. B. Fehlerdetails).
  • parent_observation_id: Verbindet diesen Span mit einem übergeordneten Span oder Hint für verschachtelte Strukturen.

• hint.technology(): Bezeichnet einen bestimmten LLM-Aufruf.
  • Identify: Der Identify der Technology (zum Beispiel „initial-response“, „refinement-step“).
  • Eingang: Die Eingabeaufforderung oder Nachrichten, die an das LLM übermittelt wurden.
  • Ausgabe: Die vom LLM erhaltene Antwort.
  • Modell: Das genaue LLM-Modell, das verwendet wurde (zum Beispiel „gpt-4o-mini„, „Claude-3-Opus“).
  • Modellparameter: Ein Wörterbuch bestimmter Modellparameter (wie temperature, max_tokens, top_p).
  • Verwendung: Ein Wörterbuch, das die Anzahl der verwendeten Token anzeigt (prompt_tokens, completion_tokens, total_tokens).
  • Metadaten: Zusätzliche Metadaten für den LLM-Aufruf.
  • parent_observation_id: Verknüpft diese Technology mit einem übergeordneten Span oder Hint.
  • immediate: (Optionally available) Kann eine bestimmte Eingabeaufforderungsvorlage identifizieren, die in Langfuse verwaltet wird.

Abschluss

Langfuse macht die Entwicklung und Wartung von LLM-basierten Anwendungen zu einem weniger anstrengenden Unterfangen, indem es sie in einen strukturierten und datengesteuerten Prozess umwandelt. Dies wird erreicht, indem Entwicklern durch umfassende Nachverfolgung, systematische Auswertung und leistungsstarkes Immediate-Administration wie nie zuvor Zugriff auf die Interaktionen mit dem LLM gewährt wird.

Darüber hinaus ermutigt es die Entwickler, ihre Arbeit mit Sicherheit zu debuggen, den Iterationsprozess zu beschleunigen und ihre KI-Produkte in Bezug auf Qualität und Leistung weiter zu verbessern. Daher stellt Langfuse die notwendigen Instrumente bereit, um sicherzustellen, dass LLM-Anwendungen vertrauenswürdig, kostengünstig und wirklich leistungsstark sind, unabhängig davon, ob Sie einen einfachen Chatbot oder einen anspruchsvollen autonomen Agenten entwickeln.

Häufig gestellte Fragen

Knowledge Science Trainee bei Analytics Vidhya
Derzeit arbeite ich als Knowledge Science Trainee bei Analytics Vidhya, wo ich mich auf die Entwicklung datengesteuerter Lösungen und die Anwendung von KI/ML-Techniken zur Lösung realer Geschäftsprobleme konzentriere. Meine Arbeit ermöglicht es mir, fortschrittliche Analysen, maschinelles Lernen und KI-Anwendungen zu erforschen, die es Unternehmen ermöglichen, intelligentere, evidenzbasierte Entscheidungen zu treffen.
Mit einem starken Fundament in den Bereichen Informatik, Softwareentwicklung und Datenanalyse ist es mir eine Leidenschaft, KI zu nutzen, um wirkungsvolle, skalierbare Lösungen zu schaffen, die die Lücke zwischen Technologie und Geschäft schließen.
📩 Du kannst mich auch erreichen unter (e-mail protected)