Langflow ist ein visueller Low-Code-Builder für RAG-Pipelines und LLM-Agenten auf Basis von LangChain. Per Drag-and-Drop-Oberfläche lassen sich komplexe KI-Workflows aus fertigen Komponenten zusammenstecken, direkt im Browser testen und als REST-API oder MCP-Server deployen – ohne eine einzige Zeile Python schreiben zu müssen. Mit 150.000 GitHub-Stars (Stand Juni 2026) und einem Release-Zyklus von wenigen Wochen ist es eines der aktivsten Projekte im LLM-Ökosystem. Diese Anleitung richtet sich an KI-Entwickler, Data Scientists und technisch versierte Admins, die Langflow schnell und produktionssicher auf einem beliebigen Linux-Host (Server, VM oder NAS mit Docker) aufsetzen wollen.

Voraussetzungen

Docker Engine >= 24.x und Docker Compose Plugin v2 (docker compose, nicht das veraltete docker-compose v1) – falls noch nicht installiert, siehe Docker und Docker Compose auf Linux installieren.
Linux-Host, VM oder NAS mit Docker-Unterstützung (AMD64 oder ARM64 – Apple Silicon und Raspberry Pi 4/5 werden unterstützt).
Mindestens 2 GB freier RAM (4 GB empfohlen), mindestens 3 GB freier Speicherplatz für Images und Volumes.
Internetverbindung für den Image-Download (ca. 1,2 GB für langflowai/langflow).
curl für die Verifikationsschritte; openssl optional für sichere Schlüssel-Generierung.
Für öffentlichen Zugriff: ein Reverse Proxy mit HTTPS (z.B. Nginx Proxy Manager oder Traefik) – siehe Traefik als Docker-Reverse-Proxy mit automatischem HTTPS.
API-Keys der gewünschten LLM-Provider (OpenAI, Anthropic usw.) – können auch nach dem Start direkt in der UI eingegeben werden.

Schritt 1: Projektordner anlegen

Lege einen dedizierten Ordner für den Langflow-Stack an. Alle Konfigurationsdateien landen hier – das erleichtert spätere Updates und Backups erheblich.

mkdir -p /opt/langflow
cd /opt/langflow

Alternativ eignet sich auch ~/langflow im Home-Verzeichnis, falls du keinen Root-Zugriff hast.

Verifizieren: Der Ordner existiert und ist das aktuelle Arbeitsverzeichnis.

pwd
# Erwartete Ausgabe: /opt/langflow

Schritt 2: .env-Datei mit sicheren Secrets anlegen

Secrets gehören nie direkt in die compose.yaml, sondern in eine .env-Datei, die niemals in ein Git-Repository commitet wird. Generiere sichere Zufallswerte mit openssl:

openssl rand -hex 32  # für LANGFLOW_SECRET_KEY
openssl rand -hex 16  # für POSTGRES_PASSWORD
openssl rand -hex 16  # für LANGFLOW_SUPERUSER_PASSWORD

Erstelle dann die .env-Datei mit den generierten Werten:

# /opt/langflow/.env
# ACHTUNG: Diese Datei enthält Secrets – niemals in Git committen!

# PostgreSQL
POSTGRES_PASSWORD=dein_zufaelliges_db_passwort_hier

# Langflow
LANGFLOW_SECRET_KEY=dein_langer_zufaelliger_schluessel_64_zeichen
LANGFLOW_SUPERUSER=admin
LANGFLOW_SUPERUSER_PASSWORD=dein_sicheres_admin_passwort
LANGFLOW_AUTO_LOGIN=false

Schütze die Datei gegen unbefugten Lesezugriff:

chmod 600 /opt/langflow/.env

Warum ist LANGFLOW_SECRET_KEY so wichtig? Fehlt dieser Wert in der Konfiguration, generiert Langflow bei jedem Container-Neustart automatisch einen neuen kryptografischen Schlüssel. Das Ergebnis: Alle bestehenden Browser-Sessions werden sofort ungültig und Nutzer müssen sich jedes Mal neu einloggen. Ein stabiler, langer Zufallsstring löst dieses Problem dauerhaft.

Verifizieren: Die Datei existiert, enthält keine Leerzeilen bei den Pflicht-Variablen und hat die richtigen Berechtigungen.

ls -la /opt/langflow/.env
# Erwartete Ausgabe: -rw------- ... .env

Schritt 3: compose.yaml erstellen

Die compose.yaml definiert zwei Services: Langflow selbst und PostgreSQL als produktionstaugliche Datenbank. Ohne PostgreSQL nutzt Langflow intern SQLite, was für Tests ausreicht – für Mehrbenutzerbetrieb ist es aber nicht geeignet.

Ein wichtiges Detail zum PostgreSQL-Image: Das offizielle Langflow-Repository nutzt bewusst postgres:16-trixie statt postgres:16. Der Grund ist ein bekannter glibc-Kollationsversionsmismatch (Issue #9608), der bei bestehenden Volumes zu Warnungen oder Datenbankkorruption führen kann, wenn das Basis-Image wechselt. Halte dich an diesen Tag.

# /opt/langflow/compose.yaml
services:
  langflow:
    image: langflowai/langflow:latest
    pull_policy: always
    restart: unless-stopped
    ports:
      - "7860:7860"
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      - LANGFLOW_DATABASE_URL=postgresql://langflow:${POSTGRES_PASSWORD:-langflow}@postgres:5432/langflow
      - LANGFLOW_CONFIG_DIR=/app/langflow
      - LANGFLOW_SECRET_KEY=${LANGFLOW_SECRET_KEY:-changeme_use_a_long_random_string}
      - LANGFLOW_HOST=0.0.0.0
      - LANGFLOW_AUTO_LOGIN=${LANGFLOW_AUTO_LOGIN:-false}
      - LANGFLOW_SUPERUSER=${LANGFLOW_SUPERUSER:-admin}
      - LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD:-changeme}
    volumes:
      - langflow-data:/app/langflow
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7860/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  postgres:
    image: postgres:16-trixie
    restart: unless-stopped
    environment:
      POSTGRES_USER: langflow
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-langflow}
      POSTGRES_DB: langflow
    volumes:
      - langflow-postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U langflow -d langflow"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

volumes:
  langflow-postgres:
  langflow-data:

Drei Punkte verdienen besondere Beachtung: Erstens steuert LANGFLOW_HOST=0.0.0.0, dass Langflow auf alle Netzwerkinterfaces hört. Der Standard (localhost) würde den Service nur innerhalb des Containers erreichbar machen – das Port-Mapping 7860:7860 würde dann trotzdem nicht funktionieren. Zweitens sorgt depends_on mit condition: service_healthy dafür, dass Langflow erst startet, wenn PostgreSQL bereit ist; ohne diesen Healthcheck-Mechanismus schlägt der Datenbankverbindungsaufbau regelmäßig fehl. Drittens hält pull_policy: always das latest-Tag aktuell – ohne diese Zeile zieht docker compose up -d kein neues Image, wenn lokal bereits eines vorhanden ist.

Schritt 4: Eckdaten im Überblick

Parameter	Wert	Hinweis
Docker-Image	`langflowai/langflow:latest`	Stabil pinnen: `langflowai/langflow:1.10.0`
Aktuelle Version	v1.10.0 (09.06.2026)	MIT-Lizenz, 150k GitHub-Stars
Image-Größe	ca. 1,2 GB	Multi-Arch: amd64 + arm64
Web-UI/API-Port	7860:7860	HTTP, Pflicht
Volume Langflow	`langflow-data:/app/langflow`	Logs, Secrets, File-Storage
Volume PostgreSQL	`langflow-postgres:/var/lib/postgresql/data`	DB-Dateien, Pflicht mit Postgres
Datenbank (Prod)	PostgreSQL 16 (trixie)	SQLite nur für Tests
Mindest-RAM	2 GB (4 GB empfohlen)	inkl. PostgreSQL

Schritt 5: Stack starten

Starte den Stack aus dem Projektordner heraus. Docker Compose liest die .env-Datei automatisch ein:

cd /opt/langflow
docker compose up -d

Docker lädt zunächst die Images herunter (beim ersten Start ca. 1,2 GB für Langflow und PostgreSQL), startet dann PostgreSQL und wartet auf den Healthcheck, bevor Langflow hochfährt. Langflow selbst führt beim ersten Start automatisch Datenbankmigrationen durch – das dauert 30–90 Sekunden. Während dieser Zeit ist /health noch nicht erreichbar; das ist kein Fehler.

Verifizieren: Prüfe den Status beider Services und warte, bis beide als healthy gemeldet werden:

docker compose ps

# Erwartete Ausgabe nach ca. 90 Sekunden:
# NAME                IMAGE                        STATUS
# langflow-langflow-1 langflowai/langflow:latest   Up (healthy)
# langflow-postgres-1 postgres:16-trixie           Up (healthy)

Prüfe anschließend den Health-Endpoint direkt:

curl -s http://localhost:7860/health
# Erwartete Ausgabe: {"status":"ok"}

Schritt 6: Logs prüfen

Bevor du den Browser öffnest, lohnt ein kurzer Blick in die Logs beider Services, um sicherzustellen, dass keine Fehler vorliegen:

# Langflow-Logs (letzte 50 Zeilen)
docker compose logs --tail=50 langflow

# PostgreSQL-Logs
docker compose logs --tail=20 postgres

In den Langflow-Logs solltest du Zeilen wie Application startup complete und Uvicorn running on http://0.0.0.0:7860 sehen. In den PostgreSQL-Logs: database system is ready to accept connections.

Verifizieren: Keine Fehlermeldungen zu Datenbankverbindung, Port-Konflikten oder fehlenden Volumes. Wenn LANGFLOW_DATABASE_URL falsch wäre, würde Langflow mit einem klaren Verbindungsfehler abstürzen und neu starten – das zeigt sich als Restarting in docker compose ps.

docker compose ps
# STATUS-Spalte darf KEIN "Restarting" enthalten

Schritt 7: Erst-Einrichtung im Browser

Öffne http://localhost:7860 im Browser (bei einem Remote-Server: die IP-Adresse des Hosts, Port 7860). Da LANGFLOW_AUTO_LOGIN=false gesetzt ist, erscheint zuerst ein Login-Formular.

Melde dich mit den in der .env definierten Zugangsdaten an:

Benutzername: Wert von LANGFLOW_SUPERUSER (Standard: admin)
Passwort: Wert von LANGFLOW_SUPERUSER_PASSWORD

Nach dem Login landet du auf dem Langflow-Dashboard. Von hier aus kannst du direkt loslegen: neue Flows erstellen, Komponenten per Drag-and-Drop aus der linken Sidebar ziehen und verbinden. Für den ersten Test bietet Langflow fertige Vorlagen (Templates) an – etwa für einen einfachen RAG-Chatbot oder einen Agenten mit Web-Suche.

LLM-Provider-API-Keys (z.B. OPENAI_API_KEY oder ANTHROPIC_API_KEY) gibst du entweder direkt in den Komponenten-Einstellungen ein oder hinterlegst sie global unter Settings → Global Variables – so stehen sie in allen Flows zur Verfügung. Wer lokale Modelle bevorzugt, kann Langflow direkt mit Ollama als lokales LLM verbinden.

Verifizieren: Der Login funktioniert, das Dashboard lädt vollständig, und unter Settings → Profile ist der Admin-Account sichtbar. Erstelle einen Test-Flow und führe ihn aus – wenn die Pipeline-Verbindungen grün leuchten und ein Ergebnis zurückkommt, läuft alles korrekt.

Schritt 8: Reverse Proxy und HTTPS einrichten (optional, aber empfohlen)

Für den Zugriff aus dem Internet oder über eine eigene Domain solltest du Langflow hinter einen Reverse Proxy mit TLS stellen. Port 7860 direkt ins Internet zu öffnen ist keine gute Idee – auch nicht mit Authentifizierung. Eine bewährte Kombination ist Traefik oder Nginx Proxy Manager; beide sind ausführlich beschrieben in Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten.

Wenn du Langflow hinter einem Reverse Proxy betreibst, entferne das ports-Mapping aus der compose.yaml (oder beschränke es auf 127.0.0.1:7860:7860) und stelle sicher, dass Langflow und der Proxy im selben Docker-Netzwerk laufen.

Verifizieren: HTTPS-Zugriff über die konfigurierte Domain funktioniert, das TLS-Zertifikat ist gültig, und HTTP wird auf HTTPS weitergeleitet.

Schritt 9: Updates und Backup

Das Update auf eine neue Langflow-Version läuft dank pull_policy: always und Named Volumes reibungslos. Langflow führt Datenbankmigrationen automatisch beim Start durch:

cd /opt/langflow
docker compose pull
docker compose up -d

Für ein Backup der PostgreSQL-Datenbank eignet sich pg_dump – wie das automatisiert per cron funktioniert, erklärt die Anleitung MySQL & PostgreSQL Backup automatisieren mit cron. Das Langflow-Daten-Volume (langflow-data) solltest du separat sichern, da dort hochgeladene Dateien und Konfigurationen liegen.

Zum Stoppen des Stacks (ohne Datenverlust):

docker compose down
# Volumes bleiben erhalten; mit --volumes würden sie gelöscht (VORSICHT!)

Verifizieren: Nach docker compose pull && docker compose up -d zeigt docker compose ps beide Services wieder als healthy. Die zuvor erstellten Flows sind nach dem Update noch vorhanden.

Troubleshooting / Typische Fehler

Sessions werden nach jedem Neustart ungültig: LANGFLOW_SECRET_KEY fehlt oder ist leer. Ohne diesen Wert generiert Langflow bei jedem Start einen neuen Schlüssel. Lösung: Einen langen Zufallsstring (openssl rand -hex 32) in der .env hinterlegen und den Stack neu starten.
Port 7860 erreichbar, aber Verbindung schlägt fehl: LANGFLOW_HOST ist nicht auf 0.0.0.0 gesetzt. Langflow bindet dann nur an localhost innerhalb des Containers. Lösung: LANGFLOW_HOST=0.0.0.0 setzen.
Langflow startet, schlägt aber sofort mit Datenbankfehler fehl: PostgreSQL war noch nicht bereit. Das passiert, wenn depends_on ohne condition: service_healthy konfiguriert ist. Lösung: Den Healthcheck in der compose.yaml wie oben gezeigt konfigurieren.
Fehler „asyncpg does not support timezone-aware datetimes": LANGFLOW_DATABASE_URL verwendet postgresql+asyncpg://.... Asyncpg ist mit Langflows Timezone-Handling inkompatibel. Lösung: Standard-URL postgresql://... oder postgresql+psycopg2://... verwenden.
Flows und hochgeladene Dateien nach Neustart verschwunden: Das Volume für /app/langflow fehlt oder ist nicht korrekt eingehängt. Lösung: Sicherstellen, dass langflow-data:/app/langflow im volumes-Abschnitt steht und LANGFLOW_CONFIG_DIR=/app/langflow gesetzt ist.
Warnung „collation version mismatch" in PostgreSQL-Logs: Image-Tag postgres:16 statt postgres:16-trixie verwendet, während ein bestehendes Volume von einer anderen Debian-Version stammt. Lösung: Den Tag auf postgres:16-trixie korrigieren.
curl http://localhost:7860/health gibt direkt nach dem Start einen Fehler zurück: Langflow führt beim ersten Start Datenbankmigrationen durch, was 30–90 Sekunden dauern kann. Das ist kein Fehler – einfach warten und erneut prüfen.
Standard-Passwörter in Production: POSTGRES_PASSWORD=langflow und LANGFLOW_SUPERUSER_PASSWORD=changeme dürfen in Production niemals unveraendert bleiben. Lösung: Immer individuelle, starke Passwörter in der .env-Datei hinterlegen.

Häufige Fragen

Kann ich Langflow ohne PostgreSQL betreiben?

Ja – für Tests und Einzelnutzer genügt die eingebettete SQLite-Datenbank vollständig. Lass einfach die LANGFLOW_DATABASE_URL-Variable und den postgres-Service weg. Für Mehrbenutzerbetrieb und Produktivsysteme ist PostgreSQL aber dringend empfohlen, da SQLite keine parallelen Schreibzugriffe unterstützt.

Wie aktualisiere ich Langflow auf eine neue Version?

Mit docker compose pull && docker compose up -d im Projektordner. Die Datenbank und der Config-Ordner bleiben durch die Named Volumes erhalten. Langflow führt Datenbankmigrationen automatisch beim Start durch – du musst nichts manuell tun. Empfehlung: Vor jedem größeren Update ein PostgreSQL-Backup anlegen.

Welche LLM-Provider werden unterstützt?

Langflow unterstützt über LangChain-Komponenten praktisch alle relevanten Provider: OpenAI (GPT-4o, GPT-4.1), Anthropic Claude, Google Gemini, Ollama (für lokale Modelle ohne Cloud), HuggingFace, Cohere und viele weitere. API-Keys kannst du direkt in der UI unter Settings → Global Variables hinterlegen oder als Umgebungsvariable in der compose.yaml übergeben.

Kann ich eigene Python-Komponenten hinzufügen?

Ja – Langflow erlaubt Custom Components als Python-Code direkt in der UI. Ziehe eine „Custom Component"-Karte in den Canvas und schreibe deine Logik. Für systemweite Erweiterungen (z.B. zusätzliche Python-Pakete) kannst du ein eigenes Dockerfile auf Basis von langflowai/langflow erstellen und es in der compose.yaml als build-Kontext referenzieren.

Läuft Langflow auf ARM64-Hardware?

Ja, das offizielle Docker-Image unterstützt sowohl linux/amd64 als auch linux/arm64. Es läuft damit nativ auf Apple-Silicon-Macs (M1/M2/M3/M4), Raspberry Pi 4/5 und ARM-basierten Cloud-VMs ohne Emulationsschicht.

Wie exportiere und importiere ich Flows?

Flows lassen sich in der UI über das Menü als JSON-Datei exportieren und auf anderen Instanzen wieder importieren. Für automatisiertes Vorladen beim Start verwendest du einen Bind-Mount: Ergänze ./flows:/app/flows im Volumes-Abschnitt des Langflow-Services und setze LANGFLOW_LOAD_FLOWS_PATH=/app/flows. Das ist praktisch für Backups, Versionsverwaltung per Git und CI/CD-Deployments.

Was ist der Unterschied zu n8n oder Dify?

Langflow ist auf LangChain-basierte KI-Workflows spezialisiert und bietet von Haus aus alle LangChain-Komponenten als Drag-and-Drop-Bausteine. n8n ist breiter aufgestellt (allgemeine Automatisierung mit KI-Erweiterungen), während Dify eine komplette LLMOps-Plattform mit eigenem Vektorspeicher ist. Wer den Fokus auf RAG-Pipelines und LLM-Agenten legt, ist mit Langflow gut bedient; für allgemeine Automatisierung bietet sich n8n mit Docker an. Einen tiefen Einblick in RAG-Architekturen als Grundlage für Langflow-Pipelines bietet die Anleitung Lokales RAG-System mit Qdrant und Embeddings selbst bauen.

Fazit

Langflow ist in der LLM-Tooling-Landschaft eine der ausgereiftesten Lösungen für visuelles RAG-Prototyping und Agenten-Entwicklung. Der Docker-Compose-Stack ist in ca. 15 Minuten produktionsbereit – vorausgesetzt, du nimmst die drei häufigsten Fehlerquellen ernst: LANGFLOW_SECRET_KEY setzen, LANGFLOW_HOST=0.0.0.0 nicht vergessen, und postgres:16-trixie statt eines generischen Tags verwenden. Für skalierte Deployments lässt sich Langflow durch mehr Worker-Prozesse (LANGFLOW_WORKERS) und einen vorgelagerten Reverse Proxy mit HTTPS produktionssicher betreiben.

Weiterführende Anleitungen und Quellen

Offizielle Quellen: Langflow Dokumentation: Deploy Langflow on Docker · Langflow GitHub Repository · langflowai/langflow auf Docker Hub