---
title: "Langflow mit Docker installieren: Visueller Low-Code-Builder für RAG-Pipelines und LLM-Agenten"
date: 2026-08-20T09:27:24+02:00
modified: 2026-11-08T22:06:31+01:00
category: kuenstliche-intelligenz
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/langflow-docker-rag-pipeline-builder
reading_time: 10
personalize_url: "https://s-edv.com/anleitungen/langflow-docker-rag-pipeline-builder#domain={domain}&server_ip={server_ip}"
variables:
  - name: postgres_password
    label: "Passwort (postgres password)"
    generated_in_browser: true
  - name: langflow_secret_key
    label: "Schlüssel (langflow secret key)"
    generated_in_browser: true
  - name: langflow_superuser_password
    label: "Passwort (langflow superuser password)"
    generated_in_browser: true
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
  - name: server_ip
    label: "Server ip"
    default: "SERVER-IP"
---

# Langflow mit Docker installieren: Visueller Low-Code-Builder für RAG-Pipelines und LLM-Agenten

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{postgres_password}}` | Passwort (postgres password) | wird im Browser des Lesers zufällig erzeugt |
| `{{langflow_secret_key}}` | Schlüssel (langflow secret key) | wird im Browser des Lesers zufällig erzeugt |
| `{{langflow_superuser_password}}` | Passwort (langflow superuser password) | wird im Browser des Lesers zufällig erzeugt |
| `{{domain}}` | Ihre Domain | `example.com` |
| `{{server_ip}}` | Server ip | `SERVER-IP` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/langflow-docker-rag-pipeline-builder#domain=cloud.example.com&server_ip=SERVER-IP

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Langflow ist ein visueller Low-Code-Builder für RAG-Pipelines und LLM-Agenten auf Basis von LangChain. In der Browser-Oberfläche verbinden Sie fertige Komponenten per Drag-and-Drop zu KI-Workflows, testen sie direkt und stellen sie als REST-API oder MCP-Server bereit. Die Anleitung richtet sich an Administratoren und Entwickler, die Langflow mit PostgreSQL auf einem Linux-Host (Server, VM oder NAS mit Docker) betreiben.

**Kurzfassung:** Sie legen einen Projektordner an, füllen eine `.env` mit Zufallswerten, erstellen eine `compose.yaml` mit Langflow und PostgreSQL und starten mit `docker compose up -d`. Nach den Datenbankmigrationen ist Langflow unter `http://localhost:7860` erreichbar. Seit Langflow 1.11 ist die automatische Anmeldung im Docker-Image abgeschaltet; `LANGFLOW_SUPERUSER_PASSWORD` ist deshalb Pflicht. `LANGFLOW_SECRET_KEY` setzen Sie fest, damit verschlüsselte API-Schlüssel auch nach einem Neuaufbau lesbar bleiben.

## Voraussetzungen

- [ ] **Docker Engine >= 24.x** und **Docker Compose Plugin v2** (`docker compose`, nicht das veraltete `docker-compose` v1). Die Einrichtung beschreibt [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Linux-Host, VM oder NAS mit Docker, x86_64 (amd64) oder ARM64. Auf x86_64 muss die CPU den Befehlssatz x86-64-v3 (AVX2) beherrschen, weil das Image seit 1.12 auf Red Hat UBI 10 basiert. Ältere CPUs und manche virtuelle CPU-Typen (z. B. `kvm64` in Proxmox) scheitern; `grep -o avx2 /proc/cpuinfo | head -1` muss `avx2` ausgeben.
- [ ] Mindestens **2 CPU-Kerne und 4 GB RAM**, dazu **5 GB freier Speicherplatz**. Das Image ist komprimiert rund 0,8 GB groß und belegt entpackt ein Mehrfaches.
- [ ] Internetverbindung für den Image-Download.
- [ ] `curl` und `openssl` für Prüfschritte und Zufallswerte.
- [ ] 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](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten).
- [ ] API-Schlüssel der gewünschten LLM-Anbieter (OpenAI, Anthropic usw.); Sie können sie auch später in der Oberfläche eintragen.

## Schritt 1: Projektordner anlegen

Legen Sie einen eigenen Ordner für den Langflow-Stack an. Alle Konfigurationsdateien liegen dort, das vereinfacht Updates und Sicherungen.

```bash
$ sudo mkdir -p /opt/langflow
$ sudo chown "$USER": /opt/langflow
$ cd /opt/langflow
```

Ohne Root-Rechte verwenden Sie `~/langflow`.

> **Prüfen:** Der Ordner existiert und ist das aktuelle Arbeitsverzeichnis.
>
> ```bash
> $ pwd
> ```
>
> ```bash
> # Erwartete Ausgabe: /opt/langflow
> ```

## Schritt 2: .env-Datei mit sicheren Secrets anlegen

Secrets gehören in die `.env`, nicht in die `compose.yaml`. Erzeugen Sie Zufallswerte:

```bash
$ 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
```

Erstellen Sie dann die `.env` mit den erzeugten Werten:

Datei: `.env`

```ini
# /opt/langflow/.env (nicht in Git einchecken)
POSTGRES_PASSWORD={{postgres_password}}

# Langflow
LANGFLOW_SECRET_KEY={{langflow_secret_key}}
LANGFLOW_SUPERUSER=admin
LANGFLOW_SUPERUSER_PASSWORD={{langflow_superuser_password}}
LANGFLOW_AUTO_LOGIN=false
```

Schützen Sie die Datei gegen Lesezugriff anderer Benutzer:

```bash
$ chmod 600 /opt/langflow/.env
```

`LANGFLOW_SECRET_KEY` verschlüsselt gespeicherte API-Schlüssel und signiert Anmelde-Token. Fehlt der Wert, erzeugt Langflow einen Schlüssel und legt ihn als Datei `secret_key` im Volume `langflow-data` ab. Geht dieses Volume verloren oder wechselt der Schlüssel, sind gespeicherte API-Schlüssel nicht mehr lesbar und alle Sitzungen ungültig. Ein fest gesetzter Wert in der `.env` vermeidet das.

> **Prüfen:** `ls -la /opt/langflow/.env` zeigt `-rw-------`, und `grep -c "=IHR_" /opt/langflow/.env` gibt `0` aus (alle Platzhalter ersetzt).

## Schritt 3: compose.yaml erstellen

Die `compose.yaml` definiert Langflow und PostgreSQL. Ohne PostgreSQL nutzt Langflow SQLite; das reicht für Tests, nicht für den Mehrbenutzerbetrieb.

Das offizielle Langflow-Beispiel nutzt `postgres:16-trixie` statt `postgres:16`. Wechselt beim generischen Tag das Debian-Basissystem, meldet PostgreSQL bei bestehenden Volumes einen Kollationsversions-Konflikt (Issue #9608). Das Langflow-Image wird mit dem Tag der aktuellen Version (hier `1.13.0`) festgeschrieben, damit ein Neustart nicht unbemerkt eine neue Version einspielt.

```yaml
# /opt/langflow/compose.yaml
services:
  langflow:
    image: langflowai/langflow:1.13.0
    restart: unless-stopped
    ports:
      - "127.0.0.1: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:?LANGFLOW_SECRET_KEY in .env setzen}
      - LANGFLOW_AUTO_LOGIN=${LANGFLOW_AUTO_LOGIN:-false}
      - LANGFLOW_SUPERUSER=${LANGFLOW_SUPERUSER:-admin}
      - LANGFLOW_SUPERUSER_PASSWORD=${LANGFLOW_SUPERUSER_PASSWORD:?LANGFLOW_SUPERUSER_PASSWORD in .env setzen}
    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:?POSTGRES_PASSWORD in .env setzen}
      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:
```

Zu den Einstellungen: Das Docker-Image setzt `LANGFLOW_HOST=0.0.0.0` und `LANGFLOW_AUTO_LOGIN=false` bereits selbst. Die Syntax `${VAR:?…}` bricht den Start mit einer klaren Meldung ab, wenn ein Pflichtwert in der `.env` fehlt, statt mit einem unsicheren Standardpasswort zu starten. `depends_on` mit `condition: service_healthy` startet Langflow erst, wenn PostgreSQL Verbindungen annimmt. Der Port ist an `127.0.0.1` gebunden; für den Zugriff aus dem Netz gehört ein Reverse Proxy davor (Schritt 8). Healthchecks, Secrets und Non-Root-Betrieb vertieft die Anleitung [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root).

> **Prüfen:** `docker compose config --quiet && echo OK` gibt `OK` aus. Fehlt ein Pflichtwert, nennt die Meldung die betroffene Variable.

## Schritt 4: Eckdaten im Überblick

| Parameter | Wert | Hinweis |
| --- | --- | --- |
| Docker-Image | `langflowai/langflow:1.13.0` | Version festschreiben, Update gezielt |
| Aktuelle Version | 1.13.0 (22.10.2026) | MIT-Lizenz |
| Image-Größe | ca. 0,8 GB komprimiert | amd64 und arm64 |
| Web-UI/API-Port | 127.0.0.1:7860 | HTTP, extern nur über Proxy |
| 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 |
| RAM | 4 GB empfohlen | inkl. PostgreSQL |

> **Prüfen:** Die Werte der Tabelle stimmen mit Ihrer `compose.yaml` überein: `docker compose config | grep -E "image:|published"` zeigt `langflowai/langflow:1.13.0`, `postgres:16-trixie` und Port `7860` an `127.0.0.1`.

## Schritt 5: Stack starten

Starten Sie den Stack im Projektordner. Docker Compose liest die `.env` automatisch ein:

```bash
$ cd /opt/langflow
$ docker compose up -d
```

Docker lädt die Images, startet PostgreSQL und wartet auf dessen Healthcheck, bevor Langflow startet. Beim ersten Start führt Langflow Datenbankmigrationen aus. Bis dahin antwortet `/health` nicht; das ist kein Fehler.

> **Prüfen:** Beide Dienste melden `healthy`:
>
> ```bash
> $ docker compose ps
> ```
>
> ```bash
> # Erwartete Ausgabe nach ca. 90 Sekunden:
> # NAME                IMAGE                        STATUS
> # langflow-langflow-1 langflowai/langflow:1.13.0   Up (healthy)
> # langflow-postgres-1 postgres:16-trixie           Up (healthy)
> ```

Der Health-Endpunkt antwortet:

```bash
$ curl -s http://localhost:7860/health
```

```bash
# Erwartete Ausgabe: {"status":"ok"}
```

## Schritt 6: Logs prüfen

Prüfen Sie vor dem ersten Aufruf die Logs beider Dienste:

```bash
# Langflow-Logs (letzte 50 Zeilen)
```

```bash
$ docker compose logs --tail=50 langflow
```

```bash
# PostgreSQL-Logs
```

```bash
$ docker compose logs --tail=20 postgres
```

In den Langflow-Logs erscheint nach dem Start ein Hinweis, dass Langflow unter `http://0.0.0.0:7860` bereitsteht. In den PostgreSQL-Logs: `database system is ready to accept connections`.

> **Prüfen:** Keine Fehlermeldungen zu Datenbankverbindung, Port-Konflikten oder fehlenden Volumes. Eine falsche `LANGFLOW_DATABASE_URL` zeigt sich als `Restarting` in `docker compose ps`.
>
> ```bash
> $ docker compose ps
> ```
>
> ```bash
> # STATUS-Spalte darf KEIN "Restarting" enthalten
> ```

## Schritt 7: Erst-Einrichtung im Browser

Öffnen Sie `http://localhost:7860` im Browser. Auf einem entfernten Server erreichen Sie den an 127.0.0.1 gebundenen Port über einen SSH-Tunnel (`ssh -L 7860:127.0.0.1:7860 benutzer@server`) oder nach Schritt 8 über den Reverse Proxy. Da die automatische Anmeldung abgeschaltet ist, erscheint ein Anmeldeformular.

Melden Sie sich mit den Zugangsdaten aus der `.env` an:

1. **Benutzername:** Wert von `LANGFLOW_SUPERUSER` (Standard: `admin`)
2. **Passwort:** Wert von `LANGFLOW_SUPERUSER_PASSWORD`

Nach der Anmeldung sehen Sie die Projektübersicht. Für den ersten Flow bietet Langflow Vorlagen, etwa einen RAG-Chatbot.

API-Schlüssel der LLM-Anbieter (z. B. `OPENAI_API_KEY` oder `ANTHROPIC_API_KEY`) tragen Sie in den Komponenten-Einstellungen ein oder hinterlegen sie zentral unter **Settings → Global Variables**; dann stehen sie in allen Flows zur Verfügung. Für lokale Modelle nutzen Sie [Ollama als lokales LLM](https://s-edv.com/anleitungen/ollama-open-webui-docker-lokales-llm).

> **Prüfen:** Die Anmeldung funktioniert und die Projektübersicht lädt. Ein Test-Flow aus einer Vorlage liefert im Playground eine Antwort, sobald ein gültiger API-Schlüssel hinterlegt ist.

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

Für den Zugriff über eine eigene Domain stellen Sie Langflow hinter einen Reverse Proxy mit TLS. Öffnen Sie Port 7860 nicht direkt ins Internet, auch nicht mit Anmeldung. Die Einrichtung mit Traefik beschreibt [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten).

Läuft der Proxy auf dem Host, leitet er an `127.0.0.1:7860` weiter. Läuft er als Container, entfernen Sie das `ports`-Mapping und hängen Langflow und Proxy in dasselbe Docker-Netzwerk.

> **Prüfen:** `curl -I https://langflow.{{domain}}/health` liefert `HTTP/2 200` mit gültigem Zertifikat, und `curl -I http://{{server_ip}}:7860` aus dem Netz schlägt fehl.

## Schritt 9: Updates und Backup

Für ein Update tragen Sie den neuen Versions-Tag in der `compose.yaml` ein, legen vorher eine Datenbanksicherung an und starten neu. Langflow führt Datenbankmigrationen beim Start aus; die Release Notes nennen Änderungen, die Handarbeit erfordern.

```bash
$ cd /opt/langflow
$ docker compose exec -T postgres pg_dump -U langflow langflow > langflow-$(date +%F).sql
$ sed -i 's|langflowai/langflow:1.13.0|langflowai/langflow:NEUE_VERSION|' compose.yaml
$ docker compose pull
$ docker compose up -d
```

Wie Sie `pg_dump` per cron automatisieren, erklärt die Anleitung [MySQL & PostgreSQL Backup automatisieren mit cron](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud). Sichern Sie zusätzlich das Volume `langflow-data`; dort liegen hochgeladene Dateien und die Datei `secret_key`.

Das Update von 1.12.4 auf 1.13.0 verläuft mit dieser `compose.yaml` ohne weitere Anpassung: Langflow wendet die Datenbankmigrationen beim Start an, der Container ist nach rund 20 Sekunden `healthy`, `/api/v1/version` meldet 1.13.0, ein vorher angelegter Flow ist vorhanden, die Anmeldung des Superusers gelingt, ein falsches Passwort wird abgelehnt, und die Flow-Liste antwortet ohne Anmeldung mit `403`. 1.13.0 bringt laut Release Notes unter anderem Trigger für Flows (Zeitplan, eingehende Webhooks, Slack), verwaltete Verbindungen zu Diensten wie Google Workspace, Microsoft und Slack, eine Administrations-API für Teams und Benutzer sowie eine geführte Seite unter *Settings > Migration* zum Umzug einer Instanz, etwa von SQLite nach PostgreSQL. Lokale Wissensdatenbanken nutzen statt Chroma jetzt SQLite.

Zum Stoppen des Stacks (ohne Datenverlust):

```bash
$ docker compose down
```

```bash
# Volumes bleiben erhalten; mit --volumes würden sie gelöscht (VORSICHT!)
```

> **Prüfen:** `ls -lh langflow-*.sql` zeigt eine Sicherung mit mehr als 0 Byte, `docker compose ps` meldet beide Dienste wieder `healthy`, und die bisherigen Flows sind vorhanden.

## Troubleshooting / Typische Fehler

1. **Gespeicherte API-Schlüssel nicht mehr lesbar, alle Sitzungen ungültig:** `LANGFLOW_SECRET_KEY` hat sich geändert oder das Volume `langflow-data` mit der Datei `secret_key` wurde neu angelegt. Lösung: den ursprünglichen Schlüssel wieder in der `.env` setzen, sonst API-Schlüssel neu eintragen.
2. **Container startet ständig neu, Log „Fatal glibc error: CPU does not support x86-64-v3“:** Die CPU oder der virtuelle CPU-Typ unterstützt kein AVX2. Lösung: in der VM den CPU-Typ `host` wählen oder einen neueren Host verwenden.
3. **„required variable … is missing a value“ beim Start:** Ein Pflichtwert fehlt in der `.env`. Lösung: Variable ergänzen und `docker compose up -d` wiederholen.
4. **Langflow startet, schlägt aber sofort mit Datenbankfehler fehl:** PostgreSQL war noch nicht bereit, weil `depends_on` ohne `condition: service_healthy` steht. Lösung: Healthcheck wie in Schritt 3.
5. **Fehler „asyncpg does not support timezone-aware datetimes“:** `LANGFLOW_DATABASE_URL` beginnt mit `postgresql+asyncpg://`. Lösung: `postgresql://` verwenden.
6. **Flows und hochgeladene Dateien nach Neustart verschwunden:** Das Volume für `/app/langflow` fehlt. Lösung: `langflow-data:/app/langflow` und `LANGFLOW_CONFIG_DIR=/app/langflow` setzen.
7. **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.
8. `curl http://localhost:7860/health`**gibt direkt nach dem Start einen Fehler zurück:** Die Datenbankmigrationen beim ersten Start dauern 30 bis 90 Sekunden. Prüfen Sie danach erneut.
9. **Kein Zugriff aus dem Netz:** Der Port ist bewusst an `127.0.0.1` gebunden. Lösung: Reverse Proxy nach Schritt 8 oder SSH-Tunnel verwenden.

## Häufige Fragen

### Kann ich Langflow ohne PostgreSQL betreiben?

Ja. Für Tests und Einzelnutzer genügt die eingebettete SQLite-Datenbank. Lassen Sie dazu `LANGFLOW_DATABASE_URL` und den Dienst `postgres` weg. Für Mehrbenutzerbetrieb empfiehlt sich PostgreSQL, weil SQLite parallele Schreibzugriffe nur eingeschränkt verarbeitet.

### Wie aktualisiere ich Langflow auf eine neue Version?

Neuen Tag in der `compose.yaml` eintragen, dann `docker compose pull && docker compose up -d`. Datenbank und Konfigurationsordner bleiben in den Volumes erhalten, Migrationen laufen beim Start. Legen Sie vorher eine PostgreSQL-Sicherung an (Schritt 9).

### Welche LLM-Provider werden unterstützt?

Langflow bringt Komponenten für die verbreiteten Anbieter mit, darunter OpenAI, Anthropic, Google Gemini, Ollama (lokale Modelle), Hugging Face und Cohere. API-Schlüssel hinterlegen Sie in der Oberfläche unter **Settings → Global Variables** oder übergeben sie als Umgebungsvariable in der `compose.yaml`.

### Kann ich eigene Python-Komponenten hinzufügen?

Ja. Langflow erlaubt eigene Komponenten als Python-Code direkt in der Oberfläche. Für zusätzliche Python-Pakete erstellen Sie ein eigenes Dockerfile auf Basis von `langflowai/langflow` und binden es in der `compose.yaml` als `build`-Kontext ein.

### Läuft Langflow auf ARM64-Hardware?

Ja, das Image gibt es für `linux/amd64` und `linux/arm64`. Es läuft damit ohne Emulation auf Apple-Silicon-Macs und ARM-Servern.

### Wie exportiere und importiere ich Flows?

Flows exportieren Sie in der Oberfläche als JSON-Datei und importieren sie auf anderen Instanzen. Zum automatischen Laden beim Start ergänzen Sie `./flows:/app/flows` im Volumes-Abschnitt des Langflow-Services und setzen `LANGFLOW_LOAD_FLOWS_PATH=/app/flows`. Das eignet sich für Versionsverwaltung per Git.

### Was ist der Unterschied zu n8n oder Dify?

Langflow ist auf KI-Workflows spezialisiert, n8n auf allgemeine Automatisierung, Dify ist eine LLMOps-Plattform. Für allgemeine Automatisierung passt [n8n mit Docker](https://s-edv.com/anleitungen/n8n-ki-automatisierung-workflows-docker) an. RAG-Grundlagen erklärt [Lokales RAG-System mit Qdrant und Embeddings selbst bauen](https://s-edv.com/anleitungen/qdrant-rag-system-lokal-embeddings-anleitung).

## Fazit

Langflow eignet sich für visuelles Prototyping von RAG-Pipelines und Agenten. Der Stack aus Langflow und PostgreSQL ist schnell aufgesetzt, wenn Sie drei Punkte beachten: Superuser-Passwort und `LANGFLOW_SECRET_KEY` fest setzen, das Image auf eine Version festschreiben und den Port nur über einen Reverse Proxy mit HTTPS freigeben.

## Weiterführende Anleitungen und Quellen

1. [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
2. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
3. [Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud betreiben](https://s-edv.com/anleitungen/ollama-open-webui-docker-lokales-llm)
4. [Lokales RAG-System mit Qdrant und Embeddings selbst bauen: Schritt-für-Schritt-Anleitung](https://s-edv.com/anleitungen/qdrant-rag-system-lokal-embeddings-anleitung)
5. [n8n mit Docker: KI-Workflows und Automatisierung self-hosted](https://s-edv.com/anleitungen/n8n-ki-automatisierung-workflows-docker)
6. [MySQL & PostgreSQL Backup automatisieren mit cron](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud)
7. [Dify mit Docker: Plattform für KI-Apps und Agenten (LLMOps)](https://s-edv.com/anleitungen/dify-ki-apps-agenten-plattform-docker)

Offizielle Quellen: [Langflow Dokumentation: Deploy Langflow on Docker](https://docs.langflow.org/deployment-docker) · [Langflow GitHub Repository](https://github.com/langflow-ai/langflow) · [langflowai/langflow auf Docker Hub](https://hub.docker.com/r/langflowai/langflow)
