> 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 visueller KI-Builder

Deploye Langflow auf Clore.ai — baue und betreibe visuelle KI-Pipelines, RAG-Systeme und Multi-Agenten-Workflows auf günstiger GPU-Cloud-Infrastruktur mit einer Drag-and-Drop-No-Code-Oberfläche.

## Ü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 zu einem der bevorzugten Tools geworden, um LLM-gestützte Workflows zu prototypisieren und bereitzustellen, ohne komplexen Boilerplate-Code zu schreiben.

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

**Wichtige Funktionen:**

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

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

Langflows Rechenanforderungen sind minimal — es ist ein Python-Webserver, der die Workflow-Orchestrierung übernimmt. Clore.ai eröffnet jedoch leistungsstarke Anwendungsfälle:

* **Selbstgehostete Embeddings** — Lokale Embedding-Modelle (nomic-embed, BGE) auf der GPU ausführen, um schnell und kostenlos Vektoren zu erzeugen
* **Lokale LLM-Backends** — Langflow mit Ollama oder vLLM verbinden, die auf demselben Server laufen
* **Private Datenpipelines** — Sensible Dokumente verarbeiten, ohne Daten an externe APIs zu senden
* **Kostenoptimierung** — Teure OpenAI-Embedding-Aufrufe durch kostenlose lokale Inferenz ersetzen
* **Persistente Workflows** — Lang laufende Flows auf dedizierten Servern (statt flüchtiger Cloud-Funktionen)

***

## Anforderungen

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

| Konfiguration                          | GPU                | VRAM  | RAM   | Speicher | Geschätzter Preis                         |
| -------------------------------------- | ------------------ | ----- | ----- | -------- | ----------------------------------------- |
| **Nur Langflow (API-Backends)**        | Nicht erforderlich | —     | 4 GB  | 10 GB    | ca. 0,03–0,08 $/h                         |
| **+ Lokale Embeddings (nomic-embed)**  | RTX 3090           | 24 GB | 8 GB  | 20 GB    | ca. 0,07–0,21 $/h                         |
| **+ Ollama (Llama 3.1 8B)**            | RTX 3090           | 24 GB | 16 GB | 40 GB    | ca. 0,07–0,21 $/h                         |
| **+ Ollama (Qwen2.5 32B)**             | RTX 4090           | 24 GB | 32 GB | 60 GB    | ca. 0,14–0,42 $/h                         |
| **+ vLLM (produktionstaugliches RAG)** | A100 80GB          | 80 GB | 64 GB | 100 GB   | [Bare Metal](https://clore.ai/bare-metal) |

> Für einen Vergleich der GPU-Optionen auf Clore.ai, siehe den [GPU-Vergleichsleitfaden](/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 lokales LLM erforderlich)
* 10+ GB freier Speicherplatz für das Langflow-Image und die Flow-Daten
* Ausgehender Internetzugang (zum Abrufen von Docker-Images und für externe APIs)

***

## Schnellstart

### Schritt 1: Mit Ihrem Clore.ai-Server verbinden

Buchen Sie einen Server auf [Clore.ai-Marktplatz](https://clore.ai). Für die reine Langflow-Nutzung reicht 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 einziger Befehl:

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

Warten Sie ca. 30–60 Sekunden, bis der Start abgeschlossen ist, dann unter folgendem Link öffnen: `http://<server-ip>:7860`

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

Im Clore.ai-Dashboard zu Ihrem Server → Bereich Ports navigieren → sicherstellen, dass `7860` der Port 7860 zugeordnet ist. Wenn Sie eine benutzerdefinierte Vorlage verwenden, fügen Sie `7860:7860` zu Ihrer Portkonfiguration hinzu, bevor Sie den Server starten.

### Schritt 4: Erster Start

Beim ersten Besuch wird Langflow:

1. Einen Willkommensbildschirm anzeigen und zum Erstellen eines Kontos auffordern (oder überspringen)
2. Eine Reihe von 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 im Container. Mounten Sie ein Volume, damit die Daten Neustarts überdauern:

```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`         | Sitzungsgeheimnis (für Produktion festlegen) | Zufällig           |
| `LANGFLOW_AUTO_LOGIN`         | Anmeldebildschirm überspringen               | `true`             |
| `LANGFLOW_SUPERUSER`          | Admin-Benutzername                           | `admin`            |
| `LANGFLOW_SUPERUSER_PASSWORD` | Admin-Passwort                               | —                  |
| `LANGFLOW_WORKERS`            | Anzahl der API-Worker                        | `1`                |
| `LANGFLOW_LOG_LEVEL`          | Protokollierungs-Detailgrad                  | `critical`         |
| `OPENAI_API_KEY`              | OpenAI-Schlüssel vorladen                    | —                  |

### Verwendung von PostgreSQL (Produktion)

Für Multi-User- oder Produktionsbereitstellungen PostgreSQL statt SQLite verwenden:

```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 (Vollständiger Stack)

Für ein vollständiges Setup 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
```

### Spezifische Version festlegen

Für reproduzierbare Bereitstellungen eine bestimmte 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 die Verbindung zu lokalen, GPU-gestützten Diensten auf demselben Clore.ai-Server schaltet kostenlose, private Inferenz frei.

### 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 herunterladen
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    # Codegenerierung

# Schritt 3: Langflow mit Ollama-Netzwerkzugriff 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 das **Ollama** -Element mit:

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

Für Embeddings verwenden Sie die **OllamaEmbeddings** -Element mit:

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

> Vollständige Ollama-Konfiguration: siehe den [Ollama-Leitfaden](/guides/guides_v2-de/sprachmodelle/ollama.md)

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

```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 den [vLLM-Leitfaden](/guides/guides_v2-de/sprachmodelle/vllm.md)

### Eine lokale RAG-Pipeline aufbauen

Beispiel-RAG-Flow nur mit lokalen Modellen (keine API-Kosten):

1. **Dateilader** Knoten → PDF-/Textdokumente laden
2. **Text-Teiler** Knoten → Dokumente in Chunks aufteilen (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 Benutzeranfrage einbetten
6. **Retriever** Knoten → Die ähnlichsten Top-k-Chunks 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 → Exportieren → 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. Die API für Automatisierung verwenden

Jeder Langflow-Flow generiert 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": "Fassen Sie die neuesten KI-Forschungsarbeiten zusammen",
    "input_type": "chat",
    "output_type": "chat"
  }'
```

### 3. Ihre Instanz absichern

Für alles über lokale Tests hinaus:

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

# Einen starken geheimen Schlüssel verwenden
-e LANGFLOW_SECRET_KEY=$(openssl rand -hex 32)
```

### 4. Speichernutzung überwachen

Langflow kann bei vielen aktiven Flows mit der Zeit Speicher verbrauchen:

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

### 5. Starter-Vorlagen verwenden

Langflow wird mit produktionsreifen Vorlagen ausgeliefert:

* **Grundlegendes RAG** — Dokumenten-Q\&A mit Vektorspeicher
* **Memory-Chatbot** — Konversationsagent mit Verlauf
* **Forschungsassistent** — Websuche + LLM-Zusammenfassung
* Zugriff über: Neuer Flow → Starter-Projekte

### 6. Komponenten-Caching

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

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

***

## Fehlerbehebung

### Container startet nicht

```bash
# Protokolle auf Fehler prüfen
docker logs langflow --tail 50

# Häufiges Problem: Port bereits in Verwendung
lsof -i :7860
# Den konfligierenden Prozess beenden oder den Port ändern:
docker run ... -p 7861:7860 ...
```

### UI lädt, aber Flows werden nicht ausgeführt

```bash
# Status des Worker-Prozesses prüfen
docker exec langflow ps aux | grep langflow

# Nach Python-Paketfehlern suchen
docker logs langflow 2>&1 | grep -i error

# Container neu starten
docker restart langflow
```

### Keine Verbindung zu Ollama möglich

```bash
# Die Verbindung von innerhalb des Langflow-Containers testen
docker exec langflow curl http://host.docker.internal:11434/api/tags

# Wenn das --add-host-Flag fehlt, den Container mit folgendem Befehl neu erstellen:
--add-host host.docker.internal:host-gateway

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

### Datenbankfehler beim Neustart

```bash
# Wenn SQLite verwendet wird und Sperrfehler auftreten:
docker stop langflow
ls -la /opt/langflow/data/
# Nach veralteten .lock-Dateien suchen
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

# Für embedding-intensive Workloads sicherstellen, dass Ollama die GPU verwendet:
docker exec ollama nvidia-smi
# Sollte bei Einbettungen die GPU-Auslastung 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
# Verwende stattdessen die Langflow-CLI:
"
# Verwende 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, Komponentenreferenz, API-Dokumentation
* [Langflow-Discord](https://discord.com/invite/EqksyE2EX9) — Community-Support und Teilen von Flows
* [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) — LLM-Serving mit hohem Durchsatz für Produktions-Flows
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Wähle die passende Clore.ai-GPU für deinen Workload
* [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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.