Mit Dify betreiben Sie auf Ihrem eigenen Server eine Plattform für KI-Apps und Agenten, ohne jede Funktion selbst zu programmieren. Dify (langgenius/dify) ist eine quelloffene LLMOps-Plattform für Entwicklung, Test, Veröffentlichung und Überwachung von Anwendungen auf Basis großer Sprachmodelle (LLM). Sie erstellen darin Chatbots, Agenten, visuelle Workflows (Chatflows) und RAG-Wissensdatenbanken (Retrieval-Augmented Generation: das Modell antwortet auf Basis Ihrer Dokumente), binden Modell-Provider wie OpenAI, Anthropic oder ein lokales Ollama ein und veröffentlichen die App als Web-Oberfläche oder API.

Sie folgen dem offiziellen Weg per Docker Compose auf einem Linux-Server, von der Installation bis zu Reverse-Proxy, Update und Backup.

Kurzfassung: Klonen Sie das Repository mit festem Release-Tag, kopieren Sie im Verzeichnis dify/docker die .env aus der Vorlage, ändern Sie die Standard-Passwörter und starten Sie den Stack:

git clone --branch 1.17.1 https://github.com/langgenius/dify.git
cd dify/docker && cp .env.example .env
docker compose up -d

Danach rufen Sie http://IHR-SERVER/install auf, legen das Admin-Konto an und hinterlegen unter Settings → Model Provider den API-Key Ihres Modell-Providers. Für den Produktivbetrieb binden Sie Dify an 127.0.0.1 und stellen einen Reverse-Proxy mit HTTPS davor.

Voraussetzungen

Dify braucht selbst keine GPU. Der Stack startet im Standardprofil rund 15 Container, planen Sie den Server entsprechend.

Komponente	Minimum / Empfehlung
CPU	mind. 2 Kerne (4+ empfohlen), x86_64 oder ARM64
RAM	mind. 4 GiB (8 GiB empfohlen)
Betriebssystem	Debian 12/13 oder Ubuntu 24.04 (Linux-Server)
Docker Engine	aktuelle Version aus dem Docker-Repository
Docker Compose	2.24.0 oder neuer
Speicherplatz	ab ca. 20 GB frei (Images, Volumes, Wissensbasis)
GPU	für Dify nicht nötig; nur für lokales LLM-Serving sinnvoll

Prüfen Sie vor dem Start die Versionen. Compose unter 2.24.0 bricht beim Start ab, weil die offizielle Compose-Datei optionale env_file-Einträge nutzt:

docker --version
docker compose version

Für den Produktivbetrieb brauchen Sie eine Domain mit HTTPS.

GPU-Betrieb: CPU vs. nvidia-container-toolkit

Betreiben Sie Modelle lokal (etwa mit Ollama oder LocalAI), läuft das auf CPU oder GPU. Für GPU-Beschleunigung geben Sie der Serving-Engine per nvidia-container-toolkit die GPU frei. Dify spricht sie nur über eine Base-URL an (Schritt 6).

Schritt 1: Repository klonen und Verzeichnis vorbereiten

Melden Sie sich per SSH am Server an und klonen Sie das offizielle Repository mit festem Release-Tag. Diese Anleitung beschreibt Version 1.17.1 (veröffentlicht am 10.09.2026):

git clone --branch 1.17.1 https://github.com/langgenius/dify.git
cd dify/docker

Im Unterverzeichnis docker liegen die docker-compose.yaml, die Vorlage .env.example, optionale Zusatzvorlagen unter envs/ und nach dem ersten Start das Verzeichnis volumes mit allen Daten. Den aktuellen Release-Tag finden Sie auf der Releases-Seite des Projekts.

Verifizieren: git describe --tags im Verzeichnis dify gibt 1.17.1 aus, und ls dify/docker zeigt docker-compose.yaml und .env.example.

Schritt 2: .env aus der Vorlage anlegen und absichern

Dify liest die Startwerte aus der .env. Kopieren Sie die Vorlage:

cp .env.example .env

Ändern Sie vor dem Produktivbetrieb die Standard-Passwörter difyai123456 für Datenbank und Redis, setzen Sie einen eigenen SECRET_KEY und ersetzen Sie das seit 1.16 benötigte DIFY_AGENT_API_TOKEN, dessen Vorgabewert laut Release Notes nur für Entwicklung gedacht ist:

# --- Sicherheit (anpassen!) ---
SECRET_KEY=IHR-LANGER-ZUFALLSSTRING
INIT_PASSWORD=
DIFY_AGENT_API_TOKEN=IHR-ZUFALLSTOKEN

# --- Datenbank (PostgreSQL) ---
DB_USERNAME=postgres
DB_PASSWORD=IHR-DB-PASSWORT
DB_DATABASE=dify

# --- Redis ---
REDIS_PASSWORD=IHR-REDIS-PASSWORT

Zufallswerte erzeugen Sie auf der Kommandozeile:

openssl rand -base64 42

Betreiben Sie Dify hinter einer Domain, tragen Sie zusätzlich die öffentlichen URLs ein. Sonst zeigen Links, API-Endpunkte und veröffentlichte Apps auf falsche Adressen:

CONSOLE_API_URL=https://IHRE-DOMAIN.de
CONSOLE_WEB_URL=https://IHRE-DOMAIN.de
SERVICE_API_URL=https://IHRE-DOMAIN.de
APP_API_URL=https://IHRE-DOMAIN.de
APP_WEB_URL=https://IHRE-DOMAIN.de

Verifizieren: grep -c difyai123456 .env liefert 0, und grep -E '^(SECRET_KEY|DIFY_AGENT_API_TOKEN)=' .env zeigt Ihre eigenen Werte.

Schritt 3: compose.yaml verstehen und Ports anpassen

Die mitgelieferte docker-compose.yaml ändern Sie nicht, Updates ersetzen sie. Sie enthält die Kerndienste api, worker, worker_beat, web, plugin_daemon und agent_backend, dazu sandbox, ssrf_proxy, redis, nginx sowie über Profile die Datenbank (db_postgres) und die gewählte Vektor-Datenbank. Welche Profile starten, steuert COMPOSE_PROFILES in der .env aus VECTOR_STORE und DB_TYPE. Die Image-Tags der Dify-Dienste sind im Release-Tag festgeschrieben (in 1.17.1 z. B. langgenius/dify-api:1.17.1, langgenius/dify-plugin-daemon:0.6.10-local, cr.weaviate.io/semitechnologies/weaviate:1.39.2).

Eigene Ergänzungen legen Sie in eine docker-compose.override.yaml im selben Verzeichnis, die Compose automatisch mitlädt. Für die Anbindung eines Ollama auf dem Host (Schritt 6) sieht sie so aus:

services:
  api:
    extra_hosts:
      - "host.docker.internal:host-gateway"
  worker:
    extra_hosts:
      - "host.docker.internal:host-gateway"
  plugin_daemon:
    extra_hosts:
      - "host.docker.internal:host-gateway"

Die Standardwerte veröffentlichen nginx auf Port 80/443 und den Plugin-Debugging-Port 5003 auf allen Schnittstellen des Hosts. Betreiben Sie einen Reverse-Proxy auf dem Host (Schritt 8), binden Sie die Ports in der .env an 127.0.0.1:

EXPOSE_NGINX_PORT=127.0.0.1:8080
EXPOSE_NGINX_SSL_PORT=127.0.0.1:8443
EXPOSE_PLUGIN_DEBUGGING_PORT=127.0.0.1:5003

Verifizieren: docker compose config --services listet die Dienste ohne Fehlermeldung, und docker compose config | grep -A3 ports zeigt die Bindung an 127.0.0.1.

Schritt 4: Stack starten und Status prüfen

Starten Sie den Stack im Hintergrund. Der erste Start lädt alle Images und dauert einige Minuten:

docker compose up -d
docker compose ps

Startet ein Dienst nicht, zeigen die Logs von api und plugin_daemon meist die Ursache:

docker compose logs -f api plugin_daemon

Die Datenbank-Migrationen laufen dank MIGRATION_ENABLED=true beim Start des api-Containers automatisch.

Verifizieren: docker compose ps zeigt alle Dienste als running bzw. healthy (nur init_permissions ist nach getaner Arbeit beendet), und curl -I http://127.0.0.1:8080/install (bzw. Port 80) liefert HTTP/1.1 200.

Schritt 5: Web-UI öffnen und Admin-Konto anlegen

Dify hat kein Standard-Login. Das Administratorkonto legen Sie beim ersten Aufruf an. Öffnen Sie die Installationsseite (IHR-SERVER durch IP oder Domain ersetzen):

http://IHR-SERVER/install

Tragen Sie E-Mail, Benutzername und Passwort ein. Ist in der .env ein INIT_PASSWORD gesetzt, fragt Dify dieses vorher ab. Richten Sie das Konto sofort ein, sonst kann es jeder mit Zugriff auf die Seite anlegen.

Verifizieren: Die Anmeldung unter http://IHR-SERVER/signin mit den neuen Zugangsdaten führt auf das leere Dashboard, ein erneuter Aufruf von /install bietet keine Einrichtung mehr an.

Schritt 6: Modell-Provider einbinden (OpenAI, Anthropic, Ollama)

Ohne Modell-Provider erzeugt Dify keine Antworten. Die Provider sind Plugins, die der plugin_daemon aus dem Dify Marketplace lädt. Dafür braucht der Server ausgehenden Internetzugang. Öffnen Sie im Dashboard Settings → Model Provider, installieren Sie den gewünschten Anbieter und tragen Sie die Zugangsdaten ein.

Cloud-Provider: OpenAI und Anthropic

Bei OpenAI und Anthropic genügt der API-Key, optional eine abweichende Base-URL. Nach dem Speichern stehen die Modelle in jeder App zur Auswahl. Prompts und Inhalte gehen dann an den Anbieter, prüfen Sie den Auftragsverarbeitungsvertrag.

Lokales Modell: Ollama anbinden

In einem Container zeigt localhost auf den Container selbst, nicht auf den Host. Läuft Ollama auf dem Host, tragen Sie als Base-URL ein:

http://host.docker.internal:11434

Unter Linux löst host.docker.internal nur mit dem extra_hosts-Eintrag aus Schritt 3 auf. Ollama muss dafür auf der Docker-Bridge erreichbar sein (OLLAMA_HOST=0.0.0.0), sperren Sie Port 11434 dann per Firewall nach außen.

Verifizieren: Unter Settings → Model Provider erscheint der Anbieter als eingerichtet, und die Modellauswahl einer Test-App listet dessen Modelle. Für Ollama zeigt docker compose exec api curl -s http://host.docker.internal:11434/api/tags die installierten Modelle.

Schritt 7: Erste App und RAG-Wissensdatenbank bauen

Im Dashboard legen Sie über Create App eine Anwendung an. Zur Auswahl stehen:

Chatbot: Dialog-Assistent mit Systemprompt.
Agent: nutzt Tools, um Aufgaben mehrstufig zu lösen.
Workflow: visuell verkettete Schritte für reproduzierbare Abläufe.
Chatflow: Dialog mit Workflow-Logik.

Für eine Wissensdatenbank öffnen Sie Knowledge, legen eine Wissensbasis an und laden Dokumente hoch (PDF, Text, Markdown). Dify zerlegt die Dokumente, erzeugt Embeddings (Vektordarstellungen des Textes) und speichert sie in der Vektor-Datenbank. In der Chatbot- oder Chatflow-App verknüpfen Sie die Wissensbasis als Kontext.

Hinweis zur Vektor-Datenbank: Legen Sie VECTOR_STORE vor der ersten Wissensbasis fest (Standard weaviate, alternativ z. B. qdrant, milvus, pgvector). Ein späterer Wechsel erfordert eine vollständige Neuindexierung.

App veröffentlichen: Web und API

Mit Publish stellt Dify eine Web-Oberfläche und eine REST-API mit eigenem API-Key bereit. Die URL-Variablen aus Schritt 2 müssen dafür auf Ihre Domain zeigen.

Verifizieren: Eine Frage zu einem hochgeladenen Dokument beantwortet die App mit Inhalten daraus, und die Wissensbasis zeigt beim Dokument den Status Available.

Schritt 8: Reverse-Proxy und HTTPS

Betreiben Sie Dify produktiv nur mit gültigem TLS-Zertifikat. Nutzen Sie den mitgelieferten nginx mit den SSL-Variablen (NGINX_HTTPS_ENABLED, optional Certbot) aus der .env, oder einen eigenen Reverse-Proxy auf dem Host, der auf den Port aus Schritt 3 weiterleitet:

server {
    listen 443 ssl;
    server_name IHRE-DOMAIN.de;

    ssl_certificate     /etc/letsencrypt/live/IHRE-DOMAIN.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/IHRE-DOMAIN.de/privkey.pem;

    client_max_body_size 100M;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Setzen Sie die URL-Variablen aus Schritt 2 auf https://IHRE-DOMAIN.de und starten Sie den Stack mit docker compose up -d neu. client_max_body_size muss für große Dokumente in der Wissensbasis ausreichen.

Verifizieren: curl -I https://IHRE-DOMAIN.de/signin liefert HTTP/2 200 mit gültigem Zertifikat, und von einem anderen Rechner ist http://SERVER-IP:8080 nicht erreichbar.

Schritt 9: Update und Backup

Vor jedem Update Release Notes lesen. Wichtig für 1.17.1: Der mitgelieferte Weaviate springt von 1.27.0 auf 1.39.2. Bestehende Installationen mit mitgeliefertem Weaviate müssen laut Release Notes vorher ein gestuftes Weaviate-Upgrade durchführen, sonst kann die Vektorsuche dauerhaft beschädigt werden. Neuinstallationen und andere Vektor-Datenbanken sind nicht betroffen.

cd dify
git fetch --tags
git checkout 1.17.1        # oder neueren Tag
cd docker
docker compose down
docker compose pull        # neue Images ziehen
docker compose up -d       # neu starten, DB-Migration laeuft automatisch

Gleichen Sie nach jedem Update Ihre .env mit der aktuellen .env.example ab, neue Releases bringen oft zusätzliche Variablen mit.

Für ein konsistentes Backup stoppen Sie den Stack kurz und sichern das Verzeichnis volumes samt .env:

cd dify/docker
docker compose down
tar czf dify-backup-$(date +%F).tar.gz volumes/ .env docker-compose.override.yaml
docker compose up -d

volumes enthält db (PostgreSQL), app/storage (Uploads), weaviate (Vektorindex) und plugin_daemon (Plugins). Lagern Sie Backups außerhalb des Servers.

Verifizieren: tar tzf dify-backup-*.tar.gz | head listet volumes/db und .env, nach dem Update zeigt die Weboberfläche unten links bzw. unter About die neue Version, und docker compose ps meldet alle Dienste als laufend.

Troubleshooting

Ollama meldet „Connection refused“: Nutzen Sie http://host.docker.internal:11434 mit dem extra_hosts-Eintrag aus Schritt 3 und prüfen Sie, dass Ollama nicht nur auf 127.0.0.1 lauscht.

Veröffentlichte Apps oder Links sind fehlerhaft: Die öffentlichen URLs aus Schritt 2 fehlen. Tragen Sie sie ein und starten Sie mit docker compose up -d neu.

Start schlägt fehl: Prüfen Sie docker compose version. Unter 2.24.0 aktualisieren Sie das Compose-Plugin.

Port 80/443 bereits belegt: Binden Sie nginx wie in Schritt 3 an 127.0.0.1:8080.

Modell-Provider lässt sich nicht laden: Der plugin_daemon braucht ausgehenden Internetzugang zum Marketplace. In abgeschotteten Umgebungen stellen Sie die Plugins offline bereit. Logs: docker compose logs -f plugin_daemon.

Vektorsuche liefert nach dem Update nichts mehr: Wahrscheinlich wurde der mitgelieferte Weaviate ohne gestuftes Upgrade aktualisiert. Spielen Sie das Backup von volumes/weaviate zurück und folgen Sie dem Upgrade-Abschnitt der Release Notes.

Häufige Fragen

Braucht Dify zwingend eine GPU?

Nein, siehe Voraussetzungen. Eine GPU lohnt sich nur für lokale Modelle.

Wie unterscheidet sich Dify von n8n oder AnythingLLM?

n8n automatisiert allgemein zwischen Systemen, AnythingLLM konzentriert sich auf Dokumenten-Chats. Dify passt für Agenten und Workflows mit Modellverwaltung.

Wo speichert Dify meine Daten?

Unter dify/docker/volumes, Details in Schritt 9. Dieses Verzeichnis plus .env ergibt ein vollständiges Backup.

Welche Vektor-Datenbank soll ich nehmen?

Für den Einstieg genügt der Standard weaviate. Entscheiden Sie vor der ersten Wissensbasis (siehe Schritt 7), ein Wechsel erfordert eine Neuindexierung.

Kann ich mehrere Modell-Provider gleichzeitig nutzen?

Ja. Sie hinterlegen mehrere Provider, etwa OpenAI für Chat und Ollama für Embeddings, und wählen je App das Modell.

Wie aktualisiere ich Dify gefahrlos?

Backup anlegen, Release Notes auf manuelle Schritte prüfen (z. B. das Weaviate-Upgrade in 1.17.1), dann wie in Schritt 9 vorgehen.

Fazit

Mit Docker Compose betreiben Sie Dify als KI-App-Plattform auf dem eigenen Server. Für den Produktivbetrieb ändern Sie die Standard-Passwörter und Tokens, binden die Ports an 127.0.0.1, tragen die öffentlichen URLs ein und stellen einen Reverse-Proxy mit HTTPS davor. Vor Updates prüfen Sie die Release Notes auf manuelle Migrationsschritte.

Weiterführende Anleitungen und Quellen

Docker Compose Grundlagen: Multi-Container-Stacks sauber betreiben: Grundlage für Stacks wie Dify.
AnythingLLM mit Docker: mit eigenen Dokumenten chatten (RAG): schlankere Alternative für reine Dokumenten-Chats.
ComfyUI mit Docker: KI-Bildgenerierung mit Stable Diffusion: GPU-Serving auf dem Host einrichten.
Weitere Anleitungen aus der Kategorie Künstliche Intelligenz

Offizielle Quellen: