Flowise KI-Agenten-Builder

Setzen Sie Flowise auf Clore.ai ein — erstellen und hosten Sie visuelle LLM-Chatbots, KI-Agenten und RAG-Pipelines auf kostengünstigen GPU-Cloud-Servern mit 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 Programmierung. Mit über 35.000 GitHub-Sternen und mehr als 5 Millionen Docker Hub-Downloadsist Flowise zu einem der am häufigsten eingesetzten selbstgehosteten 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 diese innerhalb von Minuten als REST-API-Endpunkte bereitzustellen.

Flowise basiert auf LangChain.js und bietet eine nodenbasierte Arbeitsfläche, auf der Sie Komponenten verbinden: LLMs, Vektordatenbanken, Dokumenten-Loader, Speichermodule für Memory, Werkzeuge und Agenten. Jeder Flow erzeugt automatisch ein einbettbares Chat-Widget und einen API-Endpunkt, den Sie in jede Anwendung integrieren können.

Wesentliche Funktionen:

• Drag-and-Drop-Flow-Builder — Visuelle LLM-Orchestrierung mit 100+ vorgefertigten Nodes

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

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

• Multi-Agenten-Unterstützung — Erstellen Sie Agentenhierarchien mit Tool-Einsatz und Delegation

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

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

• Credential-Manager — Zentrale Verwaltung von API-Schlüsseln, Datenbankverbindungen

Warum Clore.ai für Flowise?

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

• Lokale Modellausführung — Führen Sie Ollama oder vLLM auf demselben GPU-Server aus und eliminieren Sie API-Kosten

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

• Persistente Bereitstellung — Dauerhaftes Hosting von Chatbot und API zu GPU-Serverpreisen

• Kosteneffizient im großen Maßstab — Bauen Sie Multi-Tenant-Chatbot-Plattformen ohne kostenpflichtige API-Aufrufe pro Request

• Full-Stack-KI-Hosting — Flowise + Ollama + Qdrant/Chroma alles auf einem erschwinglichen Server

---

Anforderungen

Flowise selbst ist eine Node.js-Anwendung mit minimalen Ressourcenanforderungen. Eine GPU ist nur erforderlich, 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/Stunde
+ Ollama (Llama 3.1 8B)	RTX 3090	24 GB	16 GB	40 GB	~$0.20/Stunde
+ Ollama (Mistral 7B + Embeddings)	RTX 3090	24 GB	16 GB	30 GB	~$0.20/Stunde
+ Ollama (Qwen2.5 32B)	RTX 4090	24 GB	32 GB	60 GB	~$0.35/Stunde
+ vLLM (Produktion)	A100 80GB	80 GB	64 GB	100 GB	~$1.10/Stunde

Hinweis: Flowise läuft komfortabel auf jedem Clore.ai-Server. Eine GPU ist nur nötig, wenn Sie lokale Inferenz ohne externe APIs wünschen. Siehe die GPU-Vergleichsanleitung.

Clore.ai-Serveranforderungen:

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

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

• Port 3000 zugänglich (oder im Clore.ai-Dashboard gemappt)

• Mindestens 2 GB freier RAM, 10 GB Festplattenspeicher

---

Schnellstart

Schritt 1: Buchen Sie einen Server bei Clore.ai

Im Clore.ai-Marktplatz:

• Für ausschließliche API-Nutzung: Jeder Server, filtern Sie nach RAM ≥ 4 GB

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

• Stellen Sie sicher, dass Docker in der Vorlage aktiviert ist

Verbinden Sie sich per SSH:

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

Schritt 2: Flowise starten (ein Befehl)

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

Das war's. Flowise ist erreichbar unter http://<server-ip>:3000 in 20–30 Sekunden.

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

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

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

# Testen Sie die API
curl http://localhost:3000/api/v1/chatflows

Schritt 4: Öffnen Sie die UI

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

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

---

Konfiguration

Persistenter Speicher

Mounten Sie Volumes, damit Ihre Flows, Anmeldeinformationen und Uploads Container-Neustarts überleben:

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 Anmeldeinformationen, wenn Sie Flowise öffentlich auf Clore.ai exponieren. 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=Ihr-sicheres-Passwort \
  -e FLOWISE_SECRETKEY_OVERWRITE=Ihr-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 Anmeldeinformationen	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-Builtins in Code-Nodes	—
TOOL_FUNCTION_EXTERNAL_DEP	Erlaubte npm-Pakete in Code-Nodes	—
CORS_ORIGINS	Erlaubte CORS-Ursprünge für die API	*
IFRAME_ORIGINS	Erlaubte Ursprünge für iframe-Einbettungen	*

Docker Compose (empfohlen)

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

# Laden Sie die offizielle docker-compose.yml herunter
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=IhrPasswort \
docker compose -f /opt/flowise/docker-compose.yml up -d

---

GPU-Beschleunigung (Integration lokaler LLMs)

Flowise orchestriert — die GPU übernimmt 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: Starten Sie Ollama mit GPU-Zugriff
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 Chat-Modell

# Schritt 3: Starten Sie Flowise mit Host-Netzwerkzugang
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

Im Flowise-UI:

1. Erstellen Sie einen neuen Chatflow

2. Hinzufügen Ollama Node (unter Chat Models)

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

   • Modellname: llama3.1:8b

3. Hinzufügen OllamaEmbeddings Node (für RAG)

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

   • Modellname: nomic-embed-text

4. Verbinden Sie Ihren Vektorspeicher (Chroma, FAISS, Qdrant)

Siehe die vollständige Ollama-Anleitung für Modelldownload und GPU-Setup.

Flowise + vLLM (Produktionsskala)

Für OpenAI-kompatible Hochdurchsatz-Bereitstellung:

# Starten Sie vLLM
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-Node 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-Anleitung für Quantisierung und Multi-GPU-Konfigurationen.

Einen rein lokalen RAG-Chatbot erstellen

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

Knoten	Komponente	Einstellungen
1	PDF-Datei-Loader	Dokument hochladen
2	Rekursiver Text-Splitter	Chunk: 1000, Überlappung: 200
3	Ollama-Embeddings	Modell: nomic-embed-text
4	In-Memory-Vektorspeicher	(oder Chroma für Persistenz)
5	Ollama Chat	Modell: llama3.1:8b
6	Konversationelle Retrieval-QA	Kettentyp: Stuff
7	Puffer-Speicher (Buffer Memory)	Sitzungsbasierter Speicher

Exportieren Sie dies als API und betten Sie das Chat-Widget auf jeder Website ein.

---

Tipps & bewährte Methoden

1. Flows regelmäßig exportieren

Bevor Sie Clore.ai-Server stoppen oder wechseln:

# Exportieren Sie alle Flows über die API
curl http://localhost:3000/api/v1/chatflows \
  -H "Authorization: Basic $(echo -n admin:password | base64)" \
  > /opt/flowise/backup-flows.json

# Oder verwenden Sie die UI: Chatflows → Alle exportieren

2. Verwenden Sie das Embed-Widget

Jeder Flowise-Chatflow erzeugt ein produktionsbereites Chat-Widget:

1. Öffnen Sie Ihren Chatflow → Klicken Sie </> auf die (Embed)-Schaltfläche

2. Kopieren Sie das Skript-Snippet

3. Fügen Sie es in jede HTML-Seite ein — sofortiger Kunden-Support-Bot

3. Verwalten Sie API-Schlüssel sicher

Speichern Sie alle LLM-API-Schlüssel im Credentials Panel von Flowise (nicht hartkodiert in Flows):

• Menü → Credentials → Credential hinzufügen

• Schlüssel werden verschlüsselt mit FLOWISE_SECRETKEY_OVERWRITE

4. Rate Limiting

Für öffentlich zugängliche Bereitstellungen fügen Sie Rate Limiting via Nginx oder Caddy vor Flowise 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. Überwachen Sie die Performance

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

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

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

6. Sichern Sie die SQLite-Datenbank

# Erstellen Sie ein zeitgestempeltes Backup
cp /opt/flowise/data/database.sqlite \
   /opt/flowise/backup-$(date +%Y%m%d-%H%M%S).sqlite

# Oder automatisieren Sie mit cron
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

# Prüfen Sie den Exit-Grund
docker logs flowise

# Häufige Ursachen:
# 1. Port 3000 ist bereits in Benutzung
lsof -i :3000
# Lösung: Verwenden Sie einen anderen Port
docker run ... -p 3001:3000 ...

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

UI zeigt „Connection Failed“

# Überprüfen Sie, dass Flowise tatsächlich läuft
docker ps -a | grep flowise
docker stats flowise --no-stream

# Prüfen Sie, ob es an alle Schnittstellen gebunden ist
docker logs flowise | grep "listening"
# Sollte anzeigen: Server is listening at port 3000

# Testen Sie zuerst lokal
curl -s http://localhost:3000/api/v1/chatflows | head -20

Flows schlagen fehl mit LLM-Fehlern

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

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

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

Datenbank-Migrationsfehler beim Update

# Sichern Sie zuerst, wenn Sie Flowise upgraden
cp -r /opt/flowise/data /opt/flowise/data-backup-$(date +%Y%m%d)

# Neues Image ziehen
docker pull flowiseai/flowise:latest

# Neustarten mit demselben Volume (Migrations laufen automatisch)
docker stop flowise && docker rm flowise
docker run -d --name flowise ... flowiseai/flowise:latest
docker logs flowise -f  # Überwachen Sie die Migrationsausgabe

Fehler bei der Entschlüsselung von Anmeldeinformationen nach Neustart

# Wenn Sie FLOWISE_SECRETKEY_OVERWRITE nicht gesetzt haben, wird beim Neustart ein neuer Schlüssel generiert
# Setzen Sie ihn immer explizit:
-e FLOWISE_SECRETKEY_OVERWRITE=Ihr-stabiler-32-zeichen-geheimnis

# Zur Wiederherstellung: Geben Sie die Anmeldeinformationen nach dem Setzen eines stabilen Schlüssels in der UI erneut ein

CORS-Fehler beim Chat-Widget

# Erlauben Sie spezifische Ursprünge (ersetzen Sie * durch Ihre Domain für Produktion)
-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 — Node-Referenz, API-Dokumentation, Deploy-Guides

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

• Docker Hub: flowiseai/flowise — 5M+ Downloads, verfügbare Tags

• Ollama auf Clore.ai — Führen Sie lokale LLMs für kostenlose Flowise-Inferenz aus

• vLLM auf Clore.ai — Produktionsskalige LLM-Serving für Flowise

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

• LangChain.js-Dokumentation — Referenz des zugrunde liegenden Frameworks