> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/langflow.md).

# Langflow Visual AI 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](/guides/guides_v2-de/erste-schritte/gpu-comparison.md).

**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](/guides/guides_v2-de/sprachmodelle/ollama.md)

### 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](/guides/guides_v2-de/sprachmodelle/vllm.md)

### 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](/guides/guides_v2-de/sprachmodelle/ollama.md) — Lokales LLM-Backend für Langflow einrichten
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — Hochdurchsatz-LLM-Serving für Produktions-Flows
* [GPU-Vergleichsanleitung](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — 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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/langflow.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.