Wie viel RAM braucht ein selbst gehostetes Langfuse?

Auf unserem Testserver lief Langfuse v4 als sechs Container – Web, Worker, Postgres, ClickHouse, Redis und MinIO – und belegte mit einem leeren Projekt rund 3,5 GB RAM. ClickHouse wächst mit jedem Span, den du schickst. Medium-IP (6 GB RAM, 45 GB Disk) trägt es für eine Handvoll Agenten bequem; eine ganze Agentenflotte mit Monaten an Historie braucht einen Pro-Tarif, den es auf Anfrage gibt.

Brauche ich für Langfuse eine eigene IP?

Nur wenn deine Agenten woanders laufen und Traces übers Internet schicken: Dann brauchen sie einen HTTPS-Endpunkt, und ein NAT-Tarif nimmt von außen nur deinen SSH-Port an. Laufen die Agenten auf demselben Server, kann Langfuse auf localhost bleiben, und du öffnest das Dashboard per SSH-Tunnel – dafür reicht auch Medium mit NAT.

Mein Code läuft, aber das Dashboard bleibt leer. Warum?

Fast immer fehlt LANGFUSE_BASE_URL. Ohne diese Variable schickt das SDK alles in die gehostete Cloud von Langfuse, deine selbst gehosteten Schlüssel gibt es dort nicht, und auf deinem Server kommt nichts an. Setz die Variable auf deine eigene Adresse.

Der Endpunkt /api/public/traces liefert einen Fehler. Ist die Installation kaputt?

Nein. Langfuse v4 läuft in einem Events-only-Modus, in dem dieser Endpunkt abgeschaltet ist. Lies die Daten stattdessen über /api/public/v2/observations – genau damit haben wir geprüft, dass unsere Test-Spans angekommen sind.

Wie verhindere ich, dass sich Fremde registrieren?

Langfuse liest AUTH_DISABLE_SIGNUP, aber die mitgelieferte docker-compose.yml reicht die Variable nicht an den Web-Container weiter – sie nur in .env zu setzen, bewirkt nichts. Füg eine Zeile in die Umgebung von langfuse-web ein (der Befehl steht unten), setz sie auf true, nachdem du dein eigenes Konto angelegt hast, und weitere Registrierungen bekommen „Sign up is disabled“.

VPS für Langfuse: sieh, was deine KI-Agenten taten

Langfuse selbst hosten: jeden LLM-Aufruf und Tool-Schritt unbeaufsichtigter Agenten nachverfolgen. Getestetes Docker Compose, echte RAM-Zahlen, Tarif.

Ein Agent, der um drei Uhr nachts unbeaufsichtigt arbeitet, ist nur so gut wie deine Fähigkeit, hinterher nachzuvollziehen, was er getan hat. „Er hat über Nacht Tokens für 38 $ verbrannt“ ist ein schlechter Morgen. „Er hat 38 $ verbrannt, weil ein Such-Tool eine leere Seite lieferte und der Planer es 400-mal wiederholt hat“ ist ein Bug, den du bis zum Mittag behebst. Für den zweiten Satz brauchst du Traces.

Langfuse zeichnet jeden LLM-Aufruf, Prompt, Tool-Schritt, Token-Zähler und jede Latenz als Baum auf, durch den du dich klicken kannst. Läuft es bei dir, bleiben diese Prompts und Antworten – in denen meist Kundendaten, API-Ausgaben und gelegentlich ein Secret stecken – auf einem Server, den du kontrollierst, statt in einem fremden Dashboard.

Was der Betrieb kostet

Langfuse v4 ist keine kleine Binärdatei, sondern sechs Container: die Web-App, ein Hintergrund-Worker, Postgres, ClickHouse für die Events, Redis und MinIO für Dateien. Wir haben es auf einem Testserver installiert und gemessen: rund 3,5 GB RAM bei einem leeren Projekt. Wachsen wird ClickHouse, denn dort landet jeder Span, den du schickst.

Last	Tarif
Eine Handvoll Agenten, Traces über Wochen	Medium-IP – 6 vCPU, 6 GB, 45 GB ($20/Monat)
Eine Agentenflotte, Historie über Monate	Pro-Tarife, ab 32 GB RAM – auf Anfrage

Kleinere Tarife installieren es zwar, geraten aber ins Schwitzen, sobald ClickHouse und der Worker gleichzeitig Speicher wollen. Unter 6 GB würde ich nicht gehen.

Wo leben die Agenten? Laufen sie auf anderen Maschinen, nimm einen Tarif mit eigener IPv4: Sie brauchen einen HTTPS-Endpunkt, und bei einem NAT-Tarif ist die ausgehende Adresse nicht deine eigene, von außen ist nur der SSH-Port erreichbar. Laufen die Agenten auf demselben Server, muss Langfuse nie ins Internet schauen – zum Ausprobieren reicht Medium mit NAT für $12/Monat. Es gibt zwei Standorte, Deutschland und Finnland; die Verfügbarkeit siehst du bei der Bestellung. Wähle den, der näher an den Agenten liegt, nicht an dir. Bezahlt wird der Server in Krypto, ohne KYC.

Installation

Auf einem frischen Ubuntu 24.04 oder Debian 12, als root. Zuerst Docker:

curl -fsSL https://get.docker.com | sh

Dann Langfuse selbst, mit echten Secrets statt der Standardwerte aus der Compose-Datei:

git clone --depth 1 https://github.com/langfuse/langfuse.git
cd langfuse

PG=$(openssl rand -hex 16); MINIO=$(openssl rand -hex 16)
cat > .env <<EOF
NEXTAUTH_URL=https://langfuse.example.com
NEXTAUTH_SECRET=$(openssl rand -hex 32)
SALT=$(openssl rand -hex 32)
ENCRYPTION_KEY=$(openssl rand -hex 32)
POSTGRES_PASSWORD=$PG
DATABASE_URL=postgresql://postgres:$PG@postgres:5432/postgres
CLICKHOUSE_PASSWORD=$(openssl rand -hex 16)
MINIO_ROOT_PASSWORD=$MINIO
LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY=$MINIO
LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY=$MINIO
LANGFUSE_S3_BATCH_EXPORT_SECRET_ACCESS_KEY=$MINIO
REDIS_AUTH=$(openssl rand -hex 16)
TELEMETRY_ENABLED=false
EOF
chmod 600 .env

Zwei dieser Passwörter haben Partner: Das Postgres-Passwort steckt auch in DATABASE_URL, und das MinIO-Passwort muss zu den drei Zeilen S3_..._SECRET_ACCESS_KEY passen. Deshalb kommt jedes aus einer einzigen Variable.

Jetzt die Falle. Die Compose-Datei veröffentlicht die Web-App auf Port 3000 und MinIO auf 9090 auf allen Interfaces, und von Docker veröffentlichte Ports laufen an ufw vorbei. Binde beide an localhost, damit der Reverse Proxy der einzige Eingang bleibt:

sed -i 's/- 3000:3000/- 127.0.0.1:3000:3000/; s/- 9090:9000/- 127.0.0.1:9090:9000/' docker-compose.yml
docker compose up -d
curl -s http://127.0.0.1:3000/api/public/health

Der letzte Befehl sollte {"status":"OK", ...} ausgeben. Der erste Start führt Datenbankmigrationen aus; bei uns bestand der Health-Check etwa 15 Sekunden, nachdem die Container hochgefahren waren.

HTTPS davor

Richte langfuse.example.com auf die IP des Servers, dann:

apt install -y caddy
cat > /etc/caddy/Caddyfile <<'EOF'
langfuse.example.com {
    reverse_proxy 127.0.0.1:3000
}
EOF
systemctl reload caddy
ufw allow 22/tcp && ufw allow 80/tcp && ufw allow 443/tcp && ufw enable

Das Zertifikat holt sich Caddy selbst. Öffne die Seite, leg dein Konto an (es wird die erste Organisation), erstelle ein Projekt und kopiere dessen öffentlichen und geheimen Schlüssel.

Dann mach die Tür hinter dir zu. Langfuse versteht AUTH_DISABLE_SIGNUP, aber die mitgelieferte Compose-Datei reicht die Variable nicht an den Web-Container weiter, also braucht es eine zusätzliche Zeile unter langfuse-web:

sed -i 's|^      NEXTAUTH_SECRET: \(.*\)$|      NEXTAUTH_SECRET: \1\n      AUTH_DISABLE_SIGNUP: ${AUTH_DISABLE_SIGNUP:-false}|' docker-compose.yml
echo "AUTH_DISABLE_SIGNUP=true" >> .env
docker compose up -d

Ab jetzt bekommt ein Registrierungsversuch „Sign up is disabled“. Kollegen fügst du stattdessen im Projekt hinzu.

Traces aus einem Agenten senden

Das Python-SDK umhüllt deine Funktionen, und verschachtelte Aufrufe werden zu verschachtelten Spans:

python3 -m venv venv && . venv/bin/activate
pip install langfuse
export LANGFUSE_PUBLIC_KEY=pk-lf-...
export LANGFUSE_SECRET_KEY=sk-lf-...
export LANGFUSE_BASE_URL=https://langfuse.example.com

from langfuse import get_client, observe

langfuse = get_client()  # liest die LANGFUSE_*-Variablen

@observe(name="fetch-prices")
def fetch_prices(pair: str) -> dict:
    return {"pair": pair, "bid": 64210.5}

@observe(name="nightly-agent-run")
def run() -> str:
    data = fetch_prices("BTC/USDT")
    return f"done: {data['pair']}"

print(run())
langfuse.flush()  # kurze Skripte enden, bevor der Hintergrund-Sender fertig ist

Lass LANGFUSE_BASE_URL nicht weg. Ohne sie schickt das SDK still alles in die eigene Cloud von Langfuse, deine Schlüssel gibt es dort nicht, und du starrst auf ein leeres Dashboard.

So prüfst du in der Shell, ob die Spans angekommen sind:

curl -s -u "$LANGFUSE_PUBLIC_KEY:$LANGFUSE_SECRET_KEY" \
  "$LANGFUSE_BASE_URL/api/public/v2/observations?limit=5"

In v4 antwortet der ältere Endpunkt /api/public/traces mit einem Fehler zum Events-only-Modus. Das ist so gewollt und keine kaputte Installation. In einem echten Agenten umhüllst du den LLM-Aufruf und jedes Tool genauso; außerdem bringt Langfuse Integrationen für die verbreiteten LLM-SDKs und Agenten-Frameworks mit, oft genügt also ein geänderter Import statt Dekoratoren überall.

Worauf du achten solltest

Disk. ClickHouse und MinIO behalten alles, was du schickst. docker system df -v zeigt, wo der Platz geblieben ist. Wenn du lange Prompts und Antworten tracest, sind die 45 GB von Medium-IP in Wochen voll, nicht in Jahren. Schau einmal im Monat nach; wenn du herauswächst, gibt es einen Pro-Tarif mit 400 GB und mehr auf Anfrage.
Updates. Die Compose-Datei pinnt die Hauptversion (:4). docker compose pull && docker compose up -d holt Fixes innerhalb dieser Version. Lies das Changelog, bevor du die Hauptversion wechselst: Genau in v4 ist der Traces-Endpunkt verschwunden.
Backups. Was zählt, liegt in Docker-Volumes: Postgres hält Benutzer, Projekte und Schlüssel, ClickHouse und MinIO die Traces. Kopier sie regelmäßig vom Server weg.

Sind dir das $20 im Monat wert? Wenn deine Agenten mehr für Tokens ausgeben – und die meisten unbeaufsichtigten tun das –, hat sich das Wissen, wohin die Tokens gingen, beim ersten Mal bezahlt gemacht, wenn eine Schleife durchdreht. Ein kleiner Agent, der einmal am Tag läuft, braucht nichts davon; eine Logdatei und ein Token-Zähler reichen.

Verwandt

VPS für KI-Agenten – wo die Agenten selbst laufen
VPS für Multi-Agenten-Systeme – eine ganze Flotte dimensionieren
VPS für einen LiteLLM-Proxy – ein Gateway für alle Modell-Schlüssel, mit Ausgabelimits
Pro-Tarife auf Anfrage – 32 bis 80 GB RAM für eine Agentenflotte
ufw-Firewall einrichten