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 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

Für einen Vergleich der GPU-Optionen auf Clore.ai, siehe den GPU-Vergleichsleitfaden.

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. Für die reine Langflow-Nutzung reicht jeder Server mit ≥4 GB RAM. Verbinden Sie sich per SSH:

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

Schritt 2: Langflow mit Docker ausführen

Die einfachste Bereitstellung — ein einziger Befehl:

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:

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

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:

# 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:

# /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:

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:

# 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

# 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

Langflow mit vLLM verbinden (OpenAI-kompatibel)

# 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

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:

# 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:

# 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:

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

# 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

# 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

# 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

# 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

# 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

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 — Quellcode, Issues, Changelog

• Langflow-Dokumentation — Offizielle Doku, Komponentenreferenz, API-Dokumentation

• Langflow-Discord — Community-Support und Teilen von Flows

• Ollama auf Clore.ai — Lokales LLM-Backend für Langflow einrichten

• vLLM auf Clore.ai — LLM-Serving mit hohem Durchsatz für Produktions-Flows

• GPU-Vergleichsleitfaden — Wähle die passende Clore.ai-GPU für deinen Workload

• LangChain-Dokumentation — Referenz des zugrunde liegenden Frameworks

• Docker Hub: langflowai/langflow — Verfügbare Image-Tags und Versionen