# Flowise KI-Agenten-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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/flowise.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.