# Langflow Visueller KI-Builder

## Überblick

[Langflow](https://github.com/langflow-ai/langflow) ist eine Open-Source-, Low-Code-Plattform zum Erstellen von KI-Anwendungen mit einer visuellen Drag-and-Drop-Oberfläche. Mit über 55.000 GitHub-Sternen und einer rasant wachsenden Community ist sie eines der bevorzugten Tools zum Prototyping und Bereitstellen von LLM-gestützten Workflows, ohne komplexen Boilerplate-Code schreiben zu müssen.

Langflow baut auf LangChain auf und bietet einen grafischen Editor, in dem Sie Komponenten — LLMs, Vektor-Speicher, Dokumentenlader, Retriever, Agenten, Tools — durch Linien zwischen Knoten verbinden können. Die resultierende Pipeline kann als API-Endpunkt exportiert, als Vorlage geteilt oder in Ihre Anwendung eingebettet werden.

**Wesentliche Funktionen:**

* **Visueller RAG-Builder** — Dokumentenlader → Embeddings → Vektor-Speicher → Retriever in Minuten verbinden
* **Multi-Agenten-Workflows** — Mehrere KI-Agenten mit Memory, Tools und Entscheidungslogik verketten
* **LangChain-Integration** — Zugriff auf das gesamte LangChain-Ökosystem über UI-Knoten
* **Komponenten-Marktplatz** — Von der Community beigesteuerte Komponenten für dutzende Dienste
* **API-first** — Jeder Flow generiert automatisch einen REST-API-Endpunkt
* **Memory und Zustand** — Eingebautes Konversationsgedächtnis, Sitzungsverwaltung

**Warum Clore.ai für Langflow?**

Die Compute-Anforderungen von Langflow sind minimal — es handelt sich um einen Python-Webserver, der Workflow-Orchestrierung übernimmt. Clore.ai eröffnet jedoch leistungsstarke Einsatzmöglichkeiten:

* **Self-hosted Embeddings** — Führen Sie lokale Embedding-Modelle (nomic-embed, BGE) auf GPU aus für schnelle, kostenlose Vektor-Generierung
* **Lokale LLM-Backends** — Verbinden Sie Langflow mit Ollama oder vLLM, die auf demselben Server laufen
* **Private Datenpipelines** — Verarbeiten Sie sensible Dokumente, ohne Daten an externe APIs zu senden
* **Kostenoptimierung** — Ersetzen Sie teure OpenAI-Embedding-Aufrufe durch kostenlose lokale Inferenz
* **Persistente Workflows** — Lang laufende Flows auf dedizierten Servern (vs. ephemeren Cloud-Funktionen)

***

## Anforderungen

Langflow selbst ist leichtgewichtig und CPU-basiert. GPU ist optional, ermöglicht jedoch kostenlose lokale LLM-/Embedding-Inferenz.

| Konfiguration                         | GPU                | VRAM  | RAM   | Speicher | Geschätzter Preis   |
| ------------------------------------- | ------------------ | ----- | ----- | -------- | ------------------- |
| **Nur Langflow (API-Backends)**       | Nicht erforderlich | —     | 4 GB  | 10 GB    | \~$0.03–0.08/Stunde |
| **+ Lokale Embeddings (nomic-embed)** | RTX 3090           | 24 GB | 8 GB  | 20 GB    | \~$0.20/Stunde      |
| **+ Ollama (Llama 3.1 8B)**           | RTX 3090           | 24 GB | 16 GB | 40 GB    | \~$0.20/Stunde      |
| **+ Ollama (Qwen2.5 32B)**            | RTX 4090           | 24 GB | 32 GB | 60 GB    | \~$0.35/Stunde      |
| **+ vLLM (Produktions-RAG)**          | A100 80GB          | 80 GB | 64 GB | 100 GB   | \~$1.10/Stunde      |

> Für einen Vergleich der GPU-Optionen auf Clore.ai siehe die [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison).

**Softwareanforderungen auf dem Clore.ai-Server:**

* Docker Engine (auf allen Clore.ai-Images vorinstalliert)
* NVIDIA Container Toolkit (auf GPU-Images vorinstalliert, nur für lokale LLM erforderlich)
* 10+ GB freier Festplattenspeicher für das Langflow-Image und Flow-Daten
* Ausgehender Internetzugang (zum Herunterladen von Docker-Images und Erreichen externer APIs)

***

## Schnellstart

### Schritt 1: Verbindung zu Ihrem Clore.ai-Server herstellen

Buchen Sie einen Server auf [Clore.ai-Marktplatz](https://clore.ai). Für die ausschließliche Nutzung von Langflow eignet sich jeder Server mit ≥4 GB RAM. Verbinden Sie sich per SSH:

```bash
ssh root@<server-ip> -p <ssh-port>
```

### Schritt 2: Langflow mit Docker ausführen

Die einfachste Bereitstellung — Ein Befehl:

```bash
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  langflowai/langflow:latest
```

Warten Sie ca. 30–60 Sekunden auf den Start und greifen Sie dann zu auf `http://<server-ip>:7860`

### Schritt 3: Port 7860 auf Clore.ai freigeben

Navigieren Sie im Clore.ai-Dashboard zu Ihrem Server → Bereich Ports → stellen Sie sicher, dass `7860` zugeordnet ist. Wenn Sie eine benutzerdefinierte Vorlage verwenden, fügen Sie `7860:7860` vor dem Starten des Servers Ihrer Port-Konfiguration hinzu.

### Schritt 4: Erster Start

Beim ersten Besuch wird Langflow:

1. Einen Willkommensbildschirm anzeigen und zur Erstellung eines Kontos auffordern (oder überspringen)
2. Eine Auswahl an Starter-Vorlagen anbieten (RAG, Chatbot, Agent)
3. Den visuellen Canvas-Editor öffnen

Sie sind bereit, Ihren ersten Flow zu erstellen!

***

## Konfiguration

### Persistente Datenspeicherung

Standardmäßig speichert Langflow Flows und Daten innerhalb des Containers. Mounten Sie ein Volume, um Daten über Neustarts hinweg zu behalten:

```bash
mkdir -p /opt/langflow/data

docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  langflowai/langflow:latest
```

### Referenz der Umgebungsvariablen

```bash
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_HOST=0.0.0.0 \
  -e LANGFLOW_PORT=7860 \
  -e LANGFLOW_DATABASE_URL=sqlite:////app/langflow/langflow.db \
  -e LANGFLOW_SECRET_KEY=your-secret-key-here \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=your-password \
  -e LANGFLOW_WORKERS=2 \
  -e LANGFLOW_LOG_LEVEL=info \
  langflowai/langflow:latest
```

| Variable                      | Beschreibung                              | Standard           |
| ----------------------------- | ----------------------------------------- | ------------------ |
| `LANGFLOW_HOST`               | Bind-Adresse                              | `0.0.0.0`          |
| `LANGFLOW_PORT`               | Webserver-Port                            | `7860`             |
| `LANGFLOW_DATABASE_URL`       | Datenbank-Verbindungszeichenfolge         | SQLite im Speicher |
| `LANGFLOW_SECRET_KEY`         | Session-Geheimnis (für Produktion setzen) | Zufällig           |
| `LANGFLOW_AUTO_LOGIN`         | Login-Bildschirm überspringen             | `true`             |
| `LANGFLOW_SUPERUSER`          | Admin-Benutzername                        | `admin`            |
| `LANGFLOW_SUPERUSER_PASSWORD` | Admin-Passwort                            | —                  |
| `LANGFLOW_WORKERS`            | Anzahl der API-Worker                     | `1`                |
| `LANGFLOW_LOG_LEVEL`          | Logging-Detailstufe                       | `kritisch`         |
| `OPENAI_API_KEY`              | OpenAI-Schlüssel vorladen                 | —                  |

### Verwendung von PostgreSQL (Produktion)

Bei Multi-User- oder Produktions-Bereitstellungen verwenden Sie PostgreSQL statt SQLite:

```bash
# PostgreSQL starten
docker run -d \
  --name langflow-db \
  --restart unless-stopped \
  -e POSTGRES_USER=langflow \
  -e POSTGRES_PASSWORD=langflow-secret \
  -e POSTGRES_DB=langflow \
  -v langflow-pgdata:/var/lib/postgresql/data \
  postgres:16-alpine

# Langflow mit PostgreSQL-Backend starten
docker run -d \
  --name langflow \
  --restart unless-stopped \
  --link langflow-db:db \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  -e LANGFLOW_DATABASE_URL=postgresql://langflow:langflow-secret@db:5432/langflow \
  -e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32) \
  -e LANGFLOW_AUTO_LOGIN=false \
  -e LANGFLOW_SUPERUSER=admin \
  -e LANGFLOW_SUPERUSER_PASSWORD=changeme \
  langflowai/langflow:latest
```

### Docker Compose (Full Stack)

Für eine vollständige Einrichtung mit PostgreSQL und Nginx-Reverse-Proxy:

```yaml
# /opt/langflow/docker-compose.yml
version: "3.9"

services:
  langflow:
    image: langflowai/langflow:latest
    restart: unless-stopped
    ports:
      - "7860:7860"
    environment:
      - LANGFLOW_DATABASE_URL=postgresql://langflow:secret@db:5432/langflow
      - LANGFLOW_SECRET_KEY=${SECRET_KEY:-changeme}
      - LANGFLOW_AUTO_LOGIN=false
      - LANGFLOW_SUPERUSER=admin
      - LANGFLOW_SUPERUSER_PASSWORD=${ADMIN_PASSWORD:-changeme}
      - LANGFLOW_WORKERS=2
    volumes:
      - langflow-data:/app/langflow
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_USER=langflow
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=langflow
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U langflow"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  langflow-data:
  pgdata:
```

```bash
cd /opt/langflow
SECRET_KEY=$(openssl rand -hex 32) ADMIN_PASSWORD=yourpassword docker compose up -d
```

### Feste Version wählen

Für reproduzierbare Bereitstellungen eine spezifische Version festlegen:

```bash
# Verfügbare Versionen auflisten: https://hub.docker.com/r/langflowai/langflow/tags
docker run -d \
  --name langflow \
  -p 7860:7860 \
  langflowai/langflow:1.1.4
```

***

## GPU-Beschleunigung (Integration lokaler Modelle)

Langflow selbst läuft auf der CPU, aber durch die Verbindung mit lokalen, GPU-beschleunigten Diensten auf demselben Clore.ai-Server wird kostenlose, private Inferenz möglich.

### Langflow mit Ollama verbinden

```bash
# Schritt 1: Ollama mit GPU starten
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# Schritt 2: Modelle für verschiedene Anwendungsfälle ziehen
docker exec ollama ollama pull llama3.1:8b          # Allgemeiner Chat
docker exec ollama ollama pull nomic-embed-text     # Embeddings für RAG
docker exec ollama ollama pull qwen2.5-coder:7b    # Code-Generierung

# Schritt 3: Langflow mit Netzwerkzugang zu Ollama starten
docker run -d \
  --name langflow \
  --restart unless-stopped \
  -p 7860:7860 \
  -v /opt/langflow/data:/app/langflow \
  --add-host host.docker.internal:host-gateway \
  langflowai/langflow:latest
```

Verwenden Sie in der Langflow-UI die **Ollama** Komponente mit:

* Basis-URL: `http://host.docker.internal:11434`
* Modell: `llama3.1:8b`

Für Embeddings verwenden Sie die **OllamaEmbeddings** Komponente mit:

* Basis-URL: `http://host.docker.internal:11434`
* Modell: `nomic-embed-text`

> Vollständige Ollama-Konfiguration: siehe die [Ollama-Anleitung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama)

### Langflow mit vLLM (OpenAI-kompatibel) verbinden

```bash
# vLLM mit OpenAI-kompatibler API starten
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --gpu-memory-utilization 0.85

# In Langflow die OpenAI-Komponente mit benutzerdefinierter Basis-URL verwenden:
# Basis-URL: http://host.docker.internal:8000/v1
# API-Schlüssel: (beliebiger Wert, z. B. "none")
# Modell: mistralai/Mistral-7B-Instruct-v0.3
```

> Vollständige vLLM-Konfiguration: siehe die [vLLM-Anleitung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm)

### Erstellen einer lokalen RAG-Pipeline

Beispiel-RAG-Flow, der nur lokale Modelle verwendet (keine API-Kosten):

1. **Datei-Lader** Knoten → PDF-/Textdokumente laden
2. **Text-Splitter** Knoten → Dokumente in Stücke teilen (Größe: 512, Überlappung: 50)
3. **OllamaEmbeddings** Knoten → Embeddings erzeugen (Modell: `nomic-embed-text`)
4. **Chroma** oder **FAISS** Knoten → Vektoren lokal speichern
5. **OllamaEmbeddings** Knoten → Die Anfrage des Benutzers einbetten
6. **Retriever** Knoten → Top-k ähnliche Stücke finden
7. **Ollama** Knoten → Antwort generieren (Modell: `llama3.1:8b`)
8. **Chat-Ausgabe** Knoten → Antwort zurückgeben

Diese gesamte Pipeline läuft auf Ihrem Clore.ai-Server ohne externe API-Aufrufe.

***

## Tipps & bewährte Methoden

### 1. Flows als Backups exportieren

Bevor Sie Ihren Clore.ai-Server stoppen, exportieren Sie Ihre Flows:

* In der UI: Flows → Alle auswählen → Export → JSON herunterladen
* Oder über die API: `curl http://localhost:7860/api/v1/flows/`

Speichern Sie sie in einem persistenten Volume oder laden Sie sie auf Ihren lokalen Rechner herunter.

### 2. Verwenden Sie die API zur Automatisierung

Jeder Langflow-Flow erzeugt einen API-Endpunkt. Starten Sie Flows programmgesteuert:

```bash
# Holen Sie sich Ihre Flow-ID aus der UI (in der URL angezeigt)
FLOW_ID="your-flow-id-here"

curl -X POST \
  "http://<server-ip>:7860/api/v1/run/$FLOW_ID" \
  -H "Content-Type: application/json" \
  -d '{
    "input_value": "Fasse die neuesten KI-Forschungsarbeiten zusammen",
    "input_type": "chat",
    "output_type": "chat"
  }'
```

### 3. Sichern Sie Ihre Instanz

Für alles über lokales Testen hinaus:

```bash
# Immer Authentifizierung setzen
-e LANGFLOW_AUTO_LOGIN=false \
-e LANGFLOW_SUPERUSER=admin \
-e LANGFLOW_SUPERUSER_PASSWORD=$(openssl rand -base64 16)

# Verwenden Sie einen starken Secret Key
-e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32)
```

### 4. Überwachen Sie den Speicherverbrauch

Langflow kann mit vielen aktiven Flows im Laufe der Zeit Speicher ansammeln:

```bash
docker stats langflow
# Wenn der Speicher unbounded wächst, regelmäßig neu starten:
docker restart langflow
```

### 5. Verwenden Sie Starter-Vorlagen

Langflow wird mit produktionsbereiten Vorlagen geliefert:

* **Basic RAG** — Dokumenten-Q\&A mit Vektor-Speicher
* **Memory-Chatbot** — Konversationeller Agent mit Verlauf
* **Research Assistant** — Websuche + LLM-Synthese
* Zugriff über: Neuer Flow → Starter-Projekte

### 6. Komponenten-Caching

Aktivieren Sie Caching, um wiederholte Flow-Ausführungen zu beschleunigen:

* In den Flow-Einstellungen: Aktivieren Sie "Cache" für teure Knoten (Embeddings, LLM-Aufrufe)
* Besonders nützlich für RAG-Retrieval während der Entwicklung

***

## Fehlerbehebung

### Container startet nicht

```bash
# Prüfen Sie die Logs auf Fehler
docker logs langflow --tail 50

# Häufiges Problem: Port bereits in Gebrauch
lsof -i :7860
# Töten Sie den konfliktären Prozess oder ändern Sie den Port:
docker run ... -p 7861:7860 ...
```

### UI lädt, aber Flows laufen nicht

```bash
# Überprüfen Sie den Status der Worker-Prozesse
docker exec langflow ps aux | grep langflow

# Prüfen Sie auf Python-Paketfehler
docker logs langflow 2>&1 | grep -i error

# Container neu starten
docker restart langflow
```

### Keine Verbindung zu Ollama möglich

```bash
# Testen Sie die Konnektivität aus dem Langflow-Container heraus
docker exec langflow curl http://host.docker.internal:11434/api/tags

# Falls das --add-host-Flag fehlt, erstellen Sie den Container neu mit:
--add-host host.docker.internal:host-gateway

# Überprüfen Sie, ob Ollama läuft
docker ps | grep ollama
curl http://localhost:11434/api/tags
```

### Datenbankfehler beim Neustart

```bash
# Falls Sie SQLite verwenden und Sperrfehler erhalten:
docker stop langflow
ls -la /opt/langflow/data/
# Prüfen Sie auf veraltete .lock-Dateien
rm -f /opt/langflow/data/langflow.db-wal
rm -f /opt/langflow/data/langflow.db-shm
docker start langflow
```

### Langsame Flow-Ausführung

```bash
# Worker für parallele Verarbeitung erhöhen
-e LANGFLOW_WORKERS=4

# Bei embedding-lastigen Workloads sicherstellen, dass Ollama die GPU nutzt:
docker exec ollama nvidia-smi
# Sollte GPU-Auslastung beim Embedding anzeigen
```

### Admin-Passwort zurücksetzen

```bash
docker exec -it langflow python -c "
from langflow.services.database.utils import initialize_db
from langflow.services.deps import get_settings_service
# Verwenden Sie stattdessen die Langflow-CLI:
"
# Verwenden Sie die CLI-Methode:
docker exec -it langflow langflow superuser --username admin --password newpassword
```

***

## Weiterführende Lektüre

* [Langflow GitHub-Repository](https://github.com/langflow-ai/langflow) — Quellcode, Issues, Changelog
* [Langflow-Dokumentation](https://docs.langflow.org) — Offizielle Doku, Komponenten-Referenz, API-Doku
* [Langflow Discord](https://discord.com/invite/EqksyE2EX9) — Community-Support und Flow-Sharing
* [Ollama auf Clore.ai](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — Lokales LLM-Backend für Langflow einrichten
* [vLLM auf Clore.ai](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Hochdurchsatz-LLM-Serving für Produktions-Flows
* [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — Wählen Sie die richtige Clore.ai-GPU für Ihre Arbeitslast
* [LangChain-Dokumentation](https://python.langchain.com/docs/) — Referenz des zugrunde liegenden Frameworks
* [Docker Hub: langflowai/langflow](https://hub.docker.com/r/langflowai/langflow) — Verfügbare Image-Tags und Versionen