Flowise KI-Agenten-Builder

Deploye Flowise auf Clore.ai — baue und hoste visuelle LLM-Chatbots, KI-Agenten und RAG-Pipelines auf günstigen GPU-Cloud-Servern mit einer Drag-and-Drop-No-Code-Oberfläche und sofortigen API-Endpunkten.

Überblick

Flowise ist ein Open-Source-Drag-and-Drop-Tool zum Erstellen von LLM-gestützten Anwendungen ohne Code zu schreiben. Mit über 35.000 GitHub-Sternen und mehr als 5 Millionen Docker-Hub-Abrufen, ist Flowise eines der am häufigsten eingesetzten selbst gehosteten KI-Tools im Ökosystem geworden. Es ermöglicht Teams, Chatbots, RAG-Systeme, KI-Agenten und automatisierte Workflows über eine intuitive visuelle Oberfläche zu erstellen — und sie in wenigen Minuten als REST-API-Endpunkte bereitzustellen.

Flowise basiert auf LangChain.js und bietet eine knotenbasierte Oberfläche, auf der Sie Komponenten verbinden: LLMs, Vektordatenbanken, Dokumenten-Loader, Speicher, Tools und Agenten. Jeder Flow generiert automatisch ein einbettbares Chat-Widget und einen API-Endpunkt, den Sie in jede Anwendung integrieren können.

Wichtige Funktionen:

• Drag-and-Drop-Flow-Builder — Visuelle LLM-Orchestrierung mit über 100 vorgefertigten Knoten

• Chatbot-Erstellung — Einbettbare Chat-Widgets für Websites und Apps

• RAG-Pipelines — Dokumenten-Loader, Embedders und Vektorspeicher visuell verbinden

• Unterstützung für mehrere Agenten — Agentenhierarchien mit Tool-Nutzung und Delegation aufbauen

• Sofortige API — Jeder Flow generiert einen /api/v1/prediction/<flowId> Endpunkt

• LangChain-Knoten — Voller Zugriff auf das LangChain.js-Ökosystem

• Credential-Manager — API-Schlüssel, Datenbankverbindungen zentral verwalten

Warum Clore.ai für Flowise?

Flowise ist ein schlanker Node.js-Server — er übernimmt die Orchestrierung, nicht die Rechenarbeit. In Kombination mit Clore.ai ermöglicht er:

• Lokale Modell-Inferenz — Ollama oder vLLM auf demselben GPU-Server ausführen und API-Kosten eliminieren

• Private Dokumentenverarbeitung — RAG-Pipelines, die niemals Daten an externe Dienste senden

• Persistentes Deployment — Chatbot- und API-Hosting im Dauerbetrieb zu GPU-Server-Preisen

• Kosteneffizient im großen Maßstab — Multi-Tenant-Chatbot-Plattformen ohne API-Gebühren pro Aufruf aufbauen

• Full-Stack-KI-Hosting — Flowise + Ollama + Qdrant/Chroma alles auf einem einzigen günstigen Server

---

Anforderungen

Flowise selbst ist eine Node.js-Anwendung mit minimalen Ressourcenanforderungen. Eine GPU wird nur benötigt, wenn Sie ein lokales LLM-Backend hinzufügen.

Konfiguration	GPU	VRAM	RAM	Speicher	Geschätzter Preis
Nur Flowise (externe APIs)	Keine	—	2–4 GB	10 GB	~0,03–0,08 $/Std.
+ Ollama (Llama 3.1 8B)	RTX 3090	24 GB	16 GB	40 GB	ca. 0,07–0,21 $/h
+ Ollama (Mistral 7B + Embeddings)	RTX 3090	24 GB	16 GB	30 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 (Produktion)	A100 80GB	80 GB	64 GB	100 GB	Bare Metal

Hinweis: Flowise läuft auf jedem Clore.ai-Server problemlos. Eine GPU wird nur benötigt, wenn Sie kostenlose lokale Inferenz möchten. Siehe die GPU-Vergleichsleitfaden.

Clore.ai-Serveranforderungen:

• Docker Engine (auf allen Clore.ai-Images vorinstalliert)

• NVIDIA Container Toolkit (nur für GPU/Ollama)

• Port 3000 erreichbar (oder im Clore.ai-Dashboard zugeordnet)

• Mindestens 2 GB freier RAM, 10 GB Speicherplatz

---

Schnellstart

Schritt 1: Einen Server auf Clore.ai buchen

Im Clore.ai-Marktplatz:

• Für reine API-Nutzung: beliebiger Server, nach RAM ≥ 4 GB filtern

• Für lokales LLM: nach GPU ≥ 24 GB VRAM filtern

• Sicherstellen, dass Docker in der Vorlage aktiviert ist

Per SSH verbinden:

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

Schritt 2: Flowise ausführen (Einzelbefehl)

docker run -d \
  --name flowise \\
  --restart unless-stopped \\
  -p 3000:3000 \\
  flowiseai/flowise

Das war's. Flowise ist verfügbar unter http://<server-ip>:3000 innerhalb von 20–30 Sekunden.

Schritt 3: Prüfen, ob es läuft

# Container-Status prüfen
docker ps | grep flowise

# Protokolle prüfen
docker logs flowise --tail 20

# API testen
curl http://localhost:3000/api/v1/chatflows

Schritt 4: Die UI öffnen

Navigieren Sie zu http://<server-ip>:3000 in Ihrem Browser.

Clore.ai-Port-Zuordnung: Stellen Sie sicher, dass Port 3000 in Ihrer Clore.ai-Serverkonfiguration weitergeleitet wird. Gehen Sie zu den Serverdetails → Ports → bestätigen 3000:3000 zugeordnet ist. Einige Vorlagen stellen standardmäßig nur SSH bereit.

---

Konfiguration

Persistenter Speicher

Mounten Sie Volumes, damit Ihre Flows, Anmeldedaten und Uploads Container-Neustarts überstehen:

mkdir -p /opt/flowise/{data,uploads,logs}

docker run -d \
  --name flowise \\
  --restart unless-stopped \\
  -p 3000:3000 \\
  -v /opt/flowise/data:/root/.flowise \\
  -v /opt/flowise/uploads:/app/uploads \\
  -e DATABASE_PATH=/root/.flowise \\
  -e APIKEY_PATH=/root/.flowise \\
  -e SECRETKEY_PATH=/root/.flowise \\
  -e LOG_PATH=/root/.flowise/logs \\
  flowiseai/flowise

Authentifizierung

Schützen Sie Ihre Flowise-Instanz mit Benutzername/Passwort:

docker run -d \
  --name flowise \\
  --restart unless-stopped \\
  -p 3000:3000 \\
  -v /opt/flowise/data:/root/.flowise \\
  -e FLOWISE_USERNAME=admin \\
  -e FLOWISE_PASSWORD=$(openssl rand -base64 16) \\
  -e FLOWISE_SECRETKEY_OVERWRITE=$(openssl rand -hex 32) \\
  flowiseai/flowise

Sicherheitshinweis: Setzen Sie immer Anmeldedaten, wenn Sie Flowise öffentlich auf Clore.ai zugänglich machen. Ohne Authentifizierung kann jeder mit Ihrer Server-IP auf Ihre Flows und API-Schlüssel zugreifen.

Vollständige Referenz der Umgebungsvariablen

docker run -d \
  --name flowise \\
  --restart unless-stopped \\
  -p 3000:3000 \\
  -v /opt/flowise/data:/root/.flowise \\
  -e PORT=3000 \\
  -e FLOWISE_USERNAME=admin \\
  -e FLOWISE_PASSWORD=your-secure-password \\
  -e FLOWISE_SECRETKEY_OVERWRITE=your-secret-key \\
  -e DATABASE_TYPE=sqlite \\
  -e DATABASE_PATH=/root/.flowise \\
  -e APIKEY_PATH=/root/.flowise \\
  -e SECRETKEY_PATH=/root/.flowise \\
  -e LOG_PATH=/root/.flowise/logs \\
  -e LOG_LEVEL=info \\
  -e TOOL_FUNCTION_BUILTIN_DEP=crypto,fs \\
  -e TOOL_FUNCTION_EXTERNAL_DEP=moment,lodash \\
  -e CORS_ORIGINS=* \\
  -e IFRAME_ORIGINS=* \\
  flowiseai/flowise

Variable	Beschreibung	Standard
PORT	Webserver-Port	3000
FLOWISE_USERNAME	Admin-Benutzername (aktiviert Authentifizierung)	— (keine Authentifizierung)
FLOWISE_PASSWORD	Admin-Passwort	—
FLOWISE_SECRETKEY_OVERWRITE	Verschlüsselungsschlüssel für Anmeldedaten	Automatisch generiert
DATABASE_TYPE	sqlite oder mysql oder postgres	sqlite
DATABASE_PATH	SQLite-Speicherpfad	/root/.flowise
LOG_LEVEL	error, warn, info, debug	info
TOOL_FUNCTION_BUILTIN_DEP	Erlaubte Node.js-Built-ins in Code-Knoten	—
TOOL_FUNCTION_EXTERNAL_DEP	Erlaubte npm-Pakete in Code-Knoten	—
CORS_ORIGINS	Erlaubte CORS-Origins für die API	*
IFRAME_ORIGINS	Erlaubte Origins für Iframe-Einbettung	*

Docker Compose (Empfohlen)

Das offizielle Flowise-Repository enthält eine Docker-Compose-Konfiguration. Dies ist der empfohlene Ansatz für Clore.ai:

# Die offizielle docker-compose.yml herunterladen
curl -o /opt/flowise/docker-compose.yml \\
  https://raw.githubusercontent.com/FlowiseAI/Flowise/main/docker/docker-compose.yml

cd /opt/flowise

Oder erstellen Sie Ihre eigene mit PostgreSQL:

# /opt/flowise/docker-compose.yml
version: "3.9"

services:
  flowise:
    image: flowiseai/flowise:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - FLOWISE_USERNAME=${FLOWISE_USERNAME:-admin}
      - FLOWISE_PASSWORD=${FLOWISE_PASSWORD:-changeme}
      - FLOWISE_SECRETKEY_OVERWRITE=${SECRET_KEY}
      - DATABASE_TYPE=postgres
      - DATABASE_HOST=db
      - DATABASE_PORT=5432
      - DATABASE_USER=flowise
      - DATABASE_PASSWORD=flowise-secret
      - DATABASE_NAME=flowise
    volumes:
      - flowise-data:/root/.flowise
    depends_on:
      db:
        condition: service_healthy

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

volumes:
  flowise-data:
  pgdata:

SECRET_KEY=$(openssl rand -hex 32) \\
FLOWISE_PASSWORD=yourpassword \\
docker compose -f /opt/flowise/docker-compose.yml up -d

---

GPU-Beschleunigung (lokale LLM-Integration)

Flowise orchestriert — die GPU erledigt die schwere Arbeit in verbundenen Diensten.

Flowise + Ollama (Empfohlen)

Führen Sie Ollama auf demselben Clore.ai-Server aus und verbinden Sie Flowise damit:

# Schritt 1: Ollama mit GPU-Zugriff 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 herunterladen
docker exec ollama ollama pull llama3.1:8b          # Chat-/Agentenmodell
docker exec ollama ollama pull nomic-embed-text     # Embeddings für RAG
docker exec ollama ollama pull mistral:7b           # Alternatives Chatmodell

# Schritt 3: Flowise mit Host-Netzwerkzugriff starten
docker run -d \
  --name flowise \\
  --restart unless-stopped \\
  -p 3000:3000 \\
  -v /opt/flowise/data:/root/.flowise \\
  --add-host host.docker.internal:host-gateway \\
  -e FLOWISE_USERNAME=admin \\
  -e FLOWISE_PASSWORD=changeme \\
  flowiseai/flowise

In der Flowise-UI:

1. Einen neuen Chatflow erstellen

2. Fügen Sie Ollama Knoten (unter Chat Models)

   • Basis-URL: http://host.docker.internal:11434

   • Modellname: llama3.1:8b

3. Fügen Sie OllamaEmbeddings Knoten (für RAG)

   • Basis-URL: http://host.docker.internal:11434

   • Modellname: nomic-embed-text

4. Mit Ihrem Vector Store verbinden (Chroma, FAISS, Qdrant)

Siehe den vollständigen Ollama-Leitfaden für Modell-Download und GPU-Einrichtung.

Flowise + vLLM (Produktionsmaßstab)

Für OpenAI-kompatibles High-Throughput-Serving:

# vLLM 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 Flowise verwenden Sie den ChatOpenAI-Knoten mit benutzerdefinierter Basis-URL:
# Basis-URL: http://host.docker.internal:8000/v1
# OpenAI-API-Schlüssel: (beliebiger Wert)
# Modellname: mistralai/Mistral-7B-Instruct-v0.3

Siehe die vLLM-Leitfaden für Quantisierung und Multi-GPU-Konfigurationen.

Einen lokalen RAG-Chatbot erstellen

Vollständiger Flowise-Flow ohne externe API-Aufrufe auf Clore.ai:

Knoten	Komponente	Settings
1	PDF-Datei-Loader	Dokument hochladen
2	Rekursiver Text-Splitter	Chunk: 1000, Overlap: 200
3	Ollama Embeddings	Modell: nomic-embed-text
4	Vektorspeicher im Speicher	(oder Chroma für Persistenz)
5	Ollama Chat	Modell: llama3.1:8b
6	Konversationsbasierte Retrieval-QA	Kettentyp: Stuff
7	Puffer-Speicher	sitzungsbasierter Speicher

Exportieren Sie dies als API und betten Sie das Chat-Widget in jede Website ein.

---

Tipps & bewährte Praktiken

1. Flows regelmäßig exportieren

Bevor Sie Clore.ai-Server stoppen oder wechseln:

# Alle Flows per API exportieren
curl http://localhost:3000/api/v1/chatflows \\
  -H "Authorization: Basic $(echo -n admin:password | base64)" \\
  > /opt/flowise/backup-flows.json

# Oder die UI verwenden: Chatflows → Alle exportieren

2. Das Embed-Widget verwenden

Jeder Flowise-Chatflow generiert ein produktionsreifes Chat-Widget:

1. Öffnen Sie Ihren Chatflow → Klicken Sie auf </> (Einbetten)-Button

2. Den Skript-Snippet kopieren

3. In jede HTML-Seite einfügen — sofortiger Kundensupport-Bot

3. API-Schlüssel sicher verwalten

Speichern Sie alle LLM-API-Schlüssel im Credentials Bereich von Flowise (nicht hart in Flows codiert):

• Menü → Credentials → Credential hinzufügen

• Schlüssel werden verschlüsselt mit FLOWISE_SECRETKEY_OVERWRITE

4. Ratenbegrenzung

Für öffentlich zugängliche Deployments fügen Sie vor Flowise Ratenbegrenzung über Nginx oder Caddy hinzu:

# Einfache nginx-Reverse-Proxy-Konfiguration
docker run -d \
  --name nginx \\
  -p 80:80 \
  -v /opt/flowise/nginx.conf:/etc/nginx/conf.d/default.conf:ro \\
  --link flowise:flowise \\
  nginx:alpine

5. Leistung überwachen

# Ressourcen in Echtzeit überwachen
watch -n 3 'docker stats flowise ollama --no-stream'

# Flowise-Logs auf Fehler prüfen
docker logs flowise --tail 50 -f

# Prüfen, ob Flows aufgerufen werden
docker logs flowise 2>&1 | grep "Prediction"

6. Die SQLite-Datenbank sichern

# Ein Backup mit Zeitstempel erstellen
cp /opt/flowise/data/database.sqlite \\
   /opt/flowise/backup-$(date +%Y%m%d-%H%M%S).sqlite

# Oder mit Cron automatisieren
echo "0 */6 * * * cp /opt/flowise/data/database.sqlite /opt/flowise/backup-\$(date +\%Y\%m\%d-\%H\%M\%S).sqlite" | crontab -

---

Fehlerbehebung

Container beendet sich sofort

# Beendigungsgrund prüfen
docker logs flowise

# Häufige Ursachen:
# 1. Port 3000 wird bereits verwendet
lsof -i :3000
# Behebung: anderen Port verwenden
docker run ... -p 3001:3000 ...

# 2. Volume-Berechtigungsfehler
ls -la /opt/flowise/
chown -R 1000:1000 /opt/flowise/data

UI zeigt "Connection Failed"

# Prüfen, ob Flowise tatsächlich läuft
docker ps -a | grep flowise
docker stats flowise --no-stream

# Prüfen, ob es an alle Schnittstellen gebunden ist
docker logs flowise | grep "listening"
# Sollte anzeigen: Server lauscht auf Port 3000

# Zuerst lokal testen
curl -s http://localhost:3000/api/v1/chatflows | head -20

Flows schlagen mit LLM-Fehlern fehl

# Ollama-Konnektivität aus dem Flowise-Container testen
docker exec flowise wget -qO- http://host.docker.internal:11434/api/tags

# Falls das fehlschlägt, prüfen Sie, ob --add-host enthalten war:
docker inspect flowise | grep -A5 ExtraHosts

# Prüfen, ob Ollama läuft
curl http://localhost:11434/api/tags

Datenbank-Migrationsfehler beim Update

# Beim Upgrade von Flowise zuerst ein Backup erstellen
cp -r /opt/flowise/data /opt/flowise/data-backup-$(date +%Y%m%d)

# Neues Image ziehen
docker pull flowiseai/flowise:latest

# Mit demselben Volume neu starten (Migrationen laufen automatisch)
docker stop flowise && docker rm flowise
docker run -d --name flowise ... flowiseai/flowise:latest
docker logs flowise -f  # Migrationsausgabe beobachten

Fehler bei der Entschlüsselung von Anmeldedaten nach dem Neustart

# Wenn Sie FLOWISE_SECRETKEY_OVERWRITE nicht gesetzt haben, wird beim Neustart ein neuer Schlüssel generiert
# Immer explizit setzen:
-e FLOWISE_SECRETKEY_OVERWRITE=your-stable-32-char-secret

# Zur Wiederherstellung: Anmeldedaten nach dem Setzen eines stabilen Schlüssels erneut in der UI eingeben

CORS-Fehler des Chat-Widgets

# Bestimmte Origins zulassen (ersetzen Sie * in der Produktion durch Ihre Domain)
-e CORS_ORIGINS=https://yourdomain.com,http://localhost:3000
-e IFRAME_ORIGINS=https://yourdomain.com

---

Weiterführende Lektüre

• Flowise-GitHub-Repository — Quellcode, Releases, offizielles docker-compose

• Flowise-Dokumentation — Knoten-Referenz, API-Dokumentation, Bereitstellungsleitfäden

• Flowise-Discord — Community-Vorlagen, Flow-Sharing, Support

• Docker Hub: flowiseai/flowise — über 5 Mio. Abrufe, verfügbare Tags

• Ollama auf Clore.ai — Lokale LLMs für kostenlose Flowise-Inferenz ausführen

• vLLM auf Clore.ai — LLM-Bereitstellung im Produktionsmaßstab für Flowise

• GPU-Vergleichsleitfaden — Wählen Sie die richtige GPU für Ihren Stack

• LangChain.js-Dokumentation — Referenz zum zugrunde liegenden Framework