> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/flowise.md).

# 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](https://github.com/FlowiseAI/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](https://clore.ai/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](/guides/guides_v2-de/erste-schritte/gpu-comparison.md).

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

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

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

### Schritt 2: Flowise ausführen (Einzelbefehl)

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

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

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

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

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

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

```bash
# 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](/guides/guides_v2-de/sprachmodelle/ollama.md) für Modell-Download und GPU-Einrichtung.

### Flowise + vLLM (Produktionsmaßstab)

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

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

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

```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. Leistung überwachen

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

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

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

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

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

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

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

```bash
# 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](https://github.com/FlowiseAI/Flowise) — Quellcode, Releases, offizielles docker-compose
* [Flowise-Dokumentation](https://docs.flowiseai.com) — Knoten-Referenz, API-Dokumentation, Bereitstellungsleitfäden
* [Flowise-Discord](https://discord.gg/jn8n7yb9N) — Community-Vorlagen, Flow-Sharing, Support
* [Docker Hub: flowiseai/flowise](https://hub.docker.com/r/flowiseai/flowise) — über 5 Mio. Abrufe, verfügbare Tags
* [Ollama auf Clore.ai](/guides/guides_v2-de/sprachmodelle/ollama.md) — Lokale LLMs für kostenlose Flowise-Inferenz ausführen
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — LLM-Bereitstellung im Produktionsmaßstab für Flowise
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Wählen Sie die richtige GPU für Ihren Stack
* [LangChain.js-Dokumentation](https://js.langchain.com/docs/) — Referenz zum zugrunde liegenden Framework


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.