Diese Anleitung zeigt Dir Schritt für Schritt, wie Du AnythingLLM mit Docker self-hostest und anschließend per RAG (Retrieval Augmented Generation) mit deinen eigenen Dokumenten chattest. AnythingLLM ist eine turnkey RAG-Anwendung: Sie bringt Web-UI, API, LLM-Anbindung, eine integrierte Vektordatenbank (LanceDB), Embedding, Dokumenten-Ingestion, Workspaces, No-Code-Agenten und Multi-User in einem einzigen Container mit. Im Gegensatz zu einem selbst gebauten Qdrant-RAG musst Du also nichts zusammenstecken oder programmieren – Du startest einen Container, klickst durch das Onboarding und legst los. Zielgruppe sind Admins im Mittelstand und ambitionierte Heimserver-Nutzer, die auf einem Linux-Server mit Docker arbeiten.

Kurzfassung: Verzeichnis und compose.yaml anlegen, Storage-Volume auf /app/server/storage mounten (sonst Datenverlust), --cap-add SYS_ADMIN setzen und starten. Die drei Kernbefehle:

docker compose up -d                       # Container starten
docker compose pull && docker compose up -d # Update einspielen
docker compose down                        # Stoppen (z. B. vor Backup)

Danach Web-UI unter http://SERVER-IP:3001 öffnen und im Onboarding LLM-Provider, Embedder und Vektor-DB wählen. Es gibt KEIN Default-Passwort.

Voraussetzungen

AnythingLLM selbst ist leichtgewichtig. Die hier genannten Werte gelten, wenn die eigentliche Inferenz extern läuft (Cloud-Provider oder ein separater GPU-Host):

Hardware: ca. 2 GB RAM, 2-Core-CPU, ca. 5–10 GB Storage. Der Storage-Bedarf wächst mit Dokumenten und Vektoren.
Betriebssystem: Linux-Server mit Docker und Docker Compose, z. B. Debian 12 oder Ubuntu 24.04.
Netzwerk/Domain: Der Container lauscht intern auf Port 3001. Für den Zugriff von außen brauchst Du eine Domain und idealerweise einen Reverse-Proxy mit HTTPS (siehe Schritt 7).
GPU – nur bei lokalem LLM: Für AnythingLLM selbst ist KEINE GPU nötig. Eine GPU brauchst Du nur, wenn auf derselben Maschine ein lokales LLM läuft (z. B. Ollama oder LocalAI). Dann empfiehlt sich das nvidia-container-toolkit sowie eine GPU mit 8 GB+ VRAM für 7B-Modelle und 16–32 GB+ RAM. Alternativ betreibst Du das LLM auf einem separaten GPU-Host oder nutzt Cloud-Provider wie OpenAI/Anthropic.

Docker-Grundlagen setzen wir voraus. Wenn Du beim Aufbau von Compose-Stacks noch unsicher bist, hilft Dir vorab die Anleitung Docker Compose: Grundlagen und Stacks.

Schritt 1: Verzeichnis und compose.yaml anlegen

Lege auf dem Server ein Projektverzeichnis an. Dort landet die compose.yaml, und – je nach gewählter Persistenz-Variante – auch deine Daten:

mkdir -p $HOME/anythingllm
cd $HOME/anythingllm

Erstelle nun die compose.yaml. Die folgende Datei ist vollständig und lauffähig. Sie nutzt ein Named Volume für die Persistenz und bindet als LLM-Provider ein lokales Ollama auf dem Docker-Host ein. Wichtig auf Linux: host.docker.internal funktioniert dort NICHT – stattdessen verwendest Du die Docker-Bridge-Adresse http://172.17.0.1:PORT.

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest   # fuer Prod besser einen festen Versions-Tag pinnen
    container_name: anythingllm
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN                             # noetig fuer Web-Scraping/Chromium-Sandbox
    environment:
      - STORAGE_DIR=/app/server/storage
      - JWT_SECRET=BITTE-LANGEN-ZUFALLSSTRING-MIND-20-ZEICHEN-EINSETZEN
      - LLM_PROVIDER=ollama
      - OLLAMA_BASE_PATH=http://172.17.0.1:11434  # Linux-Host: nicht host.docker.internal
    volumes:
      - anythingllm_storage:/app/server/storage
    restart: always
volumes:
  anythingllm_storage:
    driver: local

Falls Du Cloud-Provider (OpenAI/Anthropic) nutzt, kannst Du die beiden LLM_PROVIDER- und OLLAMA_BASE_PATH-Zeilen weglassen und den Provider später bequem im Onboarding-Assistenten wählen. Für Produktion solltest Du :latest durch einen festen Versions-Tag ersetzen (das Repo ist Stand 2026 bei v1.8.x), damit Updates vorhersehbar bleiben.

Schritt 2: JWT_SECRET erzeugen und Persistenz verstehen

Das JWT_SECRET signiert die Sessions im Multi-User-Modus und sollte ein langer Zufallswert sein. Erzeuge ihn so und trage ihn in die compose.yaml ein:

openssl rand -hex 32

Achtung Login-Falle: Vermeide im späteren Admin-Passwort Sonderzeichen wie Backtick, einfaches Anführungszeichen oder Raute – ein bekannter Bug kann damit Login-Probleme verursachen.

Das Wichtigste an AnythingLLM ist die Persistenz. ALLE Daten liegen im Container unter /app/server/storage: die SQLite-Datenbank anythingllm.db, die LanceDB-Vektoren, hochgeladene und verarbeitete Dokumente sowie Modelle. Dieses Verzeichnis MUSS als Volume gemountet sein – sonst gehen beim Container-Neustart ALLE Daten verloren. Genau das erledigt die volumes-Sektion oben. Zusätzlich sorgt restart: always dafür, dass der Container nach einem Reboot automatisch wieder hochkommt.

Schritt 3: Container starten

Starte den Stack im Hintergrund und prüfe, dass der Container läuft:

docker compose up -d
docker compose ps
docker compose logs -f anythingllm   # Logs live mitlesen, mit Strg+C beenden

Wenn alles passt, ist die Web-UI jetzt unter http://SERVER-IP:3001 erreichbar. Den verwendeten Image-Tag eines laufenden Containers kannst Du jederzeit prüfen:

docker inspect --format '{{.Config.Image}}' anythingllm

Schritt 4: Web-UI-Ersteinrichtung (Onboarding)

Öffne http://SERVER-IP:3001 im Browser. Es gibt KEIN Default-Login – der Onboarding-Assistent führt Dich durch die Erstkonfiguration:

LLM-Provider wählen: AnythingLLM unterstützt 40+ Provider, darunter OpenAI, Anthropic, AWS Bedrock, Google Gemini, Ollama, LocalAI und llama.cpp-kompatible Server. Trägst Du Ollama ein, nutzt Du als Adresse auf Linux http://172.17.0.1:11434.
Embedding-Modell wählen: Als Default gibt es einen integrierten CPU-Embedder, der ohne externen Dienst läuft. Für große Dokumentmengen ist ein externer Embedder (z. B. OpenAI) empfehlenswert, weil der CPU-Embedder die Maschine stark belasten kann.
Vektordatenbank wählen: Standard ist die eingebettete LanceDB – lokal, kein externer Dienst nötig. Alternativ kannst Du Pinecone, Chroma, Qdrant, Weaviate oder Milvus anbinden.
Multi-User (optional): Standardmäßig läuft AnythingLLM im Single-User-Modus. Beim Aktivieren des Multi-User-Modus legst Du das erste Admin-Konto (Benutzername + Passwort) an. Es gibt die Rollen Admin, Manager und Default.

Sicherheitshinweis: Im Single-User-Modus ist die Instanz nach dem Start zunächst offen. Sobald sie im Netz erreichbar ist, solltest Du UNBEDINGT den Multi-User-Modus aktivieren und/oder per Reverse-Proxy mit Authentifizierung absichern (Schritt 7).

Schritt 5: Workspace anlegen und mit den eigenen Dokumenten chatten

Die Kernfunktion: ein Workspace kapselt einen Satz Dokumente samt zugehörigem Chat. So gehst Du vor:

Workspace erstellen: Klick in der UI auf New Workspace und gib ihm einen Namen, z. B. Handbuecher.
Dokumente ingestieren: Öffne im Workspace die Upload-Ansicht und lade PDFs, Word-, Text- oder Markdown-Dateien hoch. AnythingLLM zerlegt sie, erzeugt Embeddings und legt die Vektoren in LanceDB ab.
Webseiten scrapen: Du kannst auch URLs einlesen lassen – dafür ist die Capability SYS_ADMIN nötig (siehe Schritt 1).
Dokumente dem Workspace zuweisen: Markiere die ingestierten Dokumente und übernimm sie in den Workspace (Save and Embed).
Chatten: Stelle im Workspace-Chat Fragen. AnythingLLM holt die passenden Textstellen aus LanceDB, reicht sie als Kontext an dein LLM weiter und antwortet mit Quellenbezug – das ist RAG.

Wer mehr will, aktiviert No-Code-Agenten: Diese können im Chat z. B. das Web durchsuchen, Dokumente zusammenfassen oder eigene Skills ausführen, ohne dass Du Code schreibst.

Schritt 6: Alternative ohne Compose – docker run

Falls Du keinen Compose-Stack möchtest, geht es auch mit docker run und einem Bind-Mount. Achte darauf, dass das offizielle Beispiel --rm verwendet – für den Dauerbetrieb auf einem Server lässt Du --rm WEG und setzt stattdessen --restart unless-stopped:

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"
docker run -d -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  --restart unless-stopped \
  mintplexlabs/anythingllm

Bei dieser Variante wird zusätzlich eine Host-Datei .env auf /app/server/.env gemountet. Dort kannst Du Env-Variablen wie STORAGE_DIR, JWT_SECRET, LLM_PROVIDER oder OLLAMA_BASE_PATH pflegen:

STORAGE_DIR=/app/server/storage
JWT_SECRET=BITTE-LANGEN-ZUFALLSSTRING-MIND-20-ZEICHEN
LLM_PROVIDER=ollama
OLLAMA_BASE_PATH=http://172.17.0.1:11434
UID=1000
GID=1000

Schritt 7: Reverse-Proxy und HTTPS

Port 3001 gehört NICHT ungeschützt ins Internet. Stelle der Web-UI einen Reverse-Proxy mit TLS voran, der nach außen auf 443 lauscht und intern an 127.0.0.1:3001 weiterleitet. Beispiel für nginx:

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

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

    location / {
        proxy_pass http://127.0.0.1:3001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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;
    }
}

Damit die UI nicht mehr direkt erreichbar ist, binde das Port-Mapping in der compose.yaml an die Loopback-Adresse: - "127.0.0.1:3001:3001". Kombiniere das mit aktiviertem Multi-User-Modus, dann ist die Instanz sauber abgesichert.

Schritt 8: Update-Workflow und Backup

Ein Update besteht aus zwei Befehlen. Dank Storage-Volume bleiben alle Daten erhalten:

docker compose pull && docker compose up -d

Ziehe vor jedem Update ein Backup, besonders wenn Du :latest nutzt. Bei einem Bind-Mount (Variante aus Schritt 6) sicherst Du einfach das Verzeichnis:

docker compose down
tar czf anythingllm-backup-$(date +%F).tar.gz -C $HOME anythingllm
docker compose up -d

Bei einem Named Volume (Variante aus Schritt 1) sicherst Du es über einen Hilfscontainer:

docker run --rm \
  -v anythingllm_storage:/data \
  -v $PWD:/backup \
  alpine tar czf /backup/allm.tgz -C /data .

Das Backup enthält SQLite-DB, LanceDB-Vektoren, Dokumente und – bei der Bind-Mount-Variante – die .env. Damit kannst Du die Instanz jederzeit auf einem anderen Host wiederherstellen.

Troubleshooting

Daten nach Neustart weg: Das Storage-Volume war nicht gemountet, oder es lief ein docker run mit --rm. Mounte /app/server/storage und nutze --restart unless-stopped bzw. restart: always ohne --rm.
Webseiten-Scraping/Dokument-Verarbeitung schlägt fehl: Die Capability SYS_ADMIN fehlt. Ergänze cap_add: [SYS_ADMIN] in der compose.yaml.
Ollama/LocalAI nicht erreichbar: Auf Linux zeigt host.docker.internal nicht auf den Host. Verwende http://172.17.0.1:PORT oder lege den LLM-Dienst in dasselbe Compose-Netz.
Login klappt nicht: Sonderzeichen wie Backtick, einfaches Anführungszeichen oder Raute im Admin-Passwort meiden. Prüfe außerdem, dass JWT_SECRET gesetzt und lang genug ist.
Hohe CPU-/RAM-Last: Vermutlich verarbeitet der eingebaute CPU-Embedder viele Dokumente. Konfiguriere für große Mengen einen externen Embedder-Provider.

Häufige Fragen

Brauche ich für AnythingLLM eine GPU?

Nein. AnythingLLM selbst braucht keine GPU. RAM- und VRAM-Bedarf entsteht nur, wenn auf derselben Maschine ein lokales LLM (Ollama/LocalAI) läuft. Auf schwacher Hardware nutzt Du besser Cloud-Provider oder einen separaten GPU-Host für das LLM.

Worin unterscheidet sich AnythingLLM von einem selbst gebauten Qdrant-RAG?

AnythingLLM ist eine turnkey RAG-Anwendung: LLM-Anbindung, integrierte Vektor-DB (LanceDB), Embedding, Ingestion, Workspaces, Agenten und Multi-User sind out-of-the-box dabei. Ein selbst gebautes Qdrant-RAG gibt Dir mehr Kontrolle über die Pipeline, erfordert aber eigenen Code. Wie das aussieht, zeigt unsere Anleitung Qdrant RAG-System lokal mit Embeddings.

Muss ich einen externen LLM-Anbieter nutzen?

Nein. Du kannst ein lokales LLM über Ollama oder einen OpenAI-kompatiblen Server anbinden und bleibst damit komplett im eigenen Haus. Wie Du so einen Server aufsetzt, beschreibt die Anleitung LocalAI: OpenAI-kompatibler KI-Server mit Docker.

Wo liegen meine Daten?

Alles liegt unter /app/server/storage: SQLite-DB, LanceDB-Vektoren, hochgeladene und verarbeitete Dokumente sowie Modelle. Genau dieses Verzeichnis sicherst Du im Backup.

Wie aktualisiere ich, ohne Daten zu verlieren?

Mit gemountetem Storage-Volume reicht docker compose pull && docker compose up -d. Der Container wird ersetzt, die Daten bleiben im Volume. Ziehe vorher trotzdem ein Backup.

Kann ich mehrere Teams getrennt arbeiten lassen?

Ja. Aktiviere den Multi-User-Modus (legt das erste Admin-Konto an) und nutze die Rollen Admin, Manager und Default. Über getrennte Workspaces hältst Du die Dokumentensätze der Teams auseinander.

Fazit

Mit AnythingLLM und Docker hast Du in unter einer halben Stunde eine vollwertige RAG-Plattform am Laufen: ein Container, eine compose.yaml, ein Onboarding-Klickpfad. Entscheidend für den Dauerbetrieb sind drei Dinge: das Storage-Volume auf /app/server/storage mounten, --cap-add SYS_ADMIN setzen und die Instanz hinter einem Reverse-Proxy mit aktiviertem Multi-User-Modus absichern. Für die eigentliche Inferenz wählst Du frei zwischen Cloud-Providern, einem lokalen LLM oder einem GPU-Host – AnythingLLM selbst bleibt schlank. Damit chattest Du DSGVO-bewusst und reproduzierbar mit deinen eigenen Dokumenten.

Weiterführende Anleitungen und Quellen

Passende Anleitungen aus unserem Wissensbereich:

Docker Compose: Grundlagen und Stacks – Basis für die hier verwendete compose.yaml.
LocalAI: OpenAI-kompatibler KI-Server mit Docker – lokales LLM/Embedding-Backend für AnythingLLM.
Qdrant RAG-System lokal mit Embeddings – das selbst gebaute Gegenstück zur turnkey-Lösung.
Alle Anleitungen der Kategorie Künstliche Intelligenz

Quellen (offizielle Doku/Repo, Stand 2026):