# Flowise KI-Agent-Builder

## Überblick

[Flowise](https://github.com/FlowiseAI/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-Downloads**ist 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](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison).

**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](https://clore.ai):

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

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

### Schritt 2: Flowise starten (ein Befehl)

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

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

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

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

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

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

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

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

```bash
# 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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) für Modelldownload und GPU-Setup.

### Flowise + vLLM (Produktionsskala)

Für OpenAI-kompatible Hochdurchsatz-Bereitstellung:

```bash
# 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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) 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:

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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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“

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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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](https://github.com/FlowiseAI/Flowise) — Quellcode, Releases, offizielles docker-compose
* [Flowise-Dokumentation](https://docs.flowiseai.com) — Node-Referenz, API-Dokumentation, Deploy-Guides
* [Flowise Discord](https://discord.gg/jn8n7yb9N) — Community-Templates, Flow-Sharing, Support
* [Docker Hub: flowiseai/flowise](https://hub.docker.com/r/flowiseai/flowise) — 5M+ Downloads, verfügbare Tags
* [Ollama auf Clore.ai](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — Führen Sie lokale LLMs für kostenlose Flowise-Inferenz aus
* [vLLM auf Clore.ai](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Produktionsskalige LLM-Serving für Flowise
* [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — Wählen Sie die richtige GPU für Ihren Stack
* [LangChain.js-Dokumentation](https://js.langchain.com/docs/) — Referenz des zugrunde liegenden Frameworks