Langflow Visueller KI-Builder

Setzen Sie Langflow auf Clore.ai ein — erstellen und betreiben Sie visuelle KI-Pipelines, RAG-Systeme und Multi-Agenten-Workflows auf erschwinglicher GPU-Cloud-Infrastruktur mit 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 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.

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. Für die ausschließliche Nutzung von Langflow eignet sich 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 Befehl:

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:

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

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

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

Feste Version wählen

Für reproduzierbare Bereitstellungen eine spezifische 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 durch die Verbindung mit lokalen, GPU-beschleunigten Diensten auf demselben Clore.ai-Server wird kostenlose, private Inferenz möglich.

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

Langflow mit vLLM (OpenAI-kompatibel) verbinden

# 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

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:

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

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

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

# 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

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

# 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

# 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

# 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

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

• Langflow-Dokumentation — Offizielle Doku, Komponenten-Referenz, API-Doku

• Langflow Discord — Community-Support und Flow-Sharing

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

• vLLM auf Clore.ai — Hochdurchsatz-LLM-Serving für Produktions-Flows

• GPU-Vergleichsanleitung — Wählen Sie die richtige Clore.ai-GPU für Ihre Arbeitslast

• LangChain-Dokumentation — Referenz des zugrunde liegenden Frameworks

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