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

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 auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

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

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 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.aiauf, 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

# 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

# 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

# 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

# ── 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:

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

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

Zum Sichern:

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

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

Option B: vLLM als Sidecar (hoher Durchsatz)

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

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

# 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)

# 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

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

Ressourcennutzung überwachen

# 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

# 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

# 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

# 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

# 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

# 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

# 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

VorherigeÜberblick

Nächsten8n KI-Workflows

Zuletzt aktualisiert vor 1 Monat

War das hilfreich?