> 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/dify.md).

# Dify.ai-Workflow-Plattform

Deploye Dify.ai auf Clore.ai — baue produktionsreife KI-Workflows, RAG-Pipelines und Agentenanwendungen mit einer visuellen Oberfläche zu GPU-Cloud-Preisen.

## Überblick

[Dify.ai](https://github.com/langgenius/dify) ist eine Open-Source-LLM-Anwendungsentwicklungsplattform mit **114K+ GitHub-Sternen**. Sie vereint einen visuellen Workflow-Builder, eine Retrieval-Augmented-Generation-(RAG)-Pipeline, Agenten-Orchestrierung, Modellverwaltung und eine API-Bereitstellung per Klick in einem einzigen selbst hostbaren Stack.

Auf **Clore.ai** Sie können den vollständigen Dify-Stack — einschließlich seiner Postgres-Datenbank, Redis-Cache, Weaviate-Vektorspeicher, Nginx-Reverse-Proxy, API-Worker und Web-Frontend — auf einem gemieteten GPU-Server schon ab **ca. 0,07–0,21 $/h** (RTX 3090/4090). Die GPU ist für Dify selbst optional, wird aber unverzichtbar, wenn Sie lokale Modellinferenz über Ollama- oder vLLM-Backends integrieren.

**Wichtige Funktionen:**

* 🔄 **Visueller Workflow-Builder** — LLM-Pipelines per Drag-and-drop mit Verzweigungen, Schleifen und bedingter Logik
* 📚 **RAG-Pipeline** — PDFs, URLs und Notion-Seiten hochladen; Chunking + Embedding + Retrieval alles in der UI verwaltet
* 🤖 **Agentenmodus** — ReAct- und Function-Calling-Agenten mit Tool-Nutzung (Websuche, Code-Interpreter, benutzerdefinierte APIs)
* 🚀 **API-first** — jede App generiert sofort einen REST-Endpunkt und SDK-Snippets
* 🔌 **100+ Modellintegrationen** — OpenAI, Anthropic, Mistral, Cohere sowie lokale Modelle über Ollama/vLLM
* 🏢 **Mandantenfähig** — Teams, Arbeitsbereiche, RBAC, Nutzungskontingente

***

## Anforderungen

{% hint style="warning" %}
**Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

Dify läuft als Docker-Compose-Stack mit mehreren Containern. Der kleinste sinnvolle Server für die Entwicklung ist eine reine CPU-Instanz; für die Produktion mit lokaler Modellinferenz benötigen Sie einen GPU-Knoten.

| Konfiguration                   | GPU             | VRAM  | System-RAM | Festplatte | Clore.ai-Preis                            |
| ------------------------------- | --------------- | ----- | ---------- | ---------- | ----------------------------------------- |
| **Minimal** (nur API-Schlüssel) | Keins / CPU     | —     | 8 GB       | 30 GB      | \~$0,05/Stunde (CPU)                      |
| **Standard**                    | RTX 3080        | 10 GB | 16 GB      | 50 GB      | $0,05–0,19/Std.                           |
| **Empfohlen**                   | RTX 3090 / 4090 | 24 GB | 32 GB      | 80 GB      | ca. 0,07–0,21 $/h                         |
| **Produktion + lokales LLM**    | A100 80 GB      | 80 GB | 64 GB      | 200 GB     | [Bare Metal](https://clore.ai/bare-metal) |
| **Hoher Durchsatz**             | H100 SXM        | 80 GB | 128 GB     | 500 GB     | \~$1,04/Stunde                            |

> **Tipp:** Wenn Sie nur Cloud-API-Anbieter (OpenAI, Anthropic usw.) nutzen, reicht jede 2-Kern-CPU-Instanz mit 8 GB RAM aus. Eine GPU ist nur relevant, wenn Sie lokale Modelle über Ollama oder vLLM ausführen — siehe [GPU-Beschleunigung](#gpu-acceleration) unten.

### Hinweis zum Speicherplatz

Weaviate- und Postgres-Daten wachsen durch Dokument-Uploads schnell. Stellen Sie **mindestens 50 GB** bereit und binden Sie persistenten Speicher über die Volume-Optionen von Clore.ai ein.

***

## Schnellstart

### 1. Einen Clore.ai-Server mieten

Rufen Sie [clore.ai](https://clore.ai)auf, filtern Sie nach der gewünschten GPU und stellen Sie einen Server bereit mit:

* **Docker** vorinstalliert (alle Clore-Images enthalten es)
* Freigegebene Ports **80** und **443** (fügen Sie bei Bedarf benutzerdefinierte Ports in den Angebots-Einstellungen hinzu)
* SSH-Zugriff aktiviert

### 2. Verbinden und den Server vorbereiten

```bash
# Per SSH auf Ihren Clore-Server
ssh root@<clore-server-ip> -p <ssh-port>

# Systempakete aktualisieren
apt-get update && apt-get upgrade -y

# Prüfen, ob Docker verfügbar ist
docker --version
docker compose version   # Sollte v2.x sein
```

### 3. Dify klonen und starten

```bash
# Repository klonen
git clone https://github.com/langgenius/dify.git
cd dify/docker

# Die Beispiel-Umgebungsdatei kopieren
cp .env.example .env

# (Optional) Einstellungen vor dem Start bearbeiten
nano .env

# Alle Images ziehen und alle Dienste im Hintergrund starten
docker compose up -d

# Logs während des Starts beobachten (beim ersten Lauf 2–3 Minuten)
docker compose logs -f
```

### 4. Prüfen, ob alle Dienste gesund sind

```bash
# Container-Status prüfen
docker compose ps

# Erwartete Ausgabe:
# NAME                    STATUS
# docker-api-1            Läuft (healthy)
# docker-web-1            Läuft (healthy)
# docker-worker-1         Läuft (healthy)
# docker-nginx-1          Läuft
# docker-db-1             Läuft (healthy)
# docker-redis-1          Läuft (healthy)
# docker-weaviate-1       Läuft (healthy)
# docker-sandbox-1        Läuft (healthy)
```

### 5. Auf die Web-UI zugreifen

Öffnen Sie Ihren Browser und navigieren Sie zu:

```
http://<clore-server-ip>:80
```

Beim ersten Start leitet Dify Sie zum Einrichtungsassistenten weiter, um das Admin-Konto zu erstellen. Schließen Sie den Assistenten ab und melden Sie sich dann an.

***

## Konfiguration

Alle Konfiguration liegt in `dify/docker/.env`. Hier sind die wichtigsten Einstellungen:

### Wichtige Umgebungsvariablen

```bash
# ── Geheimschlüssel (DIESE ÄNDERN) ──────────────────────────────────────────────
SECRET_KEY=your-super-secret-key-change-this-immediately
# Einen starken Schlüssel generieren:
# python3 -c "import secrets; print(secrets.token_hex(32))"

# ── Anwendungs-URL ──────────────────────────────────────────────────────────
# Auf die öffentliche IP oder Domain Ihres Servers setzen
CONSOLE_WEB_URL=http://<clore-server-ip>
APP_WEB_URL=http://<clore-server-ip>

# ── Datenbank (Postgres) ─────────────────────────────────────────────────────
DB_USERNAME=postgres
DB_PASSWORD=difyai123456          # In der Produktion ändern!
DB_HOST=db
DB_PORT=5432
DB_DATABASE=dify

# ── Redis ───────────────────────────────────────────────────────────────────
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=difyai123456       # In der Produktion ändern!

# ── Speicher (standardmäßig lokales Laufwerk) ─────────────────────────────────────────
STORAGE_TYPE=local
# Oder S3-kompatiblen Speicher verwenden:
# STORAGE_TYPE=s3
# S3_ENDPOINT=https://s3.amazonaws.com
# S3_BUCKET_NAME=your-dify-bucket
# S3_ACCESS_KEY=...
# S3_SECRET_KEY=...

# ── Standard-LLM-Anbieter ─────────────────────────────────────────────────────
# Nach dem Login in der UI festlegen oder hier vorab konfigurieren:
# OPENAI_API_KEY=sk-...
```

### Ändern des freigegebenen Ports

Standardmäßig lauscht Nginx auf Port **80**. So ändern Sie ihn:

```bash
# In docker-compose.yaml den nginx-Dienst bearbeiten:
# ports:
#   - "8080:80"   ← 8080 auf den gewünschten Host-Port ändern

# Dann neu starten:
docker compose down && docker compose up -d
```

### Persistente Datenvolumes

Dify's Compose-Datei bindet diese Volumes standardmäßig ein:

```yaml
volumes:
  oradata:          # Postgres-Daten
  redis_data:       # Redis AOF
  weaviate_data:    # Vektorspeicher
  app_storage:      # Hochgeladene Dokumente und generierte Dateien
```

Zum Sichern:

```bash
# Zuerst Dienste stoppen, dann die Docker-Volumes als Tar archivieren
docker compose stop
docker run --rm \\
  -v docker_oradata:/data \\
  -v $(pwd)/backups:/backup \\
  alpine tar czf /backup/postgres-$(date +%Y%m%d).tar.gz /data
docker compose start
```

***

## GPU-Beschleunigung

Dify's Kernplattform basiert auf CPU, aber Sie schalten lokale Modellinferenz frei, indem Sie **Ollama** oder **vLLM** als Modellanbieter integrieren — beide profitieren enorm von einer GPU.

### Option A: Ollama als Sidecar (am einfachsten)

Führen Sie Ollama zusammen mit Dify auf demselben Clore-Server aus:

```bash
# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# Ein Modell herunterladen (z. B. Llama 3 8B)
ollama pull llama3:8b

# Prüfen, ob die GPU verwendet wird
ollama run llama3:8b "Hallo!"
nvidia-smi   # Sollte den Ollama-Prozess anzeigen, der VRAM verwendet
```

Dann in der Dify-UI → **Einstellungen → Modellanbieter → Ollama**:

* Basis-URL: `http://localhost:11434`
* Wählen Sie Ihr Modell aus und speichern Sie

> Eine vollständige Ollama-Anleitung finden Sie unter [language-models/ollama.md](/guides/guides_v2-de/sprachmodelle/ollama.md).

### Option B: vLLM als Sidecar (hoher Durchsatz)

```bash
# vLLM als separaten Container mit GPU-Passthrough ausführen
docker run -d \
  --name vllm \
  --gpus all \
  --runtime nvidia \\
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  -e HUGGING_FACE_HUB_TOKEN=<your-hf-token> \\
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.2 \\
  --dtype auto \\
  --max-model-len 4096

# Endpunkt prüfen
curl http://localhost:8000/v1/models
```

Dann in der Dify-UI → **Einstellungen → Modellanbieter → OpenAI-kompatibel**:

* Basis-URL: `http://localhost:8000/v1`
* API-Schlüssel: `dummy`
* Modellname: `mistralai/Mistral-7B-Instruct-v0.2`

> Die vollständige vLLM-Einrichtung finden Sie unter [language-models/vllm.md](/guides/guides_v2-de/sprachmodelle/vllm.md).

### Empfehlungen zum GPU-Speicher für lokale Modelle

| Modell             | Erforderlicher VRAM | Empfohlene Clore-GPU |
| ------------------ | ------------------- | -------------------- |
| Llama 3 8B (Q4)    | 6 GB                | RTX 3060             |
| Llama 3 8B (FP16)  | 16 GB               | RTX 3090 / 4090      |
| Mistral 7B (Q4)    | 5 GB                | RTX 3060             |
| Llama 3 70B (Q4)   | 40 GB               | A100 40GB            |
| Llama 3 70B (FP16) | 140 GB              | 2× H100              |

***

## Tipps & bewährte Methoden

### Kostenoptimierung auf Clore.ai

```bash
# Nutzen Sie Spot-Preise — Dify-Datenbanken speichern den Zustand in Volumes
# sodass Sie die Instanz günstig stoppen/neu starten können

# Vor dem Stoppen Ihrer Clore-Instanz die DB sichern:
docker exec docker-db-1 pg_dump -U postgres dify > dify_backup_$(date +%Y%m%d).sql

# Das Speicher-Volume für den Transfer komprimieren
tar czf dify_storage_$(date +%Y%m%d).tar.gz \\
  $(docker volume inspect docker_app_storage --format '{{.Mountpoint}}')
```

### HTTPS mit Caddy aktivieren (für die Produktion empfohlen)

```bash
# Caddy zu docker-compose.yaml hinzufügen oder separat ausführen
docker run -d \
  --name caddy \\
  --network docker_default \\
  -p 443:443 -p 80:80 \\
  -v $PWD/Caddyfile:/etc/caddy/Caddyfile \\
  -v caddy_data:/data \\
  caddy:latest

# Inhalt der Caddyfile:
# your-domain.com {
#     reverse_proxy nginx:80
# }
```

### Worker für hohe Last skalieren

```bash
# Statt 1 4 Celery-Worker ausführen
docker compose up -d --scale worker=4
```

### Ressourcennutzung überwachen

```bash
# Live-Container-Statistiken
docker stats

# GPU-Auslastung (wenn lokale Modelle verwendet werden)
watch -n1 nvidia-smi

# Dify-Anwendungsprotokolle
docker compose logs -f api worker
```

### RAG-Performance-Feinabstimmung

* Setze **Chunk-Größe** auf 512–1024 Tokens für die meisten Dokumenttypen
* Aktiviere **Parent-Child-Retrieval** für lange Dokumente in den Dataset-Einstellungen
* Verwende **hybride Suche** (Schlüsselwort + Vektor) für besseren Recall bei technischen Inhalten
* Dokumente außerhalb der Spitzenzeiten indexieren, um API-Ratenlimits zu vermeiden

***

## Fehlerbehebung

### Dienste starten ständig neu

```bash
# In den Protokollen des fehlerhaften Dienstes nachsehen
docker compose logs --tail=50 api
docker compose logs --tail=50 worker

# Häufige Ursache: falscher SECRET_KEY oder DB-Verbindung
# Sicherstellen, dass .env SECRET_KEY gesetzt und eindeutig ist
grep SECRET_KEY .env
```

### "Migration fehlgeschlagen" beim Start

```bash
# DB-Migrationen manuell ausführen
docker compose exec api flask db upgrade

# Wenn das fehlschlägt, zuerst prüfen, ob Postgres gesund ist
docker compose exec db pg_isready -U postgres
```

### Keine Verbindung zu Ollama von Dify aus möglich

```bash
# Ollama bindet standardmäßig an 127.0.0.1
# Ändern Sie dies, damit auf allen Schnittstellen gelauscht wird:
OLLAMA_HOST=0.0.0.0 ollama serve

# Oder den systemd-Dienst bearbeiten:
systemctl edit ollama
# Unter [Service] hinzufügen:
# Environment="OLLAMA_HOST=0.0.0.0"
systemctl restart ollama

# Aus einem Dify-Container testen:
docker compose exec api curl http://host.docker.internal:11434/api/tags
```

### Kein Speicherplatz mehr

```bash
# Volume-Größen prüfen
df -h
docker system df

# Nicht verwendete Images entfernen
docker image prune -a

# Weaviate-Protokolle können groß werden — rotieren Sie sie
docker compose exec weaviate truncate -s 0 /tmp/weaviate.log
```

### Fehler im Weaviate-Vektorspeicher

```bash
# Weaviate zurücksetzen (WARNUNG: löscht alle Embeddings, erneutes Indexieren erforderlich)
docker compose stop weaviate
docker volume rm docker_weaviate_data
docker compose up -d weaviate

# Dann Ihre Datasets in der Dify-UI → Datasets → [Dataset] → Neu indexieren
```

### Port 80 wird bereits verwendet

```bash
# Herausfinden, was Port 80 verwendet
ss -tlnp | grep :80
# oder
lsof -i :80

# Konfligierenden Dienst stoppen oder den nginx-Port von Dify in docker-compose.yaml ändern
```

***

## Weiterführende Lektüre

* [Dify-Official-Dokumentation](https://docs.dify.ai)
* [Dify-GitHub-Repository](https://github.com/langgenius/dify)
* [Dify-Self-Hosting-Anleitung](https://docs.dify.ai/getting-started/install-self-hosted/docker-compose)
* [Ollama auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/ollama.md)
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md)
* [Clore.ai GPU-Vergleich](/guides/guides_v2-de/erste-schritte/gpu-comparison.md)
* [Dify-Community-Discord](https://discord.gg/FngNHpbcY7)


---

# 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/dify.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.
