# Dify.ai Workflow-Plattform

## Überblick

[Dify.ai](https://github.com/langgenius/dify) ist eine Open-Source-Plattform zur Entwicklung von LLM-Anwendungen mit **114K+ GitHub-Sternen**. Sie kombiniert einen visuellen Workflow-Builder, eine retrieval-augmented generation (RAG)-Pipeline, Agenten-Orchestrierung, Modellverwaltung und eine Ein-Klick-API-Bereitstellungsschicht in einem einzigen selbst hostbaren Stack.

An **Clore.ai** Sie können den vollständigen Dify-Stack — einschließlich seiner Postgres-Datenbank, Redis-Cache, Weaviate-Vektorstore, Nginx-Reverse-Proxy, API-Worker und Web-Frontend — auf einem gemieteten GPU-Server für bereits **0,20–0,35 $/Std.** (RTX 3090/4090). Die GPU ist für Dify selbst optional, wird jedoch essenziell, wenn Sie lokale Modellinferenz über Ollama- oder vLLM-Backends integrieren.

**Wesentliche Funktionen:**

* 🔄 **Visueller Workflow-Builder** — Drag-and-Drop-LLM-Pipelines mit Verzweigungen, Schleifen und bedingter Logik
* 📚 **RAG-Pipeline** — PDFs, URLs, 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
* 🏢 **Multi-Tenant** — Teams, Workspaces, RBAC, Nutzungskontingente

***

## Anforderungen

Dify läuft als Multi-Container-Docker-Compose-Stack. Der minimal brauchbare Server für die Entwicklung ist eine reine CPU-Instanz; für den produktiven Betrieb mit lokaler Modellinferenz benötigen Sie einen GPU-Knoten.

| Konfiguration                   | GPU             | VRAM  | System-RAM | Festplatte | Clore.ai-Preis      |
| ------------------------------- | --------------- | ----- | ---------- | ---------- | ------------------- |
| **Minimal** (Nur API-Schlüssel) | Keine / CPU     | —     | 8 GB       | 30 GB      | \~0,05 $/Std. (CPU) |
| **Standard**                    | RTX 3080        | 10 GB | 16 GB      | 50 GB      | \~0,15 $/Std.       |
| **Empfohlen**                   | RTX 3090 / 4090 | 24 GB | 32 GB      | 80 GB      | 0,20–0,35 $/Std.    |
| **Produktion + lokale LLM**     | A100 80 GB      | 80 GB | 64 GB      | 200 GB     | \~$1.10/Stunde      |
| **Hoher Durchsatz**             | H100 SXM        | 80 GB | 128 GB     | 500 GB     | \~2,50 $/Std.       |

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

### Hinweis zur Festplatte

Weaviate- und Postgres-Daten wachsen schnell mit Dokumenten-Uploads. Stellen Sie **mindestens 50 GB** bereit und binden Sie persistente Speicherung über Clore.ais Volume-Optionen ein.

***

## Schnellstart

### 1. Miete einen Clore.ai-Server

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

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

### 2. Verbinden und Server vorbereiten

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

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

# Überprü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

# Kopieren Sie die Beispiel-Umgebungsdatei
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 Startvorgangs beobachten (erster Lauf dauert 2–3 Minuten)
docker compose logs -f
```

### 4. Überprüfen, ob alle Dienste gesund sind

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

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

### 5. Zugriff auf die Weboberfläche

Öffnen Sie Ihren Browser und navigieren Sie zu:

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

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

***

## Konfiguration

Alle Konfigurationen befinden sich in `dify/docker/.env`. Hier sind die wichtigsten Einstellungen:

### Wesentliche Umgebungsvariablen

```bash
# ── Geheime Schlüssel (ÄNDERN SIE DIESE) ───────────────────────────────────────
SECRET_KEY=your-super-secret-key-change-this-immediately
# Generieren Sie einen starken Schlüssel:
# 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 Produktion ändern!
DB_HOST=db
DB_PORT=5432
DB_DATABASE=dify

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

# ── Speicherung (standardmäßig lokale Festplatte) ────────────────────────────
STORAGE_TYPE=local
# Oder verwenden Sie S3-kompatiblen Speicher:
# 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 setzen oder hier vorkonfigurieren:
# OPENAI_API_KEY=sk-...
```

### Ändern des offengelegten Ports

Standardmäßig lauscht Nginx auf Port **80**. Um ihn zu ändern:

```bash
# Bearbeiten Sie in docker-compose.yaml den nginx-Service:
# ports:
#   - "8080:80"   ← ändern Sie 8080 in Ihren bevorzugten Host-Port

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

### Persistente Datenvolumes

Difys Compose-Datei mountet diese Volumes standardmäßig:

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

Zum Sichern:

```bash
# Dienste zuerst stoppen, dann die Docker-Volumes tar-en
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

Difys Kernplattform ist CPU-basiert, aber Sie schalten lokale Modellinferenz frei, indem Sie **Ollama** oder **vLLM** als Modellanbieter integrieren — beide profitieren enorm von einer GPU.

### Option A: Ollama-Sidecar (einfachste Variante)

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 ziehen (z. B. Llama 3 8B)
ollama pull llama3:8b

# Überprüfen, dass die GPU verwendet wird
ollama run llama3:8b "Hello!"
nvidia-smi   # Sollte den ollama-Prozess zeigen, der VRAM verwendet
```

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

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

> Für eine vollständige Ollama-Anleitung siehe [language-models/ollama.md](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama).

### Option B: vLLM-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

# Endpoint überprüfen
curl http://localhost:8000/v1/models
```

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

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

> Für die vollständige vLLM-Einrichtung siehe [language-models/vllm.md](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm).

### Empfehlungen für GPU-Speicher bei lokalen Modellen

| Modell             | Benötigter 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
# Verwenden Sie Spot-Preise — Difys Datenbanken behalten Zustand in Volumes
# sodass Sie die Instanz günstig stoppen/neustarten können

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

# Speichervolume für 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 Produktion empfohlen)

```bash
# Fügen Sie Caddy zu docker-compose.yaml hinzu oder führen Sie es standalone aus
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 Lasten skalieren

```bash
# Führen Sie 4 Celery-Worker statt 1 aus
docker compose up -d --scale worker=4
```

### Ressourcennutzung überwachen

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

# GPU-Auslastung (bei Nutzung lokaler Modelle)
watch -n1 nvidia-smi

# Dify-Anwendungs-Logs
docker compose logs -f api worker
```

### RAG-Performance-Tuning

* Setze **Chunk-Größe** auf 512–1024 Tokens für die meisten Dokumenttypen
* Aktivieren Sie **Parent-Child-Retrieval** für lange Dokumente in den Dataset-Einstellungen
* Verwenden Sie **Hybrid-Suche** (Keyword + Vektor) für bessere Rückrufe bei technischem Inhalt
* Dokumente während Nebenzeiten indexieren, um API-Rate-Limits zu vermeiden

***

## Fehlerbehebung

### Dienste starten ständig neu

```bash
# Prüfen Sie die Logs des fehlschlagenden Dienstes
docker compose logs --tail=50 api
docker compose logs --tail=50 worker

# Häufige Ursache: falscher SECRET_KEY oder DB-Verbindung
# Stellen Sie sicher, dass SECRET_KEY in .env gesetzt und einzigartig 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, prüfen Sie zuerst, ob Postgres gesund ist
docker compose exec db pg_isready -U postgres
```

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

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

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

# Testen Sie aus einem Dify-Container heraus:
docker compose exec api curl http://host.docker.internal:11434/api/tags
```

### Festplattenspeicher voll

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

# Unbenutzte Images entfernen
docker image prune -a

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

### Weaviate-Vektorstore-Fehler

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

# Dann indizieren Sie Ihre Datasets in der Dify-UI neu → Datasets → [dataset] → Re-index
```

### Port 80 bereits in Gebrauch

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

# Stoppen Sie den störenden Dienst oder ändern Sie Difys nginx-Port in docker-compose.yaml
```

***

## Weiterführende Lektüre

* [Offizielle Dify-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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama)
* [vLLM auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm)
* [Clore.ai GPU-Vergleich](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison)
* [Dify Community Discord](https://discord.gg/FngNHpbcY7)