Claude Code & Langfuse: LLM-Observability und Prompt-Monitoring einrichten

Wer LLM-Applikationen in Produktion bringt, stellt schnell fest: was man nicht sieht, kann man nicht verbessern. Welcher Prompt schlägt bei bestimmten Eingaben fehl? Welche Anfragen kosten unverhältnismäßig viel? Welche Modellversion liefert bessere Evals? Ohne Observability bleibt das alles Spekulation. Langfuse beantwortet genau diese Fragen — und lässt sich in wenigen Minuten in bestehende Anthropic-, OpenAI- und LangChain-Projekte integrieren.

Dieser Artikel zeigt, wie du Langfuse von null auf produktionsreif einrichtest: Tracing, Prompt-Versionierung, Cost-Tracking und automatisierte Evals — sowohl in der Cloud als auch self-hosted.

1. Was ist Langfuse?

Langfuse ist ein Open-Source-Observability-Tool speziell für LLM-Applikationen. Es fungiert als zentrales Dashboard für alles, was zwischen deiner Applikation und dem Sprachmodell passiert: jeder API-Call wird als Trace erfasst, mit Eingabe, Ausgabe, Latenz, Token-Verbrauch und Kosten. Dazu kommen Prompt-Versionierung, A/B-Tests auf Prompt-Ebene und ein Eval-Framework, mit dem du Modell-Outputs systematisch bewertest.

Das Besondere an Langfuse: es ist provider-agnostisch. Anthropic, OpenAI, Mistral, lokale Modelle via Ollama — alles landet in derselben Oberfläche. Und wer keine Daten in der Cloud halten will, betreibt Langfuse selbst auf dem eigenen Server.

2. Installation und erste Integration

Der schnellste Einstieg läuft über das Python-SDK. Credentials kommen dabei ausschließlich aus Umgebungsvariablen — nie im Code hardcoden.

pip install langfuse

Dann die Umgebungsvariablen setzen (in .env oder in der Shell):

LANGFUSE_PUBLIC_KEY=pk-lf-...
LANGFUSE_SECRET_KEY=sk-lf-...
LANGFUSE_HOST=https://cloud.langfuse.com  # oder deine self-hosted URL

Und in deinem Code:

import os
from langfuse import Langfuse

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

3. LLM-Calls tracen: Anthropic SDK

Mit dem Anthropic SDK lässt sich Langfuse über einen Decorator einbinden. Jeder API-Call wird automatisch als Span erfasst, mit Eingabe-Prompt, Modell, Completion-Tokens und Kosten:

import anthropic
import os
from langfuse.decorators import observe, langfuse_context

client = anthropic.Anthropic()

@observe(as_type="generation")
def call_claude(user_message: str) -> str:
    langfuse_context.update_current_observation(
        model="claude-opus-4-5",
        input=user_message,
    )
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": user_message}],
    )
    result = response.content[0].text
    langfuse_context.update_current_observation(
        output=result,
        usage={
            "input": response.usage.input_tokens,
            "output": response.usage.output_tokens,
        },
    )
    return result

Ab diesem Punkt erscheint jeder Aufruf von call_claude() als vollständiger Trace im Langfuse-Dashboard — mit Latenz, Tokenzahl und berechnetem Preis.

OpenAI-kompatible Clients

Für OpenAI oder provider-kompatible APIs gibt es einen Drop-in-Wrapper. Kein Code muss umgeschrieben werden — nur den Client austauschen:

from langfuse.openai import openai

# Identische API wie openai.OpenAI() — automatisches Tracing inklusive
client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

LangChain-Integration

Für LangChain-basierte Pipelines reicht ein Callback-Handler. Er erfasst alle Chains, Tools und Retrievals in einer einzigen Trace-Hierarchie:

from langfuse.callback import CallbackHandler

handler = CallbackHandler()

# Als callbacks-Argument an jede Chain übergeben
chain.invoke({"question": "..."}, config={"callbacks": [handler]})

4. Prompt-Versionierung

Prompts direkt im Code zu verwalten führt schnell zu unkontrollierten Änderungen: Wer hat was geändert, wann, mit welchem Effekt? Langfuse löst das mit einem integrierten Prompt-Registry.

Prompts werden einmalig im Dashboard angelegt und mit einer Versionsnummer versehen. Im Code lädt man sie dynamisch:

prompt = langfuse.get_prompt("mein-system-prompt")
compiled = prompt.compile(name="Kunde", produkt="Premium-Plan")
# compiled.prompt enthält den fertigen Text, prompt.version die aktuelle Versionsnummer

Damit wird jeder Trace automatisch mit der Prompt-Version verknüpft. A/B-Tests zwischen zwei Prompt-Varianten lassen sich direkt im Dashboard auswerten — ohne Code-Deployment für jeden Prompt-Kandidaten.

5. Cost-Tracking und Token-Budget

Langfuse berechnet die Kosten pro Trace automatisch, wenn das Modell und die Token-Zahlen übergeben werden. Das Dashboard zeigt dann: Gesamtkosten pro Zeitraum, Kosten pro Trace-Typ, Kosten pro Nutzer (wenn man eine User-ID übergibt) und die teuersten Einzelanfragen.

Für granulare Kontrolle kann man eigene Cost-Modelle hinterlegen — praktisch, wenn man einen eigenen Proxy oder ein Fine-tuned-Modell mit anderen Preisen betreibt.

# User-ID für per-User-Cost-Tracking
@observe()
def handle_request(user_id: str, message: str):
    langfuse_context.update_current_trace(user_id=user_id)
    return call_claude(message)

6. Evals einrichten

Ohne Evaluation weiß man nicht, ob Prompt-Änderungen tatsächlich besser sind. Langfuse bietet drei Eval-Mechanismen:

• Manuelle Scores: Über die UI oder per API — gut für initiales Labeling kleinerer Datensätze.
• LLM-as-Judge: Ein separates Modell bewertet die Outputs nach definierten Kriterien automatisch. Einsatz für Korrektheit, Ton, Vollständigkeit.
• Regelbasierte Scores: Regex-Checks, Längenprüfungen oder eigene Python-Funktionen — deterministisch und ohne Modell-Kosten.

Scores werden direkt an Traces angehängt und im Dashboard ausgewertet. Damit lässt sich z.B. sehen: "Prompt Version 3 hat bei Fragen zur Abrechnung 15% schlechtere Korrektheitswerte als Version 2" — und das rollback ist eine einzige Zeile.

7. Self-Hosting mit Docker

Für den Betrieb auf eigenem Server genügen wenige Schritte. Voraussetzung ist eine laufende PostgreSQL-Instanz:

# docker-compose.yml (vereinfacht)
services:
  langfuse:
    image: langfuse/langfuse:latest
    environment:
      - DATABASE_URL=postgresql://user:${DB_PASSWORD}@postgres:5432/langfuse
      - NEXTAUTH_SECRET=${NEXTAUTH_SECRET}
      - NEXTAUTH_URL=https://langfuse.deine-domain.de
      - SALT=${LANGFUSE_SALT}
    ports:
      - "3000:3000"

Alle Secrets kommen aus Umgebungsvariablen — nie im docker-compose.yml selbst. Nach dem ersten Start erstellt Langfuse automatisch alle Datenbank-Tabellen. Dann in den Applikations-Einstellungen LANGFUSE_HOST auf die eigene URL setzen — fertig.

Langfuse schließt die Observability-Lücke, die beim Deployment von LLM-Applikationen fast immer entsteht. Tracing, Prompt-Versionierung, Cost-Tracking und Evals — in einer integrierten Plattform, provider-agnostisch, open-source. Wer Claude Code für die Entwicklung nutzt, hat damit auch für den Betrieb ein vollständiges Bild.

• Claude Code Debugging — Bugs systematisch finden mit Claude Code
• Claude Code für Unternehmen — Deployment und Team-Workflows auf Unternehmensebene