AnythingLLM Installationsanleitung

Ubuntu 24.04 • Docker • Ollama • Vollständiges RAG-Setup

Was ist AnythingLLM?

AnythingLLM ist der ultimative KI-Arbeitsbereich — eine Full-Stack-Anwendung, mit der Sie jedes Dokument, jede Website oder jede Codebasis in RAG-Daten (Retrieval-Augmented Generation) umwandeln können, mit denen Sie chatten können. Es funktioniert mit jedem LLM, ob lokal oder cloudbasiert, und läuft vollständig auf Ihrer eigenen Infrastruktur. Kombinieren Sie Dokumente, PDFs, Videos und Audio zu einer einzigen KI-gestützten Wissensdatenbank mit einer sauberen, modernen Benutzeroberfläche.

Hauptfunktionen:

• Multi-LLM-Unterstützung — Ollama, OpenAI, Anthropic, Azure, LM Studio und über 20 weitere Anbieter
• Local-first RAG — Einbettungen (Embeddings) und Inferenz verlassen niemals Ihre Maschine
• Multi-User-Arbeitsbereiche — separate Arbeitsbereiche mit isolierten Datenspeichern
• Benutzerdefinierte Agenten — integrierte Tools für Websuche, Codeausführung und mehr

Voraussetzungen

• 2 vCPU / 4 GB RAM Minimum (8 GB+ empfohlen für große Dokumente oder mehrere Benutzer)
• Docker — Community Edition (25.x+) installiert (docker --version zur Überprüfung)
• Docker Compose (V2, in Docker Desktop enthalten oder als docker compose plugin)
• Port 3001 — muss frei und zugänglich sein (oder via Nginx weitergeleitet werden)
• 10 GB+ freier Festplattenspeicher für Docker-Images, Speichervolumen und LLM-Modelle
• Ubuntu 24.04 LTS (Noble Numbat) — frisch aktualisiert (sudo apt update && sudo apt upgrade -y)

1. Docker installieren

Installieren Sie die offiziellen Docker-Repository-Pakete auf Ubuntu 24.04:

# Offiziellen GPG-Schlüssel und Repository von Docker hinzufügen
sudo apt-get update
sudo apt-get install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Benutzer zur Docker-Gruppe hinzufügen (danach aus- und wieder einloggen)
sudo usermod -aG docker $USER

# Installation überprüfen
docker --version
docker compose version

2. Projektverzeichnis erstellen

mkdir -p ~/anythingllm/storage
cd ~/anythingllm

3. Docker Compose Konfiguration

Erstellen Sie eine docker-compose.yml in ~/anythingllm/. Dies ist das empfohlene produktionsreife Setup mit Ollama als LLM-Anbieter und lokalen Einbettungen:

version: "3.8"
services:
  anythingllm:
    image: ghcr.io/mintplexlabs/anything-llm:latest
    container_name: anythingllm
    ports:
      - "3001:3001"
    volumes:
      - ./storage:/app/storage
    environment:
      - STORAGE_DIR=/app/storage
      - JWT_SECRET="change-me-to-a-random-string"
      - LLM_PROVIDER=ollama
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
      - OLLAMA_MODEL_PREF=llama3.2
      - EMBEDDING_PROVIDER=ollama
      - OPEN_MODEL_PREF=nomic-embed-text
    extra_hosts:
      - "host.docker.internal:host-gateway"
    restart: unless-stopped

Minimale Konfiguration (ohne Ollama-Umgebungsvariablen)

Wenn Sie keine Ollama-Voreinstellungen benötigen, ist das absolute Minimum:

version: "3.8"
services:
  anythingllm:
    image: ghcr.io/mintplexlabs/anything-llm:latest
    container_name: anythingllm
    ports:
      - "3001:3001"
    volumes:
      - ./storage:/app/storage
    environment:
      - STORAGE_DIR=/app/storage
      - JWT_SECRET="a-strong-random-secret"
    restart: unless-stopped

Sie können LLM- und Embedding-Anbieter dann beim ersten Login über die Web-Benutzeroberfläche konfigurieren.

4. Container starten

docker compose up -d
docker compose logs -f    # Startvorgang beobachten (Strg+C zum Trennen)

Sobald Sie Server running on port 3001 sehen, öffnen Sie http://ihre-server-ip:3001 in Ihrem Browser.

5. Nginx Reverse Proxy (Optional, aber empfohlen)

Stellen Sie AnythingLLM über eine Subdomain mit SSL bereit:

# Nginx installieren
sudo apt-get install -y nginx certbot python3-certbot-nginx

# Seitenkonfiguration erstellen
sudo nano /etc/nginx/sites-available/anythingllm

Fügen Sie Folgendes ein (ersetzen Sie anything.example.com):

server {
    listen 80;
    server_name anything.example.com;

    client_max_body_size 100M;

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

# Seite aktivieren und SSL abrufen
sudo ln -s /etc/nginx/sites-available/anythingllm /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

# Let's Encrypt Zertifikat abrufen
sudo certbot --nginx -d anything.example.com

6. Referenz der Umgebungsvariablen

7. RAG-Konfiguration mit lokalen Embeddings

AnythingLLM unterstützt vollständig lokales RAG — Dokumente werden auf Ihrer Maschine in Chunks unterteilt, eingebettet und indiziert, ohne dass externe API-Aufrufe erforderlich sind.

Verbindung zu Ollama

Stellen Sie sicher, dass Ollama auf dem Host läuft:

# Ollama installieren (falls noch nicht geschehen)
curl -fsSL https://ollama.com/install.sh | sh

# Ein Chat-Modell und ein Embedding-Modell herunterladen
ollama pull llama3.2
ollama pull nomic-embed-text

# Ollama läuft standardmäßig auf 0.0.0.0:11434 — überprüfen
ollama list

RAG in der UI konfigurieren

1. Öffnen Sie AnythingLLM unter http://localhost:3001 (oder Ihrer Domain).
2. Erstellen Sie beim ersten Start ein Administratorkonto.
3. Gehen Sie zu Settings → LLM Preference und wählen Sie Ollama.
4. Setzen Sie die Ollama Base URL auf http://host.docker.internal:11434 (oder die IP Ihres Ollama-Hosts).
5. Wählen Sie das Chat-Modell (z. B. llama3.2) und speichern Sie.
6. Gehen Sie zu Settings → Embedding Preference und wählen Sie Ollama.
7. Setzen Sie das Embedding-Modell auf nomic-embed-text (oder llama3.2).
8. Speichern — das System wird alle vorhandenen Dokumente mit dem neuen Anbieter neu einbetten.

Dokument-Vektor-Einstellungen

Unter Settings → Vector Database können Sie Folgendes anpassen:

• Chunk size — Standard 1000 Token; für präzisere Antworten auf 500 reduzieren, für breiteren Kontext auf 2000 erhöhen
• Chunk overlap — Standard 200 Token; hilft, den Kontext über Chunk-Grenzen hinweg zu erhalten
• Document similarity threshold — Mindest-Relevanz-Score (0.0–1.0), damit ein Chunk in den Kontext aufgenommen wird

8. Backup

Der gesamte Status von AnythingLLM — Dokumente, Vektor-Index, Benutzerkonten, Einstellungen — befindet sich im Verzeichnis ./storage. Sichern Sie es regelmäßig:

# Container vor dem Backup für Konsistenz stoppen
docker compose down

# Ein Backup mit Zeitstempel erstellen
tar -czf anythingllm-backup-$(date +%Y%m%d-%H%M%S).tar.gz storage/

# Container neu starten
docker compose up -d

Zum Wiederherstellen stoppen Sie den Container, entpacken das Archiv über ./storage/ und starten neu:

tar -xzf anythingllm-backup-20250115-120000.tar.gz
docker compose up -d

9. AnythingLLM aktualisieren

cd ~/anythingllm
docker compose pull                 # Aktuelles Image herunterladen
docker compose up -d                 # Container neu erstellen, falls sich das Image geändert hat
docker image prune                   # Alte, verwaiste Images entfernen

Überprüfen Sie die GitHub Releases-Seite auf Changelogs und Breaking Changes, bevor Sie Hauptversionen aktualisieren.

10. Fehlerbehebung

JWT-Fehler nach Neustart

Symptom: Nach dem Neustart des Containers zeigen bestehende Sitzungen "Invalid or expired token" an oder Benutzer sind abgemeldet.

Ursache: Das JWT_SECRET hat sich zwischen den Ausführungen geändert. AnythingLLM verwendet es zum Signieren von Sitzungstokens; eine Änderung macht alle bestehenden Sitzungen ungültig.

Lösung: Legen Sie ein festes JWT_SECRET in der docker-compose.yml fest und ändern Sie es niemals. Benutzer müssen sich einfach erneut anmelden. Wenn Sie das Geheimnis absichtlich rotiert haben, ist dies das erwartete Verhalten.

Ollama-Verbindung verweigert

Symptom: "Failed to connect to Ollama" oder "Connection refused" bei der Auswahl des Ollama-LLM-Anbieters.

Checkliste:

1. Überprüfen Sie, ob Ollama läuft: curl http://localhost:11434/api/tags auf dem Host.
2. Stellen Sie sicher, dass das Bridge-Netzwerk den Host-Zugriff erlaubt: host.docker.internal funktioniert unter Docker Desktop und mit extra_hosts wie oben gezeigt.
3. Wenn Sie Docker auf einem Remote-Host verwenden, ersetzen Sie host.docker.internal durch die tatsächliche IP (z. B. http://192.168.1.50:11434).
4. Überprüfen Sie, ob Ollama an 0.0.0.0 bindet, nicht an 127.0.0.1: ss -tlnp | grep 11434 sollte 0.0.0.0:11434 anzeigen.

Embedding-Dimensions-Konflikt

Symptom: "Vector dimension mismatch" oder "Embedding size mismatch"-Fehler beim Abfragen von Dokumenten.

Ursache: Sie haben Embedding-Modelle (oder Anbieter) gewechselt, nachdem Dokumente bereits indiziert wurden. Ein anderes Modell erzeugt Vektoren einer anderen Dimension, was die Vektordatenbank beschädigt.

Lösung: Gehen Sie zu Settings → Vector Database und klicken Sie auf Reset Vector Database (dies entfernt alle vorhandenen Embeddings, behält aber Ihre Dokumente). Laden Sie Dokumente dann erneut hoch oder verarbeiten Sie sie neu, damit sie mit dem neuen Modell eingebettet werden.

Verarbeitung großer Dokumente

Symptom: Große PDFs (100+ Seiten) führen zu Timeouts oder schlagen bei der Verarbeitung fehl.

Lösungen:

• Erhöhen Sie client_max_body_size in Nginx auf 500M+ (siehe Abschnitt 5).
• Fügen Sie DISABLE_LOGS=true zu den Container-Umgebungsvariablen hinzu, um den I/O-Overhead während der Verarbeitung zu reduzieren.
• Teilen Sie sehr große Dokumente vor dem Hochladen in kleinere Dateien (jeweils 50–100 Seiten) auf.
• Stellen Sie sicher, dass der Server über ausreichend RAM verfügt — Einbettung ist speicherintensiv. 8 GB werden für Dokumente über 1000 Seiten empfohlen.
• Reduzieren Sie die Chunk-Größe in den Vektordatenbank-Einstellungen auf 500 Token, damit jeder Chunk schneller verarbeitet wird.

Allgemeines Debugging

Überprüfen Sie die Container-Logs auf detaillierte Fehlermeldungen:

docker compose logs -f --tail=100

Um ohne Cache neu zu erstellen, falls etwas feststeckt:

docker compose down
docker compose up -d --force-recreate

AnythingLLM — GitHub Repository • Offizielle Website • Run This AI