Selbstgehosteter KI-Assistent: Komplette Moltbot Installationsanleitung für Docker

Betreibe deinen eigenen ChatGPT-ähnlichen KI-Assistenten auf WhatsApp, Telegram und Discord mit vollständiger Privatsphäre und Kontrolle

Suchst du nach einem selbstgehosteten KI-Assistenten, der dir die Leistung von ChatGPT, Claude und Gemini bietet, ohne deine Privatsphäre zu opfern? Moltbot ist ein Open-Source KI-Gateway, mit dem du deinen eigenen KI-Chatbot auf Docker bereitstellen und mit WhatsApp, Telegram, Discord, Slack und mehr verbinden kannst.

In dieser umfassenden Anleitung zeige ich dir, wie du Moltbot mit Docker Compose installierst, für maximale Sicherheit konfigurierst und häufige Probleme löst, auf die ich bei meiner eigenen Bereitstellung gestoßen bin.

Was ist Moltbot? Open-Source KI-Assistent für Self-Hosting

Moltbot ist ein Privacy-First KI-Assistent, der vollständig auf deiner eigenen Infrastruktur läuft. Im Gegensatz zu cloudbasierten KI-Diensten bietet dir Moltbot:

Vollständige Datenprivatsphäre - alle Konversationen bleiben auf deinem Server
Multi-Plattform-Unterstützung - WhatsApp, Telegram, Discord, Slack und mehr
Mehrere KI-Modelle - Google Gemini, OpenAI GPT-4, Anthropic Claude, GitHub Copilot
Docker-native Bereitstellung - einfache Installation mit Docker Compose
Volle Anpassbarkeit - erweiterbar mit Plugins, Skills und benutzerdefinierten Tools

Hauptfunktionen

🔒 Privacy-First: Alle Daten bleiben auf deinem Server - keine Drittanbieter-Cloud-Dienste
🌐 Multi-Channel: WhatsApp, Telegram, Discord, Slack und mehr
🤖 Multi-Model: Google Gemini, OpenAI GPT, Anthropic Claude, GitHub Copilot und andere
🛠️ Erweiterbar: Plugins für Browser-Automatisierung, Shell-Zugriff, Gedächtnis und benutzerdefinierte Tools
📱 Mobile-Ready: Volle KI-Funktionen direkt von deinem Handy über WhatsApp
🐳 Docker-Native: Einfache Bereitstellung mit Docker Compose
🔐 Sicher: Eingebautes Sandboxing, Genehmigungs-Workflows und Zugriffskontrollen

Warum Moltbot statt Cloud-KI-Diensten?

Für Anfänger: Einfaches Self-Hosted KI-Setup

Keine KI-API-Kosten: Nutze kostenlose Stufen (Google Gemini) oder dein bestehendes GitHub Copilot Abonnement oder Ollama
Einfache Docker-Installation: Ein einziger docker compose up Befehl zum Starten
WhatsApp KI-Integration: Sprich mit deinem KI-Assistenten, als würdest du einem Freund schreiben
Intelligente Sicherheitsstandards: Funktioniert sofort mit sinnvollen Privatsphäre-Einstellungen
Kein Programmieren erforderlich: Konfiguriere alles über JSON-Dateien

Für Fortgeschrittene: Volle Infrastruktur-Kontrolle

Shell-Zugriff per Chat: Führe Linux-Befehle auf deinem Server über WhatsApp aus
Docker-Container-Management: Steuere Container, prüfe Logs, stelle Dienste remote bereit
Benutzerdefinierte Skills und Plugins: Erweitere mit Python/Node.js Skripten
Browser-Automatisierung: Headless Chromium für Web-Scraping und Testing
Infrastructure as Code: Verwalte dein gesamtes Homelab über WhatsApp

Wie man Moltbot mit Docker Compose installiert (Schritt-für-Schritt)

Voraussetzungen für Self-Hosting Moltbot

Docker und Docker Compose installiert
Ein Google API Key (kostenlose Stufe verfügbar) oder GitHub Copilot Abonnement
Eine Telefonnummer für WhatsApp Web Kopplung

Schnellstart

Klone oder erstelle dein Moltbot-Verzeichnis:

mkdir ~/moltbot && cd ~/moltbot

Erstelle eine docker-compose.yml:

services:
  moltbot-gateway:
    image: moltbot:local
    build:
      context: .
      args:
        CLAWDBOT_DOCKER_APT_PACKAGES: ${CLAWDBOT_DOCKER_APT_PACKAGES}
    user: root
    environment:
      HOME: /home/node
      TERM: xterm-256color
      CLAWDBOT_GATEWAY_TOKEN: ${CLAWDBOT_GATEWAY_TOKEN}
      MOLTBOT_STATE_DIR: /home/node/.moltbot
      CLAWDBOT_STATE_DIR: /home/node/.moltbot
      GOOGLE_GENERATIVE_AI_API_KEY: ${GOOGLE_API_KEY}
    volumes:
      - ${CLAWDBOT_CONFIG_DIR}:/home/node/.moltbot
      - ${CLAWDBOT_WORKSPACE_DIR}:/home/node/clawd
    ports:
      - "${CLAWDBOT_GATEWAY_PORT:-18789}:18789"
      - "${CLAWDBOT_BRIDGE_PORT:-18790}:18790"
    init: true
    restart: unless-stopped
    command:
      [
        "node",
        "dist/index.js",
        "gateway",
        "--bind",
        "${CLAWDBOT_GATEWAY_BIND:-lan}",
        "--port",
        "${CLAWDBOT_GATEWAY_PORT:-18789}"
      ]

Erstelle eine .env Datei:

CLAWDBOT_CONFIG_DIR=./config
CLAWDBOT_WORKSPACE_DIR=./workspace
CLAWDBOT_GATEWAY_PORT=18789
CLAWDBOT_BRIDGE_PORT=18790
CLAWDBOT_GATEWAY_BIND=lan
GOOGLE_API_KEY=dein_google_api_key_hier

Erstelle eine Dockerfile:

FROM node:22-bookworm

# Installiere Bun (erforderlich für Build-Skripte)
RUN curl -fsSL https://bun.sh/install | bash
ENV PATH="/root/.bun/bin:${PATH}"

RUN corepack enable

WORKDIR /app

ARG CLAWDBOT_DOCKER_APT_PACKAGES=""
RUN apt-get update && \
  DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
  ca-certificates curl gnupg lsb-release && \
  mkdir -p /etc/apt/keyrings && \
  curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg && \
  echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
  apt-get update && \
  DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends docker-ce-cli \
    libgbm1 libnss3 libasound2 libxss1 libxtst6 libatk1.0-0 libatk-bridge2.0-0 \
    libc6 libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgcc1 \
    libgdk-pixbuf2.0-0 libglib2.0-0 libgtk-3-0 libnspr4 libpango-1.0-0 \
    libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 libxcomposite1 \
    libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 \
    libxshmfence1 libwayland-client0 libwayland-cursor0 libwayland-egl1 && \
  apt-get clean && \
  rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*

# Klone Moltbot Repository
RUN git clone https://github.com/moltbot/moltbot.git /app

COPY package.json pnpm-lock.yaml pnpm-workspace.yaml .npmrc ./
COPY ui/package.json ./ui/package.json
COPY patches ./patches
COPY scripts ./scripts

RUN pnpm install --frozen-lockfile

COPY . .
RUN CLAWDBOT_A2UI_SKIP_MISSING=1 pnpm build
ENV CLAWDBOT_PREFER_PNPM=1
RUN pnpm ui:install
RUN pnpm ui:build
RUN pnpm dlx playwright install chromium

ENV NODE_ENV=production

USER node

CMD ["node", "dist/index.js"]

Starte Moltbot:

docker compose up -d

Kopple mit WhatsApp:

docker compose exec moltbot-gateway node dist/index.js channels login

Scanne den QR-Code mit WhatsApp auf deinem Handy (Einstellungen → Verknüpfte Geräte → Gerät hinzufügen).

Konfiguration

Grundkonfiguration (`config/moltbot.json`)

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "google/gemini-3-flash-preview"
      }
    }
  },
  "channels": {
    "whatsapp": {
      "dmPolicy": "pairing",
      "allowFrom": ["+1234567890"],
      "groupPolicy": "allowlist"
    }
  },
  "gateway": {
    "bind": "lan"
  },
  "tools": {
    "profile": "safe"
  }
}

Tool-Profile

safe: Nur-Lese-Tools (empfohlen für Anfänger)
standard: Lesen + einfache Schreiboperationen
full: Voller Shell-Zugriff, Docker-Steuerung, Dateibearbeitung

Browser-Konfiguration

Um Web-Browsing ohne API-Keys zu aktivieren:

{
  "browser": {
    "defaultProfile": "clawd",
    "executablePath": "/root/.cache/ms-playwright/chromium-1208/chrome-linux64/chrome",
    "headless": true,
    "noSandbox": true
  }
}

Häufige Probleme & Lösungen

Problem 1: WhatsApp-Verbindung schlägt fehl

Symptom: QR-Code erscheint nicht oder Verbindung bricht ab

Lösung:

# Lösche WhatsApp-Session und koppele neu
docker compose exec moltbot-gateway rm -rf /home/node/.moltbot/channels/whatsapp
docker compose restart moltbot-gateway
docker compose exec moltbot-gateway node dist/index.js channels login

Problem 2: Browser Relay nicht verbunden

Symptom: "Chrome extension relay is running, but no tab is connected"

Lösung: Das passiert, wenn das Standard-Profil chrome (Erweiterungs-basiert) verwendet wird. Wechsele zum clawd Profil (Playwright):

{
  "browser": {
    "defaultProfile": "clawd",
    "executablePath": "/root/.cache/ms-playwright/chromium-1208/chrome-linux64/chrome",
    "headless": true,
    "noSandbox": true
  }
}

Problem 3: Zugriff verweigert auf Docker Socket

Symptom: "Cannot connect to Docker daemon"

Lösung: Mounte den Docker Socket und führe als root aus:

services:
  moltbot-gateway:
    user: root
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

Problem 4: Chromium startet nicht

Symptom: "Failed to start Chrome CDP on port 18800"

Lösung: Aktiviere noSandbox-Modus (erforderlich, wenn als root ausgeführt):

{
  "browser": {
    "noSandbox": true
  }
}

Problem 5: Port 18789 bereits belegt

Symptom: "Address already in use"

Lösung: Ändere den Gateway-Port in .env:

CLAWDBOT_GATEWAY_PORT=18790

Problem 6: Sandbox Image fehlt

Symptom: "Sandbox base image missing: moltbot-sandbox:bookworm-slim"

Lösung: Baue das Sandbox Image, wenn von moltbot doctor aufgefordert, oder deaktiviere Sandboxing:

{
  "agents": {
    "defaults": {
      "sandbox": {
        "mode": "off"
      }
    }
  }
}

Plugins & Skills

Eingebaute Plugins

WhatsApp (`@moltbot/whatsapp`)

Verbinde dich mit WhatsApp Web für persönliche und Gruppen-Nachrichten.

docker compose exec moltbot-gateway node dist/index.js channels login

Memory (`@moltbot/memory`)

Dauerhaftes Konversationsgedächtnis über Sitzungen hinweg.

Beispiel: "Erinnere dich, dass meine Server-IP 192.168.1.100 ist"

Copilot Proxy (`@moltbot/copilot-proxy`)

Nutze GitHub Copilot Modelle kostenlos (erfordert Copilot Abonnement).

{
  "plugins": {
    "entries": {
      "copilot-proxy": {
        "enabled": true
      }
    }
  }
}

Skills

Skills sind leichtgewichtige Skripte, die Moltbots Fähigkeiten erweitern.

Local Places (`local-places`)

Suche nach Restaurants, Cafés etc. in der Nähe via Google Places API.

Anforderungen:

uv (Python-Paketmanager)
GOOGLE_PLACES_API_KEY Umgebungsvariable

Beispiel: "Finde Pizzerien in meiner Nähe"

Summarize (`summarize`)

Extrahiere und fasse Inhalte von URLs, Podcasts und Videos zusammen.

Anforderungen:

summarize CLI-Tool

Beispiel: "Fasse dieses YouTube-Video zusammen: https://youtube.com/watch?v=..."

Model Usage (`model-usage`)

Verfolge KI-Modell-Nutzung und Kosten (nur macOS, erfordert CodexBar).

Beispiel: "Zeige mir meine Modellnutzung für heute"

Skills installieren

Skills werden automatisch aus dem gebündelten Skills-Verzeichnis erkannt. Prüfe verfügbare Skills:

docker compose exec moltbot-gateway node dist/index.js skills list

Installiere fehlende Abhängigkeiten nach Bedarf (z.B. uv für local-places).

Sicherheits-Best-Practices

✅ DO

Nutze DM-Pairing für unbekannte Absender (dmPolicy: "pairing")
Führe Gruppensitzungen in Docker-Sandboxen aus (sandbox.mode: "non-main")
Nutze Tailscale für Fernzugriff statt Ports freizugeben
Überprüfe regelmäßig moltbot doctor Ausgabe
Halte Erlaubnislisten aktuell (allowFrom in Kanal-Konfig)
Nutze exec.ask: "on-miss" um neue Shell-Befehle zu genehmigen

⚠️ DON'T

Port 18789 öffentlich freigeben (nutze bind: "lan")
Shell-Zugriff gewähren ohne die Risiken zu verstehen
Unverifizierte Skills installieren aus unbekannten Quellen
dmPolicy: "open" nutzen ohne Erlaubnislisten

Fortgeschrittene Anwendungsfälle

1. Server-Management via WhatsApp

Du: "Prüfe den Status meines Traefik-Containers"
Moltbot: "Traefik läuft (up 3 days)"

Du: "Zeige mir die letzten 20 Zeilen der Gitea-Logs"
Moltbot: [zeigt Logs an]

Du: "Starte den job_map Container neu"
Moltbot: "Container erfolgreich neu gestartet"

2. Website-Bereitstellung

Du: "Erstelle einen neuen Nginx-Container in ~/docker/test-site mit Traefik-Labels für test.example.com"
Moltbot: [erstellt docker-compose.yml, konfiguriert Traefik, stellt bereit]

3. Web-Recherche

Du: "Surfe zur Traefik-Dokumentation und sage mir, wie man Basic-Auth-Middleware hinzufügt"
Moltbot: [öffnet Browser, liest Doku, gibt Antwort]

4. Dateimanagement

Du: "Was ist der größte Ordner in ~/docker?"
Moltbot: "Der größte Ordner ist ~/docker/nextcloud (45GB)"

Fehlerbehebung

Gateway-Status prüfen

docker compose exec moltbot-gateway node dist/index.js health

Logs ansehen

docker compose logs -f moltbot-gateway

Diagnose ausführen

docker compose exec moltbot-gateway node dist/index.js doctor

Konfiguration zurücksetzen

docker compose exec moltbot-gateway node dist/index.js reset

Fazit: Baue deinen eigenen privaten KI-Assistenten noch heute

Moltbot ist die perfekte Lösung für alle, die die Leistung von ChatGPT, Claude oder Gemini wollen, ohne Privatsphäre zu opfern oder monatliche Abgebühren zu zahlen. Mit Docker Compose kannst du deinen eigenen selbstgehosteten KI-Assistenten in wenigen Minuten am Laufen haben.

Ob du ein Homelab-Enthusiast, ein datenschutzbewusster Entwickler oder jemand bist, der sein Server-Management über WhatsApp automatisieren möchte - Moltbot gibt dir die Werkzeuge, um einen wirklich persönlichen KI-Assistenten zu bauen.

Bereit loszulegen? Folg der Installationsanleitung oben und du hast deinen eigenen KI-Assistenten in weniger als 30 Minuten auf deiner Infrastruktur laufen.

Zusätzliche Ressourcen

Offizielle Dokumentation: docs.molt.bot
GitHub Repository: github.com/moltbot/moltbot
Community Discord: discord.gg/moltbot

Über den Autor: Diese Anleitung basiert auf meiner persönlichen Erfahrung beim Deployen von Moltbot auf meinem Homelab-Server. Ich habe alle Probleme, auf die ich gestoßen bin, und ihre Lösungen dokumentiert, um dir zu helfen, die gleichen Fallstricke zu vermeiden. Wenn du diese Anleitung hilfreich fandest, teile sie gerne mit anderen, die von einem selbstgehosteten KI-Assistenten profitieren könnten.

Keywords: Self-hosted AI, Docker AI Assistant, WhatsApp AI Bot, Privacy-First AI, Open-Source ChatGPT Alternative, Moltbot Installation, AI Gateway, Docker Compose AI

Lizenz

Moltbot ist Open-Source-Software lizenziert unter der MIT License.

Built with ❤️ by the Moltbot community

Selbstgehosteter KI-Assistent: Moltbot