AnythingLLM RAG-Plattform

Setzen Sie AnythingLLM auf Clore.ai ein — eine All-in-One RAG-Anwendung und KI-Agentenplattform mit integriertem Dokument-Chat, No-Code-Agenten-Builder und MCP-Unterstützung, die auf kosteneffizienten GPU-Cloud-Servern läuft.

Überblick

AnythingLLM ist ein voll ausgestatteter Open-Source-AI-Arbeitsbereich mit über 40.000 GitHub-Sternen. Er kombiniert dokumentenbasierte RAG (Retrieval-Augmented Generation), KI-Agenten und einen No-Code-Agenten-Baukasten in einer einzigen, selbst gehosteten Anwendung – alles verwaltet über eine saubere, intuitive Benutzeroberfläche, die keine Programmierkenntnisse zur Einrichtung erfordert.

Warum AnythingLLM auf Clore.ai betreiben?

Vollständige RAG-Pipeline sofort einsatzbereit — Laden Sie PDFs, Word-Dokumente, Websites und YouTube-Transkripte hoch. AnythingLLM zerlegt, erstellt Einbettungen und speichert sie automatisch für semantische Suche.
Keine GPU für die Anwendung erforderlich — AnythingLLM verwendet standardmäßig CPU-basierte Einbettungen. Kombinieren Sie es mit einem Clore.ai-GPU-Server, der Ollama oder vLLM für lokale Inferenz ausführt.
KI-Agenten mit echten Tools — Eingebaute Agenten können das Web durchsuchen, Code schreiben und ausführen, Dateien verwalten und externe APIs aufrufen – alles über eine GUI orchestriert.
MCP-Kompatibilität — Integriert sich in das Model Context Protocol-Ökosystem für erweiterte Tool-Konnektivität.
Workspace-Isolierung — Erstellen Sie separate Workspaces mit unterschiedlichen Wissensdatenbanken und LLM-Einstellungen für verschiedene Projekte oder Teams.

Architekturübersicht

┌─────────────────────────────────────────────┐
│            AnythingLLM (Port 3001)          │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │  Agents  │  │  Users   │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM Provider Router   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (lokal)
  Claude        Gemini      vLLM (lokal)

Anforderungen

Server-Spezifikationen

Komponente

Minimum

Clore.ai Preisinformationen

Servertyp

Ungefähre Kosten

Einsatzgebiet

CPU-Instanz (4 vCPU, 8 GB RAM)

~0,05–0,10 $/Std.

AnythingLLM + externe API-Anbieter

RTX 3090 (24 GB VRAM)

~$0.20/Stunde

AnythingLLM + Ollama lokale LLMs

RTX 4090 (24 GB VRAM)

~$0.35/Stunde

AnythingLLM + schnellere lokale Inferenz

A100 80 GB

~$1.10/Stunde

AnythingLLM + große Modelle ab 70B+

💡 Pro-Tipp: Die eingebaute Einbettung von AnythingLLM (LanceDB + lokaler CPU-Embedder) funktioniert ohne GPU. Für das LLM-Backend können Sie kostenlose API-Anbieter wie OpenRouter oder Groq nutzen, um die Kosten gering zu halten.

Voraussetzungen

Clore.ai-Server mit SSH-Zugang
Docker (vorinstalliert auf Clore.ai-Servern)
Mindestens ein LLM-API-Schlüssel oder lokales Ollama/vLLM-Backend

Schnellstart

Methode 1: Einzelner Docker-Container (empfohlen)

Die offizielle Single-Container-Bereitstellung enthält alles: die Web-UI, LanceDB-Vektorspeicher und den Dokumentenprozessor.

Schritt 1: Verbinden Sie sich mit Ihrem Clore.ai-Server

ssh root@<your-clore-server-ip> -p <ssh-port>

Schritt 2: Speicherverzeichnis einrichten

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"

Schritt 3: AnythingLLM starten

docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -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" \
  mintplexlabs/anythingllm

Warum --cap-add SYS_ADMIN? AnythingLLM verwendet Chromium zum Scrapen von Webseiten und Rendern von PDFs, was erhöhte Container-Berechtigungen erfordert.

Schritt 4: Start überprüfen

docker logs anythingllm --tail 30 -f
# Warten auf: "Server listening on port 3001"

Schritt 5: Setup-Assistent abschließen

Im Browser öffnen:

http://<your-clore-server-ip>:3001

Der erstmalige Setup-Assistent führt Sie durch:

Admin-Konto erstellen
LLM-Anbieter wählen
Einbettungsmodell wählen
Ihren ersten Workspace konfigurieren

Methode 2: Docker Compose (Multi-Service)

Für Produktionsbereitstellungen mit separaten Diensten und leichterer Verwaltung:

Schritt 1: Projektverzeichnis anlegen

mkdir -p ~/anythingllm && cd ~/anythingllm
mkdir -p storage
touch storage/.env

Schritt 2: Erstellen Sie docker-compose.yml

cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest
    container_name: anythingllm
    restart: unless-stopped
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN
    environment:
      STORAGE_DIR: "/app/server/storage"
      # LLM-Anbieter (einen konfigurieren)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # Einbettung
      EMBEDDING_ENGINE: native
      # Vektor-DB
      VECTOR_DB: lancedb
      # Auth
      AUTH_TOKEN: ${ANYTHINGLLM_AUTH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
    volumes:
      - ./storage:/app/server/storage
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/api/ping"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  anythingllm_storage:
EOF

Schritt 3: Erstellen .env Datei

cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=Ihr-zufälliges-64-Zeichen-Secret-hier
EOF

Schritt 4: Starten

docker compose up -d
docker compose logs anythingllm -f

Methode 3: Mit vorkonfigurierten Umgebungsvariablen

Für automatisierte Bereitstellung ohne Setup-Assistent:

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION && touch "$STORAGE_LOCATION/.env"

docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -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" \
  -e LLM_PROVIDER=openai \
  -e OPEN_AI_KEY=sk-your-key \
  -e OPEN_MODEL_PREF=gpt-4o-mini \
  -e EMBEDDING_ENGINE=native \
  -e VECTOR_DB=lancedb \
  -e AUTH_TOKEN=your-password \
  -e JWT_SECRET=$(openssl rand -hex 32) \
  mintplexlabs/anythingllm

Konfiguration

LLM-Anbieter-Optionen

AnythingLLM unterstützt eine große Auswahl an LLM-Backends. Einstellbar in der UI unter Einstellungen → LLM-Voreinstellungen, oder über Umgebungsvariablen:

OpenAI:

-e LLM_PROVIDER=openai
-e OPEN_AI_KEY=sk-your-key
-e OPEN_MODEL_PREF=gpt-4o

Anthropic Claude:

-e LLM_PROVIDER=anthropic
-e ANTHROPIC_API_KEY=sk-ant-your-key
-e ANTHROPIC_MODEL_PREF=claude-sonnet-4-5

Google Gemini:

-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=your-key
-e GEMINI_LLM_MODEL_PREF=gemini-1.5-pro

Ollama (lokal):

-e LLM_PROVIDER=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e OLLAMA_MODEL_PREF=llama3.2

OpenRouter (Zugriff auf 100+ Modelle):

-e LLM_PROVIDER=openrouter
-e OPENROUTER_API_KEY=sk-or-your-key
-e OPENROUTER_MODEL_PREF=meta-llama/llama-3.1-8b-instruct:free

Einbettungskonfiguration

Engine

Backend

GPU benötigt

Qualität

native

CPU (eingebaut)

Nein

Gut

openai

OpenAI API

Nein

Ausgezeichnet

ollama

Lokales Ollama

Optional

Gut–Ausgezeichnet

localai

LocalAI

Optional

Variable

# Verwenden Sie OpenAI-Einbettungen für beste Qualität
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# Verwenden Sie Ollama-Einbettungen für eine vollständig lokale Pipeline
-e EMBEDDING_ENGINE=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e EMBEDDING_MODEL_PREF=nomic-embed-text

Optionen für Vektor-Datenbanken

Beschreibung

Am besten geeignet für

lancedb

Eingebaut, keine Konfiguration

Standard, kleine–mittlere Datensätze

chroma

ChromaDB (extern)

Mittlere Datensätze, Flexibilität

pinecone

Pinecone Cloud

Große Datensätze, Produktion

weaviate

Weaviate (selbst gehostet)

Erweiterte Anwendungsfälle

Workspace-Konfiguration

AnythingLLM-Workspaces sind isolierte Umgebungen mit eigenen:

Dokumenten-Wissensbasis
LLM-Einstellungen (können global überschreiben)
Chat-Verlauf
Agentenkonfigurationen

Erstellen Sie Workspaces über die UI oder API:

# Workspace über API erstellen
curl -X POST http://localhost:3001/api/v1/workspace/new \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Project", "similarityThreshold": 0.7}'

Dokumentaufnahme (Ingestion)

Laden Sie Dokumente über UI oder API hoch:

# Ein Dokument über die API hochladen
curl -X POST http://localhost:3001/api/v1/document/upload \
  -H "Authorization: Bearer your-api-key" \
  -F "file=@/path/to/document.pdf"

# Dokument in Workspace verschieben
curl -X POST http://localhost:3001/api/v1/workspace/my-project/update-embeddings \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"adds": ["custom-documents/document.pdf-chunk-1.json"]}'

GPU-Beschleunigung

AnythingLLM selbst läuft auf der CPU. GPU-Beschleunigung gilt für das LLM-Inferenz-Backend.

Ollama auf demselben Clore.ai-Server ausführen

# Ollama mit GPU-Unterstützung starten
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  ollama/ollama

# Modelle für AnythingLLM herunterladen
docker exec ollama ollama pull llama3.2          # 2B, schnell
docker exec ollama ollama pull llama3.1:8b       # 8B, ausgewogen
docker exec ollama ollama pull nomic-embed-text  # für Einbettungen
docker exec ollama ollama pull mxbai-embed-large # bessere Einbettungen

# AnythingLLM mit Ollama-Konfiguration neu starten
docker stop anythingllm && docker rm anythingllm

docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e LLM_PROVIDER=ollama \
  -e OLLAMA_BASE_PATH=http://172.17.0.1:11434 \
  -e OLLAMA_MODEL_PREF=llama3.1:8b \
  -e EMBEDDING_ENGINE=ollama \
  -e EMBEDDING_MODEL_PREF=nomic-embed-text \
  mintplexlabs/anythingllm

GPU-Modellleistung auf Clore.ai

Modell

GPU

VRAM

Einbettungsgeschwindigkeit

Inferenzgeschwindigkeit

Kosten/Stunde

Llama 3.2 3B

RTX 3090

2 GB

Schnell

60–80 tok/s

~$0.20

Llama 3.1 8B

RTX 3090

6 GB

Schnell

40–60 tok/s

~$0.20

Mistral 7B

RTX 3090

5 GB

Schnell

45–65 tok/s

~$0.20

Llama 3.1 70B

A100 80GB

40 GB

Mittel

20–35 tok/s

~$1.10

Tipps & bewährte Methoden

Best Practices für Dokumentenaufnahme

# Für große Dokumentensätze Node.js-Speicher erhöhen
-e NODE_OPTIONS="--max-old-space-size=4096"

# Empfohlene Chunk-Einstellungen für verschiedene Dokumenttypen
# Technische Dokumentation: Chunk-Größe 1000, Überlappung 200
# Rechtliches/Verträge: Chunk-Größe 500, Überlappung 100
# Bücher/Artikel: Chunk-Größe 1500, Überlappung 300

Große PDFs vorverarbeiten — OCR-lastige Scans verlangsamen die Aufnahme. Verwenden Sie pdftotext oder Adobe OCR im Vorfeld.
Nach Workspace organisieren — Erstellen Sie für jedes Projekt/Domain separate Workspaces für bessere Abrufgenauigkeit.
Spezifische Abfragen verwenden — RAG funktioniert am besten mit spezifischen Fragen, nicht mit allgemeinen Anfragen.

Kostenmanagement auf Clore.ai

# Sichern Sie Ihren Speicher, bevor Sie eine Clore.ai-Instanz stoppen
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

# Um auf einer neuen Clore.ai-Instanz fortzufahren, stellen Sie das Backup wieder her
tar -xzf anythingllm-backup-20240101.tar.gz -C ~/

Da Clore.ai-Instanzen flüchtig sind, sichern Sie immer das Speicherverzeichnis. Es enthält:

Vektor-Einbettungen (LanceDB)
Hochgeladene Dokumente
Chat-Verlauf
Agentenkonfigurationen

Multi-Benutzer-Einrichtung

# Multi-User-Modus in der UI aktivieren:
# Einstellungen → Sicherheit → Multi-User-Modus aktivieren

# Oder über die Umgebung:
-e MULTI_USER_MODE=true

# Benutzer nach Aktivierung des Multi-User-Modus über API erstellen
curl -X POST http://localhost:3001/api/v1/admin/users/new \
  -H "Authorization: Bearer admin-api-key" \
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "securepass", "role": "default"}'

KI-Agentenkonfiguration

AnythingLLM-Agenten können reale Aufgaben ausführen. Aktivieren Sie Tools in Einstellungen → Agents:

Web-Browsen — Ruft Webseiten ab und liest sie
Google-Suche — Durchsucht Google (erfordert API-Schlüssel)
Code-Interpreter — Führt Python in einer Sandbox aus
GitHub — Liest Repositories
SQL-Connector — Fragt Datenbanken ab

# Agentenfähigkeiten über die Umgebung aktivieren
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=your-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=your-api-key

Leistungsoptimierung

# Für schwere Dokumentenverarbeitungs-Workloads
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  --cpus="4" \
  --memory="8g" \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

AnythingLLM aktualisieren

# Neuestes Image ziehen
docker pull mintplexlabs/anythingllm:latest

# Zuerst Backup erstellen
cp -r $HOME/anythingllm $HOME/anythingllm-backup-$(date +%Y%m%d)

# Alten Container stoppen und entfernen (Daten sind im Volume, sicher)
docker stop anythingllm && docker rm anythingllm

# Mit demselben Befehl neu starten
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

Fehlerbehebung

Container startet, aber UI nicht erreichbar

# Überprüfen, ob Container läuft
docker ps | grep anythingllm

# Logs auf Startfehler prüfen
docker logs anythingllm --tail 50

# Überprüfen Sie die Portbindung
ss -tlnp | grep 3001

# Prüfen, ob der Clore.ai-Server Port 3001 in der Portzuordnung hat
# (in den Clore.ai-Bereitstellungseinstellungen hinzufügen)

Dokument-Upload schlägt fehl

# Überprüfen Sie den verfügbaren Festplattenspeicher
df -h

# Dokumentenprozessor-Logs prüfen
docker logs anythingllm 2>&1 | grep -i "error\|fail\|upload"

# Verifizieren, dass die SYS_ADMIN-Fähigkeit gesetzt ist (erforderlich für Chromium)
docker inspect anythingllm | grep -A5 CapAdd

RAG-Antworten sind von schlechter Qualität / Halluzinieren

Häufige Ursachen und Behebungen:

# 1. Ändern Sie den Ähnlichkeitsschwellenwert (niedriger = mehr Dokumente werden abgerufen)
# Einstellungen → Workspace → Vektor-Datenbank → Similarity Threshold: 0.5

# 2. Erhöhen Sie die Top-K-Ergebnisse
# Einstellungen → Workspace → Vektor-Datenbank → Max Context Snippets: 10

# 3. Verbessern Sie die Chunk-Größe (Dokumente nach Änderung neu ingestieren)
# Einstellungen → Workspace → Text Splitter → Chunk Size: 1000, Overlap: 200

# 4. Wechseln Sie zu einem besseren Einbettungsmodell
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large

Ollama-Verbindung von AnythingLLM schlägt fehl

# Im AnythingLLM-Container testen
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# Falls das fehlschlägt, finden Sie die tatsächliche Docker-Bridge-IP
ip route | grep docker
# Verwenden Sie diese IP in OLLAMA_BASE_PATH

# Alternative: Host-Netzwerk verwenden
docker run -d \
  --name anythingllm \
  --network host \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e OLLAMA_BASE_PATH=http://localhost:11434 \
  mintplexlabs/anythingllm

Nicht genügend Speicher / Container-Absturz

# Speicherverbrauch prüfen
docker stats anythingllm

# Speicher freimachen, indem Sie den LanceDB-Cache reduzieren
# Oder zu einer Clore.ai-Instanz mit mehr RAM wechseln

# Neustart mit Speichergrenzen und Swap
docker run -d \
  --name anythingllm \
  --memory=6g \
  --memory-swap=8g \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

Weiterführende Lektüre

AnythingLLM-Dokumentation — vollständige Einrichtung und API-Referenz
AnythingLLM GitHub — Quellcode, Issues, Roadmap
AnythingLLM Docker Hub — Image-Tags
Ollama auf Clore.ai ausführen — lokales LLM-Backend für AnythingLLM
vLLM auf Clore.ai ausführen — Hochleistungs-Inferenz
GPU-Vergleichsanleitung — Auswahl des richtigen Clore.ai-Tarifs
MCP-Dokumentation — Model Context Protocol zum Erweitern von Agenten
AnythingLLM API-Referenz — REST-API für Automatisierung

VorherigeLibreChat Multi-Provider NächsteJan.ai Offline-Assistent

Zuletzt aktualisiert vor 23 Stunden

War das hilfreich?

hashtagÜberblick

hashtagArchitekturübersicht

hashtagAnforderungen

hashtagServer-Spezifikationen

hashtagClore.ai Preisinformationen

hashtagVoraussetzungen

hashtagSchnellstart

hashtagMethode 1: Einzelner Docker-Container (empfohlen)

hashtagMethode 2: Docker Compose (Multi-Service)

hashtagMethode 3: Mit vorkonfigurierten Umgebungsvariablen

hashtagKonfiguration

hashtagLLM-Anbieter-Optionen

hashtagEinbettungskonfiguration

hashtagOptionen für Vektor-Datenbanken

hashtagWorkspace-Konfiguration

hashtagDokumentaufnahme (Ingestion)

hashtagGPU-Beschleunigung

hashtagOllama auf demselben Clore.ai-Server ausführen

hashtagGPU-Modellleistung auf Clore.ai

hashtagTipps & bewährte Methoden

hashtagBest Practices für Dokumentenaufnahme

hashtagKostenmanagement auf Clore.ai

hashtagMulti-Benutzer-Einrichtung

hashtagKI-Agentenkonfiguration

hashtagLeistungsoptimierung

hashtagAnythingLLM aktualisieren

hashtagFehlerbehebung

hashtagContainer startet, aber UI nicht erreichbar

hashtagDokument-Upload schlägt fehl

hashtagRAG-Antworten sind von schlechter Qualität / Halluzinieren

hashtagOllama-Verbindung von AnythingLLM schlägt fehl

hashtagNicht genügend Speicher / Container-Absturz

hashtagWeiterführende Lektüre

Überblick

Architekturübersicht

Anforderungen

Server-Spezifikationen

Clore.ai Preisinformationen

Voraussetzungen

Schnellstart

Methode 1: Einzelner Docker-Container (empfohlen)

Methode 2: Docker Compose (Multi-Service)

Methode 3: Mit vorkonfigurierten Umgebungsvariablen

Konfiguration

LLM-Anbieter-Optionen

Einbettungskonfiguration

Optionen für Vektor-Datenbanken

Workspace-Konfiguration

Dokumentaufnahme (Ingestion)

GPU-Beschleunigung

Ollama auf demselben Clore.ai-Server ausführen

GPU-Modellleistung auf Clore.ai

Tipps & bewährte Methoden

Best Practices für Dokumentenaufnahme

Kostenmanagement auf Clore.ai

Multi-Benutzer-Einrichtung

KI-Agentenkonfiguration

Leistungsoptimierung

AnythingLLM aktualisieren

Fehlerbehebung

Container startet, aber UI nicht erreichbar

Dokument-Upload schlägt fehl

RAG-Antworten sind von schlechter Qualität / Halluzinieren

Ollama-Verbindung von AnythingLLM schlägt fehl

Nicht genügend Speicher / Container-Absturz

Weiterführende Lektüre