RAGFlow mit Docker installieren: Enterprise-RAG-Engine für eigene Wissensdatenbanken

Wer eigene Dokumente datenschutzkonform mit einem KI-Sprachmodell durchsuchbar machen möchte, braucht mehr als ein einfaches Chat-Interface. RAGFlow von Infiniflow geht hier deutlich weiter: Die Plattform kombiniert Deep-Document-Understanding (PDF, Word, Excel, Bilder mit OCR), template-basiertes Chunking, Hybrid-Search über Elasticsearch und einen grafischen Agenten-Workflow-Editor zu einer vollständigen RAG-Pipeline. RAG (Retrieval-Augmented Generation) bedeutet: Das Sprachmodell beantwortet Fragen auf Basis passender Textabschnitte aus Ihren Dokumenten. RAGFlow läuft per Docker Compose auf einem eigenen Linux-Server, die Daten bleiben im Haus, und die Web-Oberfläche ist auch für Nicht-Entwickler bedienbar.

Voraussetzungen

• Betriebssystem: Linux x86_64 (AMD64) – empfohlen Ubuntu 22.04/24.04 LTS oder Debian 12. ARM64 (Apple Silicon, Raspberry Pi) wird offiziell nicht unterstützt.
• Docker Engine >= 24.0.0 und Docker Compose >= v2.26.1 – Installationsanleitung: Docker und Docker Compose auf Linux installieren.
• RAM: mindestens 16 GB, empfohlen 32 GB für den produktiven Betrieb.
• CPU: mindestens 4 Kerne, empfohlen 8+ Kerne.
• Speicher: mindestens 50 GB frei (SSD empfohlen); Elasticsearch und MinIO wachsen je nach Datenmenge erheblich.
• Internet: stabiler Zugang für den initialen Download (RAGFlow-Image allein rund 3,8 GB komprimiert, dazu Elasticsearch, MySQL, MinIO und Valkey).
• LLM-API-Key: z. B. von OpenAI, DeepSeek oder ein lokaler Ollama-Server – wird erst nach der Installation benötigt.
• Optional: einen Reverse Proxy (z. B. Traefik oder Nginx Proxy Manager) für HTTPS und eine eigene Domain.

Schritt 1: Kernel-Parameter setzen (Linux)

Elasticsearch benötigt einen erhöhten Wert für virtuelle Speicherbereiche. Ohne diese Anpassung bricht der Container beim Start sofort ab.

# Sofort wirksam (bis zum nächsten Reboot):
sudo sysctl -w vm.max_map_count=262144

# Dauerhaft persistent machen:
echo 'vm.max_map_count=262144' | sudo tee -a /etc/sysctl.conf

Schritt 2: Repo klonen und Projektordner vorbereiten

Die Compose-Konfiguration besteht aus zwei verknüpften Dateien (docker-compose.yml + docker-compose-base.yml), daher muss das vollständige Repo geklont werden – einzelne Dateien aus Drittquellen führen zu Konfigurationsdrift. Das Release-Tag sorgt dafür, dass entrypoint.sh und Compose-Dateien zur Image-Version passen.

# Repo klonen (ca. 50 MB, ohne Images):
git clone https://github.com/infiniflow/ragflow.git

# In das Docker-Verzeichnis wechseln und auf das Release-Tag festlegen:
cd ragflow/docker
git checkout v0.27.2

# .env-Vorlage kopieren:
cp .env .env.backup

Schritt 3: Umgebungsvariablen in der .env anpassen

Die .env steuert alle sicherheitsrelevanten Einstellungen. Die Standard-Passwörter lauten infini_rag_flow, das Passwort des Systemadministrators admin@ragflow.io (ADMIN_DEFAULT_PASSWORD) lautet admin. Die Compose-Dateien veröffentlichen Elasticsearch (1200), MySQL (3306), MinIO (9000/9001) und Valkey (6379) auf allen Netzwerkschnittstellen; mit Standardwerten sind diese Dienste für jeden im Netzwerk offen. Passwörter vor dem ersten Start ändern und diese Ports per Firewall nach außen sperren.

# --- RAGFlow Version (stabil: v0.27.2) ---
RAGFLOW_IMAGE=infiniflow/ragflow:v0.27.2

# --- Dokumenten-Engine (Standard: Elasticsearch) ---
DOC_ENGINE=elasticsearch
STACK_VERSION=8.11.3

# --- Recheneinheit: cpu | gpu ---
DEVICE=cpu

# --- Sichere Passwörter setzen (PFLICHT!) ---
ELASTIC_PASSWORD=MeinSicheresESPasswort2026!
MYSQL_PASSWORD=MeinSicheresMySQL2026!
MINIO_USER=ragflow_admin
MINIO_PASSWORD=MeinSicheresMinIO2026!
REDIS_PASSWORD=MeinSicheresRedis2026!
ADMIN_DEFAULT_PASSWORD=MeinSicheresAdmin2026!

# --- Zeitzone (DACH) ---
TZ=Europe/Berlin

# --- Ports (Standardwerte beibehalten oder anpassen) ---
SVR_WEB_HTTP_PORT=80
SVR_HTTP_PORT=9380
ES_PORT=1200
MINIO_PORT=9000
MINIO_CONSOLE_PORT=9001

# --- RAM-Limit pro Container (Standard 8 GB) ---
# Bei Parsing-Abbrüchen auf 16 GB erhöhen:
MEM_LIMIT=8073741824

# --- Upload-Limit (Standard 1 GB) ---
MAX_CONTENT_LENGTH=1073741824

# --- Nutzerregistrierung (nach Admin-Setup auf 0 setzen) ---
REGISTER_ENABLED=1

# --- HuggingFace Mirror (bei eingeschränktem Internetzugang) ---
# HF_ENDPOINT=https://hf-mirror.com

Die Beispielpasswörter oben sind Platzhalter: Setzen Sie eigene, zufällige Werte (z. B. openssl rand -base64 24).

Schritt 4: Eckdaten im Überblick

Schritt 5: Stack starten

Die Compose-Konfiguration bringt MySQL, Elasticsearch, MinIO und Valkey mit. Der erste Start dauert länger, weil alle Images heruntergeladen werden.

# Im Verzeichnis ragflow/docker/ ausführen:
docker compose up -d

# Echtzeit-Logs des RAGFlow-Kerns beobachten:
docker compose logs -f ragflow-cpu

Die Initialisierung dauert typischerweise 2–5 Minuten. Der Stack ist betriebsbereit, wenn in den Logs Running on all addresses (0.0.0.0) erscheint.

docker compose ps

Erwartete Ausgabe (gekürzt; der Projektname docker ergibt sich aus dem Verzeichnisnamen) – alle Container im Status Up, Elasticsearch, MySQL, MinIO und Valkey zusätzlich (healthy):

NAME                  IMAGE                                      STATUS
docker-ragflow-cpu-1  infiniflow/ragflow:v0.27.2                 Up
docker-es01-1         elasticsearch:8.11.3                       Up (healthy)
docker-mysql-1        mysql:8.0.40                               Up (healthy)
docker-minio-1        pgsty/silo:RELEASE.2026-08-06T00-00-00Z    Up (healthy)
docker-redis-1        valkey/valkey:8                            Up (healthy)

API-Erreichbarkeit prüfen:

curl -s http://localhost:9380/api/v1/system/ping
# Erwartete Ausgabe: pong

Schritt 6: Erst-Einrichtung im Browser

Für die tägliche Arbeit registrieren Sie ein normales Benutzerkonto. Die Systemverwaltung (Benutzer, Registrierung, Dienststatus) liegt in der Admin-Oberfläche unter /admin; dort melden Sie sich mit admin@ragflow.io und dem Wert aus ADMIN_DEFAULT_PASSWORD an.

1. Browser öffnen: http://<SERVER-IP> (Port 80 ist Standard)
2. Registrierungsformular ausfüllen: E-Mail, Passwort (normales Benutzerkonto)
3. Nach dem Login: Settings › Model Providers aufrufen
4. LLM-Anbieter wählen (z. B. OpenAI, DeepSeek) und API-Key eingeben
5. Für lokale Modelle (Ollama, LM Studio): Basis-URL http://host.docker.internal:<PORT> eintragen
6. Nach der Einrichtung in der .env REGISTER_ENABLED=0 setzen und Stack neu starten
7. Admin-Oberfläche http://<SERVER-IP>/admin mit admin@ragflow.io aufrufen und prüfen, ob die Anmeldung mit Ihrem Passwort funktioniert

Schritt 7: Wissensdatenbank anlegen und Dokumente hochladen

Jede Wissensdatenbank (Knowledge Base) hat eine eigene Chunking-Strategie, also eine Regel, wie Dokumente in Abschnitte zerlegt werden.

1. Im Dashboard Knowledge Base aufrufen und „Create Knowledge Base“ klicken
2. Name, Beschreibung und Chunk Method wählen (z. B. „General“, „Q&A“, „Paper“, „Manual“ je nach Dokumenttyp)
3. Dokumente hochladen (PDF, Word, Excel, PowerPoint, TXT, HTML, Markdown, Bilder mit OCR) – bis zu 1 GB pro Datei, 32 Dateien pro Batch
4. Parsing starten – RAGFlow verarbeitet die Dokumente mit Deep-Document-Understanding (OCR, Tabellen- und Bildanalyse)
5. Nach Abschluss des Parsings steht die Wissensdatenbank für Chat und Agenten-Workflows bereit

Schritt 8: Updates und Backup

RAGFlow entwickelt sich schnell. Vor jedem Update eine Datensicherung anlegen – alle kritischen Daten liegen in den Named Volumes.

# Stack stoppen (ohne -v!), damit die MySQL-Dateien konsistent sind:
docker compose down

# Backup der Named Volumes (Präfix = Projektname, Standard docker_):
docker run --rm \
  -v docker_mysql_data:/source:ro \
  -v $(pwd)/backup:/backup \
  alpine tar czf /backup/mysql_data_$(date +%Y%m%d).tar.gz -C /source .

# Update: Repo aktualisieren, neues Release-Tag auschecken,
# RAGFLOW_IMAGE in .env anpassen, dann:
git pull && git checkout -f v0.27.2
docker compose pull
docker compose up -d

# Logs nach Update prüfen:
docker compose logs -f ragflow-cpu

Eine systematische Backup-Strategie für Docker-Volumes: Docker Compose absichern: Secrets, Healthchecks und Non-Root.

Sichern Sie auf die gleiche Weise docker_minio_data (hochgeladene Dokumente) und docker_esdata01 (Suchindex).

Troubleshooting / Typische Fehler

„max virtual memory areas vm.max_map_count [65530] is too low“

(Elasticsearch startet nicht): vm.max_map_count nicht gesetzt oder Reboot hat ihn zurückgesetzt. Fix: sudo sysctl -w vm.max_map_count=262144 – dauerhaft in /etc/sysctl.conf eintragen.

Browser zeigt „network abnormal“ direkt nach dem Start

RAGFlow ist noch nicht vollständig initialisiert. Fix: docker compose logs -f ragflow-cpu beobachten, bis Running on all addresses (0.0.0.0) erscheint – erst dann den Browser öffnen.

Parsing bleibt bei ~90% stehen oder bricht ab

MEM_LIMIT in der .env ist zu niedrig. Fix: auf 16073741824 (16 GB) erhöhen, dann docker compose stop && docker compose up -d.

Elasticsearch-Container Status „unhealthy“ trotz laufendem Container

Häufig falsches ELASTIC_PASSWORD oder fehlendes vm.max_map_count. Diagnose: docker compose logs es01.

„exec format error“ beim Starten (ARM64/Apple Silicon)

Es gibt keine offiziellen ARM64-Images. Das Image muss aus dem Quellcode selbst gebaut werden (ragflow/docs/dev/build_docker_image).

„address already in use“ für Port 80

Ein anderer Webserver belegt Port 80. Fix: SVR_WEB_HTTP_PORT=8080 in der .env setzen und docker compose up -d neu starten. SVR_HTTP_PORT ist der API-Port 9380 und bleibt unverändert.

HuggingFace-Embedding-Modelle werden nicht geladen

Eingeschränkter Internetzugang. Fix: HF_ENDPOINT=https://hf-mirror.com in der .env setzen, Dienste neu starten.

nginx-Fehler „ragflow.conf.python not found“

Einzelne Dateien wurden kopiert statt das komplette Repo zu klonen. Fix: vollständigen git clone durchführen.

GPU wird nicht erkannt (DEVICE=gpu)

nvidia-container-toolkit muss auf dem Host installiert sein und Docker für GPU-Zugriff konfiguriert werden: nvidia-ctk runtime configure --runtime=docker.

Häufige Fragen

Wie lautet das Standard-Login nach der Installation?

Für die Admin-Oberfläche unter /admin gibt es das Konto admin@ragflow.io; das Passwort stammt aus ADMIN_DEFAULT_PASSWORD (Vorgabe admin, vor dem ersten Start ändern). Normale Benutzer registrieren sich beim ersten Aufruf von http://<HOST-IP>. Danach empfiehlt sich REGISTER_ENABLED=0 in der .env, um weitere Selbst-Registrierungen zu verhindern.

Wie ändere ich den Web-Port von 80 auf einen anderen Port?

In docker/.env den Wert SVR_WEB_HTTP_PORT=8080 (oder einen anderen freien Port) setzen. Anschließend docker compose stop && docker compose up -d. Der Zugriff erfolgt dann über http://<HOST-IP>:8080.

Wie verbinde ich RAGFlow mit einem lokalen Ollama-Modell?

Im Web-UI unter Settings › Model Providers den Anbieter „Ollama“ auswählen und die Basis-URL http://host.docker.internal:11434 eintragen (host.docker.internal zeigt auf den Docker-Host). Für LM Studio den Port anpassen. Mehr zu lokalen Modellen: Ollama und Open WebUI mit Docker – eigenes lokales KI-Sprachmodell ohne Cloud.

Kann ich die Dokumenten-Engine von Elasticsearch auf Infinity wechseln?

Ja: DOC_ENGINE=infinity in der .env setzen, dann docker compose down && docker compose up -d. Achtung: Bestehende Elasticsearch-Dokumente werden dabei nicht migriert. Infinity ist ressourcenschonender, ein offizieller ARM64-Support fehlt aber auch dort.

Wie groß wird die Installation ungefähr?

Das RAGFlow-Image ist rund 3,8 GB groß (komprimiert). Mit Elasticsearch-Index und MinIO-Dokumenten sollten Sie mindestens 50 GB SSD-Speicher einplanen.

Welche Dokumentformate werden unterstützt?

PDF, Word (.docx), Excel (.xlsx), PowerPoint (.pptx), TXT, HTML, Markdown, sowie Bilder mit OCR-Analyse. Tabellen und Layout erkennt RAGFlow per Deep-Document-Understanding.

Was ist der MCP-Endpunkt auf Port 9382?

Über das Model Context Protocol (MCP) binden andere KI-Agenten die RAGFlow-Wissensdatenbanken als Werkzeug ein. Port 9382 sollte nur intern oder über einen gesicherten Tunnel erreichbar sein.

Fazit

RAGFlow deckt mit Pipeline-Editor, MCP-Unterstützung, Deep-Document-Understanding und breiter LLM-Kompatibilität den kompletten RAG-Ablauf im Eigenbetrieb ab. Die Installation gelingt zuverlässig, wenn die Voraussetzungen stimmen: x86_64-Linux, mindestens 16 GB RAM, vm.max_map_count korrekt gesetzt und eigene Passwörter in der .env. Wer ein schlankes RAG-System ohne eigenen Vektor-Index sucht, findet in AnythingLLM eine leichtgewichtigere Alternative. Grundlagen zu Chunking und Reranking: RAG produktiv betreiben: Chunking, Hybrid-Search, Reranking und Antwortqualität messen.

Weiterführende Anleitungen und Quellen

1. Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage
2. Ollama und Open WebUI mit Docker: eigenes lokales KI-Sprachmodell ohne Cloud betreiben
3. AnythingLLM installieren (Docker): Lokale KI-Zentrale mit RAG-Workspaces und Ollama
4. RAG produktiv betreiben: Chunking, Hybrid-Search, Reranking und Antwortqualität messen
5. Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb
6. Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten

Offizielle Quellen: RAGFlow GitHub Repository (infiniflow/ragflow) – README, docker-compose.yml, .env-Referenz. RAGFlow Offizielle Dokumentation – Quickstart, Konfiguration, FAQ. RAGFlow auf Docker Hub – Image-Tags und Versionsübersicht.