Langfuse: LLM Observability, Kosten und Qualität überwachen

Inhalt

Langfuse ist eine Open-Source-Plattform für LLM-Engineering, die aufzeichnet, was Ihre LLM-Anwendung tatsächlich tut. Sie erfasst den vollständigen Kontext jeder Ausführung, also Prompts, Completions, Retrieval-Schritte und Tool-Aufrufe, und bietet darauf aufbauend Evaluierungen, Datasets und Prompt-Management. Damit können Sie einen halluzinierenden Chatbot oder einen Agenten, der sich falsch verhält, anhand von Daten debuggen, statt zu raten.

In diesem Beitrag hosten wir Langfuse mit Docker Compose selbst und gehen die wichtigsten Open-Source-Funktionen durch: OpenAI-Aufrufe tracen, sie zu Traces, Sessions und Benutzern bündeln, das Dashboard, manuelle Evaluierungen, Datasets und Prompt-Management. Ein ähnliches Werkzeug, Opik (auf Englisch), haben wir bereits vorgestellt, das ist also eine gute Gelegenheit zum Vergleich.

Warum KI-Anwendungen und Agenten schwer zu debuggen sind

KI-Anwendungen, besonders solche mit autonomen Agenten, bringen Probleme mit sich, für die die klassischen Werkzeuge der Softwareentwicklung nicht gemacht sind.

Das Blackbox-Problem

In herkömmlicher Software liefert dieselbe Eingabe zuverlässig dieselbe Ausgabe. LLMs sind unberechenbar. Eine kleine Änderung in der Formulierung kann das Verhalten des Modells stark verändern, und selbst identische Prompts können je nach Sampling-Parametern unterschiedliche Antworten liefern. Ohne spezielle Werkzeuge ist es fast unmöglich nachzuvollziehen, was in Ihrer Anwendung passiert.

Komplexe Ausführungspfade entwirren

Moderne KI-Anwendungen bestehen selten aus einfachen Paaren von Prompt und Antwort. Meist laufen Abfolgen aus

• mehreren LLM-Aufrufen mit unterschiedlichem Kontext,
• Retrieval-Schritten, die Daten aus verschiedenen Quellen holen,
• Tool-Aufrufen und API-Interaktionen,
• Verzweigungen abhängig von den Ausgaben des Modells sowie
• paralleler und asynchroner Verarbeitung.

Wenn etwas schiefgeht, und das wird es, ist schwer festzustellen, wo der Fehler passiert ist. Hat das Retrieval irrelevanten Kontext geliefert? Hat der Agent das falsche Tool gewählt? Enthielt der eigentliche Denkschritt einen logischen Fehler? Ohne Einblick in jeden Schritt wird Debugging zu frustrierendem Rätselraten.

Die Qualität von LLM-Ausgaben messen

Klassische Software verlässt sich auf Unit-Tests, die entweder bestehen oder scheitern. Die Qualität von LLM-Ausgaben ist dagegen oft subjektiv, und "richtig" ist eine Frage des Grades. Ist eine Antwort korrekt, aber nicht hilfreich? Hilfreich, aber nicht korrekt? Beides, aber schlecht formatiert? Erfolgskriterien festzulegen ist schwer, und das Fehlen standardisierter Evaluierungs-Frameworks macht es nicht leichter.

LLM-Anwendungen werden im Betrieb schlechter

LLM-Anwendungen verschlechtern sich im produktiven Betrieb oft auf eine Weise, die in der Entwicklungsumgebung nie sichtbar wird:

• Nutzer stellen Fragen, mit denen die Entwickler nie gerechnet haben.
• Externe APIs und Tools ändern ihr Verhalten.
• Die zugrunde liegenden Modelle selbst bekommen Updates.
• Es tauchen Grenzfälle auf, die in den Tests nicht vorkamen.

Ohne laufendes Monitoring und Evaluierung kann eine Anwendung, die in der Entwicklung einwandfrei lief, im echten Einsatz schnell unzuverlässig werden.

KI-Agenten debuggen

Bei agentenbasierten Systemen vervielfachen sich diese Probleme. Agenten entscheiden selbst, welche Aktionen sie ausführen, und daraus ergibt sich eine riesige Zahl möglicher Ausführungspfade. Wenn ein Agent in einer Schleife hängen bleibt, die falschen Tools wählt oder sein Ziel nicht erreicht, ist es sehr schwierig zu rekonstruieren, was passiert ist und warum.

Eingaben und Ausgaben klassisch zu loggen reicht nicht. Sie brauchen Tracing des Entscheidungsprozesses: die Denkschritte des Agenten, die Wahl der Tools, Zwischenergebnisse und den vollständigen Kontext hinter jeder Entscheidung. (Mehr dazu in unserem Beitrag über zuverlässige KI-Agenten-Systeme.)

Der Engpass beim Iterieren

Zusammen bremsen diese Probleme das Iterieren aus. Ohne klaren Einblick in das Geschehen beruhen Verbesserungen auf Vermutungen statt auf Daten. Teams fragen sich dann:

• Welche Prompts müssen überarbeitet werden?
• Wo sollten wir mit der Optimierung ansetzen?
• Passen die gewählten Modelle zu den jeweiligen Aufgaben?
• Wie messen wir, ob Änderungen wirklich Verbesserungen sind?

Ohne Antworten wird der Entwicklungszyklus langsam und teuer. LLM-Anwendungen brauchen Werkzeuge, die für genau diese Probleme gebaut sind, mit Observability, Evaluierung und systematischer Verbesserung in jeder Phase der Entwicklung.

Was ist Langfuse?

Langfuse ist eine Open-Source-Plattform für LLM-Engineering mit Werkzeugen, um KI-Anwendungen zu debuggen, zu analysieren und systematisch zu verbessern. Im Kern ist Langfuse eine Observability-Schicht, die den vollständigen Ausführungskontext von Sprachmodell-Anwendungen erfasst, vom einfachen Chatbot bis zum komplexen autonomen Agenten.

Anders als allgemeine Logging- oder Monitoring-Werkzeuge ist Langfuse für die oben beschriebenen Probleme der LLM-Entwicklung gebaut. Traces stehen im Mittelpunkt, sodass Sie die hierarchischen, oft nichtlinearen Ausführungspfade moderner KI-Anwendungen visualisieren können. Jeder LLM-Aufruf, jeder Retrieval-Schritt, jeder Tool-Aufruf und jeder Zwischenschritt im Denken lässt sich mit vollem Kontext erfassen. So entsteht ein detailliertes Protokoll dessen, was während der Ausführung passiert ist.

Die Plattform hat vier integrierte Komponenten, die den Lebenszyklus der LLM-Entwicklung abdecken:

1. Observability: Schlanke SDKs und Framework-Integrationen zeichnen Prompts, Completions, Metadaten und die Beziehungen zwischen den Ausführungsschritten auf.

2. Prompt-Management: Prompts zentral speichern, versionieren und weiterentwickeln, getrennt vom Anwendungscode. So können Sie experimentieren, ohne neu zu deployen.

3. Evaluierungen: die Qualität der Ausgaben mit LLM-as-a-Judge, Nutzerfeedback, manuellem Labeling oder eigenen Evaluierungs-Pipelines bewerten.

4. Datasets: Benchmarks aus Produktivdaten, Testsets oder synthetischen Beispielen aufbauen, um die Leistung der Anwendung über Versionen hinweg zu vergleichen.

Was Langfuse von anderen Werkzeugen abhebt, ist die enge Verzahnung dieser Komponenten. Ein problematischer Trace aus dem Produktivbetrieb lässt sich sofort in ein Dataset übernehmen, mit LLM-as-a-Judge bewerten, durch bessere Prompts beheben und vor dem Deployment prüfen, alles in derselben Plattform.

Langfuse unterstützt Python, JavaScript/TypeScript und verbreitete Frameworks wie LangChain, LlamaIndex und das OpenAI-SDK. Es ist vollständig Open Source (MIT-Lizenz) und lässt sich selbst hosten oder als Managed Service über Langfuse Cloud nutzen. Für Teams mit besonderen Compliance-Anforderungen gibt es Hosting in der EU und in den USA.

Langfuse betreiben

Langfuse dokumentiert mehrere Wege, die Plattform selbst zu betreiben:

• Mit Docker oder Docker Compose

• Auf Kubernetes

• Auf Railway

Für ein Testsetup verwenden wir in diesem Beitrag die Docker-Compose-Konfiguration.

1. Klonen Sie das Langfuse-Repository:

1git clone https://github.com/langfuse/langfuse.git
2cd langfuse

2. Öffnen Sie die Datei docker-compose.yml und setzen Sie alle Umgebungsvariablen, die mit # Change me markiert sind, auf eigene Werte. Das sind Secrets, mit denen die einzelnen Dienste eingerichtet und verbunden werden. Bei der ersten Einrichtung können Sie beliebige Werte wählen.

3. Starten Sie die Dienste mit folgendem Befehl:

1docker compose up -d

Das war es: Wir haben eine laufende Langfuse-Instanz mit diesen Diensten:

• langfuse worker
• langfuse web
• clickhouse
• minio
• redis
• postgres

Nichts Ungewöhnliches, aber bedenken Sie, dass Langfuse einige Dienste braucht. Für den produktiven Betrieb benötigen Sie eine ordentliche Umgebung, in der alle diese Dienste konfiguriert sind und laufen.

Die Funktionen von Langfuse

Langfuse läuft, sehen wir uns also die Funktionen an.

Tracing

Die Hauptfunktion von Langfuse ist, wenig überraschend, Tracing: Langfuse zeichnet die Ausführung Ihrer LLM-Anwendung auf und visualisiert sie.

Das geht ganz einfach:

1. Installieren Sie die nötigen Pakete (wir verwenden ein OpenAI-Modell):

   1pip install langfuse openai
   

2. Legen Sie in Ihrer Langfuse-Instanz ein neues Projekt an und holen Sie sich Secret Key und Public Key.

   Klicken Sie in der Übersicht Ihrer Organisation auf "New Project" und füllen Sie das Formular aus. Neues Projekt im Einrichtungsassistenten von Langfuse anlegen

   Klicken Sie im nächsten Schritt auf "Create API Key". Dann werden Public und Secret Key angezeigt. Kopieren Sie beide. API-Keys im Einrichtungsassistenten von Langfuse anlegen

3. Legen Sie eine .env-Datei an:

   1LANGFUSE_SECRET_KEY="sk-lf-..." # privater Schlüssel
   2LANGFUSE_PUBLIC_KEY="pk-lf-..." # öffentlicher Schlüssel
   3LANGFUSE_HOST="https://<your-langfuse-instance>.com" # Ihre Langfuse-Instanz
   

4. Sorgen Sie dafür, dass Ihr Projekt die Umgebungsvariablen lädt. Importieren Sie dann statt des SDK selbst den Langfuse-Wrapper Ihres KI-SDK. Für OpenAI sieht das so aus:

   1from langfuse.openai import openai # OpenAI-Integration
   2completion = openai.chat.completions.create(
   3    name="my-completion",
   4    model="gpt-4o",
   5    messages=[
   6        {"role": "system", "content": "You are a helpful assistant."},
   7        {"role": "user", "content": "What is the capital of France?"}
   8    ],
   9)
   

   Hinweis: Mehr braucht es nicht, um Ihre LLM-Aufrufe zu tracen. Jeder Aufruf an OpenAI wird jetzt samt Latenz und Kosten protokolliert. Allerdings ist jeder Aufruf ein eigener Trace. Im nächsten Schritt zeigen wir, wie Sie die Aufrufe dort verschachteln, wo Sie es möchten.

Unser erster Trace in Langfuse

Mehrere LLM-Aufrufe in einem Trace bündeln

Wenn Ihre Anwendung pro Anfrage mehrere LLM-Aufrufe macht, möchten Sie diese gebündelt sehen. Ein Chat-Agent braucht zum Beispiel wahrscheinlich einen Aufruf, um relevante Informationen herauszuziehen, einen weiteren, um zu entscheiden, welche Tools er nutzt, und einen letzten, um die Antwort zu formulieren. Bündeln Sie diese Aufrufe, haben Sie eine einzelne Benutzerinteraktion im Überblick.

Langfuse bietet dafür zwei Möglichkeiten:

1. Sie geben den OpenAI-Aufrufen eine eigene Trace-ID mit.

   1import uuid
   2
   3my_trace_id = str(uuid.uuid4()) # eigene Trace-ID erzeugen
   4
   5completion = openai.chat.completions.create(
   6    name="my-completion",
   7    model="gpt-4o",
   8    messages=[
   9        {"role": "system", "content": "You are a helpful assistant."},
   10        {"role": "user", "content": "What is the capital of France?"}
   11    ],
   12    trace_id=my_trace_id,
   13)
   

   Geben Sie allen LLM-Aufrufen, die zusammengehören, dieselbe Trace-ID mit. Meist erzeugen Sie die Trace-ID zu Beginn der Benutzerinteraktion.

   So bekommen Sie am einfachsten ein gutes Bild davon, wie Ihre Anwendung arbeitet. Die trace_id jedem LLM-Aufruf mitzugeben ist aber mühsam. Außerdem sehen Sie nicht, in welchem Schritt oder in welcher Funktion ein LLM-Aufruf stattfand.

2. Der Decorator @observe löst beide Probleme. Langfuse stellt diesen Decorator bereit, um die Funktionen zu umhüllen, in denen Ihre LLM-Aufrufe laufen.

   Setzen Sie den Decorator auf Ihre Funktionen, werden alle LLM-Aufrufe darin gebündelt.

   1 from langfuse.decorators import observe
   2 from langfuse.openai import openai # OpenAI-Integration
   3
   4 @observe()
   5 def call_llm():
   6     return openai.chat.completions.create(
   7         model="gpt-4o",
   8         messages=[
   9           {"role": "system", "content": "You are a helpful assistant."},
   10           {"role": "user", "content": "What is the capital of France?"}
   11         ],
   12     ).choices[0].message.content
   13
   14 @observe()
   15 def main():
   16     return call_llm()
   17
   18 main()
   

   Das Ergebnis ist ein einzelner Trace, der zeigt, welche Funktionen wann aufgerufen wurden, mit den LLM-Aufrufen eine Ebene tiefer.

   Hinweis: Setzen Sie @observe auf jede Funktion, die im Trace erscheinen soll, und zwar über die gesamte Aufrufhierarchie. Wenn main() die Funktion do_something() aufruft und do_something() wiederum call_llm(), müssen Sie alle drei Funktionen dekorieren, um das vollständige Bild zu bekommen.

   Dekorieren Sie nur main() und call_llm(), bekommen Sie zwei getrennte Traces, einen für main() und einen für call_llm() (mit dem LLM-Aufruf als Kind). Achten Sie also darauf, dass alle Funktionen Ihrer Aufrufhierarchie @observe haben.

   Ein Trace mit mehreren LLM-Aufrufen

   Diese Ansicht zeigt auf einen Blick die verbrauchten Tokens, die Latenz und die Kosten jedes LLM-Aufrufs.

Zeitachse eines Traces

Mit dem Schalter "Timeline" in der Trace-Ansicht wechseln Sie zu einer zeitbasierten Übersicht. Sie zeigt, was am längsten gedauert hat, wo die Engpässe liegen, wo Sie parallelisieren und wo Sie Ihren Code optimieren können.

Bei Streaming sehen Sie sogar die Zeit bis zum ersten Token, was für Chat-Anwendungen sehr nützlich ist.

Zeitachse eines Traces

Sessions

In einem Chat-Agenten schicken Nutzer selten nur eine Nachricht. Sie stellen im selben Chat mehrere Fragen und Rückfragen.

Man könnte alle in einem Trace bündeln, aber das ergibt selten Sinn. Meist möchten Sie eine einzelne Frage überwachen und analysieren, und die ist per Definition ein Trace. Trotzdem wollen Sie sehen, wie das gesamte Gespräch verlaufen ist.

Dafür bietet Langfuse Sessions. Eine Session bündelt diese Traces und zeigt das gesamte Gespräch als einfache Wiedergabe.

Sessions sind schnell eingebaut. Aktualisieren Sie mit langfuse_context den aktuellen Trace mit der Session-ID. (Verwenden Sie statt chat-id unten Ihre tatsächliche Chat-Kennung. Die meisten Chat-SDKs liefern eine Chat-ID mit.)

1from langfuse.decorators import langfuse_context, observe
2from langfuse.openai import openai
3
4@observe()
5def call_llm():
6    session_id = "chat-id"
7    langfuse_context.update_current_trace(
8        session_id=session_id,
9    )
10
11    completion = openai.chat.completions.create(
12       name="my-completion",
13       model="gpt-4o",
14       messages=[
15           {"role": "system", "content": "You are a helpful assistant."},
16           {"role": "user", "content": "What is the capital of France?"}
17       ],
18    )
19
20call_llm()

Ohne den Decorator @observe geben Sie die Session-ID direkt beim Aufruf mit:

1    completion = openai.chat.completions.create(
2       name="my-completion",
3       model="gpt-4o",
4       messages=[
5           {"role": "system", "content": "You are a helpful assistant."},
6           {"role": "user", "content": "What is the capital of France?"}
7       ],
8      session_id="chat-id",
9    )

Benutzer

Nach Traces und Sessions sind Benutzer die letzte Ebene der Bündelung.

Benutzerkennungen fügen Sie Ihrem Trace nach demselben Muster wie bei Sessions hinzu, mit dem Parameter user_id.

1from langfuse.decorators import langfuse_context, observe
2from langfuse.openai import openai
3@observe()
4def call_llm():
5    user_id = "user-id"
6    langfuse_context.update_current_trace(
7        user_id=user_id,
8    )
9
10    completion = openai.chat.completions.create(
11       name="my-completion",
12       model="gpt-4o",
13       messages=[
14           {"role": "system", "content": "You are a helpful assistant."},
15           {"role": "user", "content": "What is the capital of France?"}
16       ],
17    )

Langfuse zeigt dann alle Benutzer, was sie verbraucht haben und welche Kosten sie verursacht haben.

Benutzerübersicht. Quelle: https://langfuse.com/docs/observability/features/users

Weitere Tracing-Funktionen

• Metadaten: Fügen Sie Traces eigene Metadaten hinzu, um sie besser zu ordnen und zu filtern.

  1  # Trace-Metadaten von beliebiger Stelle im Call Stack aktualisieren
  2  langfuse_context.update_current_trace(
  3      metadata={"key":"value"}
  4  )
  5
  6  # Metadaten der aktuellen Observation aktualisieren
  7  langfuse_context.update_current_observation(
  8      metadata={"key": "value"}
  9  )
  

• Tags: Ordnen Sie Traces mit Tags in Kategorien ein. Das macht Übersichten und Filter deutlich einfacher.

  1 langfuse_context.update_current_trace(
  2     tags=["tag-1", "tag-2"]
  3 )
  

  Traces in Langfuse nach Tags filtern

• Multimodales Tracing: Erfassen und visualisieren Sie multimodale Daten wie Bilder oder Audio zusammen mit den Text-Traces.

  Multimodaler Trace. Quelle: https://langfuse.com/docs/observability/features/multi-modality

• Sampling: Wenn Sie viele Nutzer haben (was wir Ihnen wünschen), wollen Sie wahrscheinlich nicht jede einzelne Interaktion tracen. Setzen Sie die Umgebungsvariable LANGFUSE_SAMPLE_RATE auf einen Wert zwischen 0 und 1, um nur einen Anteil der Traces aufzuzeichnen. Mit 0.1 werden zum Beispiel 10 % aller Traces erfasst.

  1os.environ["LANGFUSE_SAMPLE_RATE"] = '0.5'
  

• Traces teilen: Teilen Sie Traces mit Ihrem Team oder mit externen Beteiligten, um gemeinsam Fehler zu suchen. Klicken Sie auf das (etwas zu kleine) "Share"-Symbol und dann auf "Share", um einen öffentlichen Link zum Trace zu bekommen.

  Einen Trace in Langfuse per öffentlichem Link teilen

• Native Integrationen: Oft reicht es, die LLM-Aufrufe zu tracen. Langfuse bietet aber auch Dutzende Integrationen mit anderen Werkzeugen, etwa:

  • LangChain
  • LlamaIndex
  • Smolagents (auf Englisch)
  • und viele mehr

  Diese Integrationen bilden das Innenleben eines Frameworks besser ab, als es die einfache Integration auf Ebene der LLM-Aufrufe kann.

  (Der Vollständigkeit halber: Langfuse ist auch vollständig kompatibel mit OpenTelemetry.)

Dashboard

Das Dashboard von Langfuse bietet eine zentrale Sicht auf alle Traces, Sessions und Benutzerinteraktionen. Es zeigt, wie sich Ihre Anwendung und ihre Leistung entwickeln, und hilft, Verschlechterungen über die Zeit zu erkennen. Es enthält die Zahl der Traces, die Kosten pro Modell, Scores sowie Latenz-Perzentile für Traces, Generations und Spans.

Ein, zwei Bilder sagen mehr als tausend Worte:

Langfuse-Dashboard mit Anzahl der Traces, Modellkosten und Modellnutzung

Langfuse-Dashboard mit Latenzen von Traces, Generations, Spans und Modellen

Evaluierungen

Mit den Evaluierungen in Langfuse bewerten Sie die Qualität Ihrer LLM-Ausgaben systematisch. Im Folgenden bewerten wir Traces durch manuelle Annotation. (Automatische RAG-Metriken behandelt unser Beitrag dazu, wie Sie RAG-Qualität mit RAGAS messen.)

Klicken Sie in den Projekteinstellungen auf Scores/Evaluations und legen Sie eine neue Score-Konfiguration an. Sie legt fest, wie Sie Ihre Traces bewerten möchten (etwa mit Zahlen oder Labels).

Eine neue Score-Konfiguration anlegen

Klicken Sie dann in der Trace-Ansicht auf den Button Annotate (die kleine Sprechblase) und wählen Sie die gewünschte Score-Konfiguration.

Einen Trace annotieren: Score-Konfiguration auswählen

Geben Sie Ihren Score ein (oder wählen Sie je nach Konfiguration ein Label) und ergänzen Sie optional einen Kommentar. Mit Save speichern Sie den Score.

Einen Trace annotieren: Score eintragen

Unter Tracing → Scores finden Sie eine Übersicht aller Scores. Mit Filtern und Sortierung sehen Sie, ob sich Ihre Scores mit der Zeit verschlechtern oder verbessern.

Übersicht der Scores

Datasets

Datasets in Langfuse sind Testsets und Benchmarks, mit denen Sie die Leistung Ihrer LLM-Anwendung bewerten.

Anwendungsfälle (laut der Dokumentation von Langfuse):

• Laufende Verbesserung: Datasets aus Grenzfällen im Produktivbetrieb erstellen, um die Anwendung zu verbessern
• Tests vor dem Deployment: neue Releases vor dem Produktivgang benchmarken
• Strukturiertes Testen: Experimente mit Sammlungen von Eingaben und erwarteten Ausgaben durchführen
• Flexible Evaluierung: eigene Metriken ergänzen oder LLM-as-a-Judge nutzen
• Gute Integration: funktioniert mit verbreiteten Frameworks wie LangChain und LlamaIndex

Datasets sprengen den Rahmen dieses Beitrags, der sich auf das Monitoring konzentriert. Wir verweisen deshalb auf die recht gute Dokumentation zu Datasets.

Prompt-Management

Als letzte Funktion stellen wir das Prompt-Management vor, eine sehr angenehme Ergänzung der Plattform.

Im Menü Prompts können Sie Prompts anlegen und versionieren. So lassen sich Prompts leicht weiterentwickeln und Änderungen über die Zeit nachverfolgen.

Klicken Sie auf Create prompt und füllen Sie das Formular aus. Es erklärt sich von selbst.

Einen neuen Prompt anlegen

Für eine neue Version öffnen Sie den Prompt und klicken im Reiter "Versions" auf "New". Sie bekommen eine übersichtliche Versionshistorie, ähnlich wie in git.

Versionshistorie eines Prompts

Der Reiter Metrics zeigt, wie oft der Prompt über die Zeit genutzt wurde und was er gekostet hat. Wenn Sie die oben beschriebenen Evaluierungen nutzen, sehen Sie dort auch die Scores des Prompts und seiner Versionen.

Versionierung hilft, wenn Sie Prompts von Hand schreiben. Wie Sie Prompts anhand einer Metrik und einiger Beispiele automatisch optimieren lassen, zeigt unser DSPy-Tutorial (auf Englisch).

So verwenden Sie diese Prompts im Code:

1chat_prompt = langfuse.get_prompt("rag-chat-prompt", type="chat")
2
3# Falls Sie Variablen in den Prompt einsetzen müssen
4compiled_chat_prompt = chat_prompt.compile(rag_question="What is...", rag_context="...")

Um den Prompt mit einem Trace zu verknüpfen, geben Sie, Sie ahnen es, den prompt in der mit @observe dekorierten Funktion mit:

1from langfuse.decorators import langfuse_context, observe
2
3@observe()
4def main():
5    prompt = langfuse.get_prompt("rag-chat-prompt", type="chat")
6
7    langfuse_context.update_current_observation(
8        prompt=prompt,
9    )
10
11main()

Zusammenfassung

Langfuse bietet Tracing, Sessions, Auswertungen pro Benutzer, ein Dashboard für Kosten und Latenz, manuelle Evaluierungen, Datasets und Prompt-Versionierung in einem Open-Source-Paket. Für den Einstieg reichen ein docker compose up -d und ein geänderter Import (from langfuse.openai import openai). Danach setzen Sie @observe auf Ihre Aufrufhierarchie und geben Ihren Traces Session- und User-IDs mit. Selbst hosten heißt, sechs Dienste zu betreiben, darunter ClickHouse, MinIO, Redis und Postgres. Planen Sie das ein, bevor Sie Langfuse produktiv einsetzen.

Wenn Sie LLM-Anwendungen oder KI-Agenten im Unternehmen betreiben und Kosten und Qualität laufend im Blick behalten möchten, unterstützt Sie unser Team für KI-Beratung bei Aufbau und Betrieb. Sprechen Sie uns an.

Sie möchten zuverlässige KI-Agenten-Systeme bauen?

Wir haben auf Basis aktueller Forschung einen ausführlichen Leitfaden (auf Englisch) erstellt, wie Sie robuste KI-Agenten-Systeme bauen, die auch im produktiven Betrieb funktionieren. Der Leitfaden behandelt:

• die 14 systematischen Fehlerquellen in Multi-Agenten-Systemen
• belegte Best Practices für das Design von Agenten
• strukturierte Kommunikationsprotokolle und Prüfmechanismen

---

Weiterlesen

• KI-Anwendungen mit Opik überwachen (auf Englisch)
• Advanced RAG: ColBERT Reranker (auf Englisch)
• LLM-Sicherheit mit LlamaGuard 2 (auf Englisch)
• RAG-Qualität mit RAGAS messen
• Smolagents: ein minimalistisches Agenten-Framework (auf Englisch)
• KI-Agenten ohne Framework bauen (auf Englisch)
• Komplexe Aufgaben mit Workflows im Microsoft Agent Framework orchestrieren

Über den Autor

Andreas Nigg

Mitgründer, Pondhouse Data

Andreas entwickelt seit mehr als acht Jahren Datenanwendungen. Bei Pondhouse Data konzipiert und baut er KI-Systeme und integriert sie in komplexe, gewachsene Unternehmensumgebungen.

Sprechen Sie mit Andreas über Ihr ProjektAuf LinkedIn folgen