> 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

## Ü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](/guides/guides_v2-de/sprachmodelle/ollama.md).

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

### 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](/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:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/dify.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.
