Bitdoze-Logo

Memoh: KI-Agenten-Plattform mit Docker Compose deployen

Deploye Memoh mit Docker Compose oder Dokploy und hoste die Multi-Agenten-KI-Plattform selbst. Behandelt das Memoh-1.0-Setup, pgvector-Memory, Channels und Security-Hardening.

Dragos

Aktualisiert Veröffentlicht 67 Min. Lesezeit

Dashboard der Memoh-KI-Agenten-Plattform auf einem self-hosted Server mit Docker Compose

Disclosure: Dieser Guide enthält Referral-Links. Wenn du über sie kaufst, erhalte ich möglicherweise eine Provision – ohne zusätzliche Kosten für dich.

Aktualisiert für Memoh 1.0 (November 2026). Service-Layout, Config-Schema und Images haben sich seit der Erstveröffentlichung dieses Guides im März stark geändert. Wenn du damals deployt hast, ist dein Stack veraltet. Alles Folgende wurde gegen v1.0.2 neu aufgebaut.

Memoh ist eine self-hosted Multi-Agenten-KI-Plattform: mehrere KI-Agenten in einem Docker-Compose-Stack, jeder in einem eigenen containerd-Workspace, mit persistentem Memory, MCP-Tool-Zugriff und Messaging-Channels wie Telegram, Slack und Discord. Ich zeige drei Wege, Memoh zu deployen (One-Click-Installer, Dokploy, klassisches Docker Compose), verifiziere danach das Deployment, lege Backups an und riegle das Ganze ab. Das Projekt steht bei 2,8k Stars auf GitHub unter AGPL-3.0 – du kannst also jede Zeile lesen, die auf deiner Box läuft.

Was ist Memoh?

Memoh ist eine Open-Source-Multi-Agenten-Plattform, gebaut mit Go und Vue 3. Du erstellst Agenten (die UI nennt sie Bots), von denen jeder in einem eigenen isolierten containerd-Workspace mit separatem Dateisystem, Netzwerk und Prozessbaum läuft. Agenten behalten persistentes Memory über Sessions hinweg, erreichen externe Tools über MCP (Model Context Protocol) und erkennen einzelne Nutzer in Gruppenchats – inklusive Kontextverfolgung pro Person. Sie können über Telegram, Slack, Discord, Feishu (Lark), DingTalk, WeCom, WeChat, QQ und LINE kommunizieren, plus die eingebaute Web-UI und eine Desktop-App, die sich remote mit deinem Server verbinden kann. Wenn du den Stack lieber gar nicht selbst betreibst, ist Memoh Cloud die gehostete Option.

Privilegierter Container

Der Memoh-Server-Container läuft mit privileged: true und pid: host, weil er containerd einbettet, um Agent-Workspaces zu verwalten. Deploye das nur auf Servern, denen du vertraust und die du kontrollierst, und betreibe es nicht zusammen mit sensiblen Workloads auf derselben Box. Ein kompromittierter Agent-Workspace ist ein Incident auf Host-Ebene.

Was sich in Memoh 1.0 geändert hat

Wenn du den ursprünglichen März-Guide gelesen hast: Der Stack, den du gebaut hast, ist nicht mehr der aktuelle. Die Kurzversion dessen, was sich zwischen v0.3 und v1.0.2 (veröffentlicht 2026-11-08) bewegt hat:

  • pgvector ersetzt Qdrant. Memory-Embeddings liegen jetzt in einem zweiten Postgres-Container (pgvector/pgvector:pg18, Datenbank memoh_vector). Der qdrant-Service ist weg.
  • Der Agent läuft in-process. Der eigenständige memohai/agent-Service ist weg; die AI-Agent-Loop läuft innerhalb des server-Containers. Die alten memohai/agent- und memohai/mcp-Images sind auf dem Stand von März 2026 eingefroren.
  • Ein neuer channel-Service besitzt die Telegram-/Discord-/Webhook-Verbindungen und spricht über internes RPC mit dem Server, abgesichert durch ein verpflichtendes MEMOH_INTERNAL_RPC_SHARED_SECRET. Ohne es verweigert Compose den Start.
  • Channels wurden verschoben. Der eingebaute E-Mail-Support wurde in v0.21.0 entfernt. Slack, DingTalk, WeCom, WeChat, QQ und LINE gesellten sich zu Telegram, Discord und Feishu.
  • Es gibt einen One-Click-Installer (curl -fsSL https://memoh.sh | sh) – der von Upstream empfohlene Weg. Das Repo ist nach felinics/Memoh umgezogen.
  • ACP-Support erlaubt es dir, echte Coding-Agenten (Claude Code, Codex, OpenCode) in Agent-Workspaces zu hosten.

Upgrade vom alten Stack?

Stand November 2026 gibt es keine dokumentierte In-Place-Migration vom alten Qdrant-basierten Layout zu pgvector. Exportiere alles, was du behalten willst (Chat-Verläufe, Configs), und installiere frisch. Richte v1.0.2-Images nicht auf Volumes aus März und hoffe auf das Beste.

Kernfeatures

Feature Was es macht
Workspaces pro Agent Jeder Agent bekommt seine eigene containerd-Sandbox mit separatem Dateisystem, Netzwerk und Prozessbaum
Persistentes Memory Hybride Abfrage: pgvector-Embeddings für Semantik, Postgres für Struktur und Keyword-Suche
Neun Messaging-Channels Telegram, Slack, Discord, Feishu (Lark), DingTalk, WeCom, WeChat, QQ, LINE
MCP-Tool-Anbindungen HTTP-, SSE- und Stdio-Server: Browser, Websuche, Dateisysteme, App-APIs
ACP-Coding-Agenten Claude Code, Codex, OpenCode oder Hermes in einem Agent-Workspace ausführen
Plugin-Marketplace Supermarket-Apps, Skills, Hooks, geplante Tasks mit Per-Run-Sessions
Web-UI und Desktop-App Vue-3-Dashboard mit Streaming, Dateimanager und visueller Config; nativer Desktop-Client
  • Mehrere KI-Agenten aus einem einzigen Dashboard erstellen und verwalten
  • Isolation auf Container-Ebene pro Agent via containerd
  • Hybrides Memory: pgvector-Embeddings plus Postgres-Struktur und Keyword-Retrieval
  • MCP-Support zum Anbinden externer Tools (HTTP, SSE, Stdio)
  • Echte Coding-Agenten über ACP hosten (Claude Code, Codex, OpenCode)
  • Geplante Tasks und Heartbeat-basierte autonome Aktionen
  • Funktioniert mit jedem OpenAI-kompatiblen, Anthropic- oder Google-AI-Provider
  • Rollenbasierte Zugriffskontrolle mit Ownership-Transfer
  • Plattformübergreifendes Identity-Binding über alle Channels

MCP ist die Tool-Schicht. Verbinde eine Such-API, einen Browser oder ein App-Gateway, und jeder Agent auf der Box kann es nutzen. Für App-Integrationen mag ich Composio MCP, das Agenten mit über 1.500 Apps verbindet. Für rohen Web-Zugriff erspart dir eine API wie TinyFish (Websuche, Fetch- und Browser-Endpunkte unter einem Key) das Schreiben eines eigenen Scrapers.

Memoh-Architektur im Überblick

Memoh-Docker-Compose-Service-Topologie mit postgres-, pgvector-, migrate-, server-, channel- und web-Containern sowie deren Volumes und Ports

Memoh fährt sechs Kernservices unter Docker Compose, plus zwei optionale, die du über Compose-Profiles aktivieren kannst:

Service Image Rolle
postgres postgres:18-alpine System of Record: Nutzer, Agenten, Channels, Konfiguration
pgvector pgvector/pgvector:pg18 Memory-Embeddings (Datenbank memoh_vector)
migrate memohai/server:1.0.2 One-Shot: führt memoh-server migrate up aus und beendet sich
server memohai/server:1.0.2 Go-API, in-process AI-Agent, eingebettetes containerd (privileged)
channel memohai/server:1.0.2 Channel-Worker: memoh-channel serve, Webhooks und IM-Connectoren
web memohai/web:1.0.2 Vue-3-UI hinter Nginx, mit zwei Upstreams (server und channel)
webhook-tunnel (optional) cloudflare/cloudflared:latest Quick Tunnel für Channel-Webhooks (--profile webhook-tunnel)
connect-it (optional) ghcr.io/felinics/connect-it:0.3.1 OAuth-Connector-Gateway für GitHub, Notion und Co. (--profile connectors)

Die Startreihenfolge wird über Health Checks erzwungen, nicht über Glück. PostgreSQL und pgvector bestehen zuerst ihre pg_isready-Checks. Der migrate-Service spielt dann die Datenbank-Migrationen ein und beendet sich mit Exit 0 – das ist das Gate für den Server-Start (condition: service_completed_successfully). Sobald der Server seinen eigenen Health Check besteht, startet channel, und web kommt zuletzt hoch, wartend auf server und channel. Dieses migrate-Gate ist der Grund, warum Schema-Updates beim Pull neuer Images automatisch anlaufen. Es bedeutet auch: Eine fehlerhafte Migration stoppt den Stack am Gate – server startet nie bei einem Non-Zero-Migrate-Exit, und das ist genau das, was du willst. Wenn das passiert, ist docker compose logs migrate das einzige Log, das zählt.

Der channel-Split verdient einen eigenen Absatz, weil er die größte strukturelle Änderung in 1.0 ist. Der Server besitzt State, die API und die Agent-Runtime. Der Channel-Worker besitzt die langlebigen Webhook- und IM-Verbindungen und ruft über internes RPC auf den Ports 9090/9091 zurück in den Server. Dieses RPC wird mit MEMOH_INTERNAL_RPC_SHARED_SECRET authentifiziert, den beide Prozesse teilen müssen. Kein Secret oder unterschiedliche Secrets bedeuten: Der Channel-Worker registriert sich nie, und dein Telegram-Bot bleibt stumm.

Warum zwei Postgres-Container?

Eine Datenbank hält das System of Record (Nutzer, Agenten, Config). Die andere ist ein Standard-Postgres-Image mit der pgvector-Erweiterung (Datenbank memoh_vector), das Embedding-Vektoren speichert. Sie getrennt zu halten bedeutet: Vector-Index-Churn bläht nicht deine Hauptdatenbank auf, und du kannst beide unabhängig voneinander sichern, wiederherstellen oder skalieren. Das Volume ist pgvector_data, und der Health Check ist ein schlichtes pg_isready -U memoh -d memoh_vector (der fragile Qdrant-TCP-Hack aus dem alten Stack ist Geschichte). Wenn du direkt an pgvector herumspielen willst, deploye pgvector und pgAdmin auf Docker und zeige mit pgAdmin auf den Container.

Voraussetzungen

Prüfe zuerst das Tooling:

bash
docker --version          # 24+ is fine
docker compose version    # must be Compose v2 (the docker compose plugin)

Wenn docker compose version fehlschlägt, hast du entweder das alte docker-compose-Python-Binary oder gar kein Compose-Plugin. Installiere das Compose-Plugin der Docker Engine aus dem Paket deiner Distro (docker-compose-plugin auf Debian/Ubuntu), bevor du weitermachst. Alles in diesem Guide setzt Compose-v2-Semantik voraus: depends_on mit condition:, :?-Interpolations-Guards und Compose-Profiles.

  • Ein Linux-VPS oder Dedicated Server mit installiertem Docker und Docker Compose v2
  • Realistisch 8 GB RAM (Upstream setzt mem_limit: 8g und GOMEMLIMIT: 7GiB auf dem Server-Container)
  • Root- oder Sudo-Zugriff (für den privilegierten Container-Modus erforderlich)
  • Ein API-Key eines OpenAI-kompatiblen, Anthropic- oder Google-AI-Providers
  • Ein Domainname, wenn du HTTPS über einen Reverse Proxy willst

Du kannst den Stack in 4 GB quetschen, indem du MEMOH_SERVER_MEMORY_LIMIT senkst und GOMEMLIMIT auf grob 85 % davon setzt – aber das ist ein Lab-Setup, keine komfortable Untergrenze. Jeder Agent-Workspace legt Overhead auf den Basis-Stack obendrauf, und ich würde keine Idle-RSS-Zahl nennen, ohne sie vorher auf deiner eigenen Box gemessen zu haben.

Diese 8-GB-Realität schiebt dich von einer Hetzner-Box der CX32-Klasse auf eine Maschine der CX42- oder CPX31-Klasse, in der Größenordnung von 8 bis 15 EUR/Monat. Nicht schlecht für eine Flotte von Always-on-Agenten mit echten Workspaces.

Hetzner Cloud jetzt testen Hostinger VPS testen

VPS-Preise sind 2026 überall gestiegen. Wenn du eine gemietete Box gerade überdenkst, schau dir an, was sich geändert hat und wann ein Mini-PC gewinnt.

Option 1: Memoh mit dem One-Click-Installer installieren

Das ist der schnellste Weg und der von Upstream empfohlene. Auf einer sauberen Box mit installiertem Docker:

bash
curl -fsSL https://memoh.sh | sh

Der Installer übernimmt Config-Generierung, .env-Secrets (inklusive RPC-Secret), Connect-It-Provisioning sowie Upgrade-/Reinstall-Modi. Er pinnt die Image-Tags außerdem auf das Release, das er installiert – anders als die :latest-Tags in selbst zusammengestellten Compose-Dateien. In der Praxis schreibt er config.toml und eine .env mit den generierten Secrets und fährt dann den Compose-Stack unter Docker hoch. Wenn er fertig ist, bekommst du einen Login-Prompt im Terminal und einen Stack, den du wie jeden anderen mit docker compose ps inspizieren kannst.

Nützliche Varianten:

bash
# Silent install (no prompts)
curl -fsSL https://memoh.sh | sh -s -- -y

# Pin a specific version
curl -fsSL https://memoh.sh | sh -s -- --version v1.0.2

# Slow network or China mirror
curl -fsSL https://memoh.sh | USE_CN_MIRROR=true sh

Defaults im Silent-Modus

Der Silent-Modus (-y) kommt mit dem Admin-Login admin/admin123 und dem PostgreSQL-Passwort memoh123. Ändere beides, bevor die Box irgendwo erreichbar ist. Der interaktive Modus zwingt dich immerhin dazu, sie dir anzusehen.

CN-Mirror auch für manuelle Installationen

Falls Image-Pulls in Timeouts laufen, ist das Installer-Flag oben der einfache Fix. Für manuelle Compose-Läufe setze registry = "memoh.cn" unter [container] in config.toml und füge das docker/docker-compose.cn.yml-Overlay aus dem Repo hinzu. Generell profitieren langsame Netzwerke davon.

Egal welchen Weg du wählst: Führe die Smoke-Tests in Dein Memoh-Deployment verifizieren aus, bevor du es als erledigt abhakst.

Option 2: Memoh mit Dokploy deployen

Dokploy kümmert sich für dich um Domains und SSL und ist das, was ich nutze, wenn der Stack hinter einer echten Domain sitzt. Falls du es noch nicht eingerichtet hast, folge zuerst dem Dokploy-Installations-Guide.

Schritt 1: Die Config-Datei erstellen

SSH auf deinen Server und hol dir das Config-Template aus dem Repo:

bash
mkdir -p /opt/memoh && cd /opt/memoh
git clone --depth 1 --recurse-submodules --shallow-submodules https://github.com/felinics/Memoh.git upstream
cp upstream/conf/app.docker.toml config.toml
mkdir -p conf/providers
cp -r upstream/conf/providers/. conf/providers/

Kopiere das Template, statt eine Config-Datei von Hand zu bauen. Das Schema hat sich in 1.0 komplett geändert (neue [channel]-, [internal_rpc]-, [container]- und [pgvector]-Sektionen; die alten [mcp]-, [qdrant]- und [agent_gateway]-Blöcke existieren nicht mehr), und das Template ist das Einzige, das garantiert zu den Images passt. Zwei Fallstricke beim Klonen: Ein schlichtes git clone verpasst die Submodules, und die von GitHub automatisch generierten Source-Archive sind nicht buildbar. Wenn du nur das Config-Template willst, sind die Submodules weniger kritisch – aber behalt die Gewohnheit bei.

Generiere jetzt echte Secrets und bearbeite config.toml:

bash
openssl rand -base64 32   # -> [auth] jwt_secret
openssl rand -base64 16   # -> [postgres] password

Drei Dinge müssen vor dem ersten Boot geändert werden:

  1. [admin]: Username, password und E-Mail. Das Default-Passwort ist admin123.
  2. [auth]: jwt_secret. Füge die Ausgabe von openssl rand -base64 32 ein.
  3. [postgres]: password. Füge die Ausgabe von openssl rand -base64 16 ein. Sie muss mit POSTGRES_PASSWORD in den nächsten Schritten übereinstimmen.

Wissenswert, solange du in der Datei bist: [container] hat einen registry-Schalter ("memoh.cn" für den CN-Mirror) und das Workspace-Image (memohai/workspace:debian-latest); [internal_rpc] und [webhook_tunnel] konfigurieren den Channel-Worker und den optionalen Cloudflare-Tunnel; [pgvector] ist nur relevant, wenn du die Vector-Datenbank mit einem separaten Passwort betreibst. Patterns, um diese Secrets aus der Versionskontrolle zu halten, findest du unter Secrets in Docker Compose handhaben.

Schritt 2: Den Dokploy-Service anlegen

  1. Öffne dein Dokploy-Projekt
  2. Klick Add Service und wähle Compose
  3. Benenne ihn memoh

Schritt 3: Compose-Datei einfügen und Environment setzen

Füge das in den Dokploy-Compose-Editor ein. Es ist das Upstream-1.0.2-Service-Layout, angepasst für Dokploy: keine publizierten Ports (der Proxy übernimmt das Routing) und ein externes dokploy-network:

yaml
name: "memoh"
services:
  postgres:
    image: postgres:18-alpine
    container_name: memoh-postgres
    environment:
      POSTGRES_DB: memoh
      POSTGRES_USER: memoh
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD is required}
    volumes:
      - postgres_data:/var/lib/postgresql
      - /etc/localtime:/etc/localtime:ro
    expose:
      - "5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U memoh"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    networks:
      - dokploy-network

  pgvector:
    image: pgvector/pgvector:pg18
    container_name: memoh-pgvector
    environment:
      POSTGRES_DB: memoh_vector
      POSTGRES_USER: memoh
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD is required}
    volumes:
      - pgvector_data:/var/lib/postgresql
      - /etc/localtime:/etc/localtime:ro
    expose:
      - "5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U memoh -d memoh_vector"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    networks:
      - dokploy-network

  migrate:
    image: memohai/server:1.0.2
    container_name: memoh-migrate
    entrypoint: ["/app/memoh-server", "migrate", "up"]
    volumes:
      - /opt/memoh/config.toml:/app/config.toml:ro
      - memoh_data:/opt/memoh/data
      - /etc/localtime:/etc/localtime:ro
    depends_on:
      postgres:
        condition: service_healthy
      pgvector:
        condition: service_healthy
    restart: "no"
    networks:
      - dokploy-network

  server:
    image: memohai/server:1.0.2
    container_name: memoh-server
    privileged: true
    pid: host
    mem_limit: 8g
    environment:
      MEMOH_INTERNAL_RPC_SHARED_SECRET: ${MEMOH_INTERNAL_RPC_SHARED_SECRET:?MEMOH_INTERNAL_RPC_SHARED_SECRET is required}
      GOMEMLIMIT: 7GiB
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - /opt/memoh/config.toml:/app/config.toml:ro
      - /opt/memoh/conf/providers:/app/conf/providers:ro
      - containerd_data:/var/lib/containerd
      - server_cni_state:/var/lib/cni
      - memoh_data:/opt/memoh/data
      - /etc/localtime:/etc/localtime:ro
    expose:
      - "8080"
      - "1455"
      - "9090"
    depends_on:
      migrate:
        condition: service_completed_successfully
      pgvector:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "wget --spider -q http://127.0.0.1:8080/health || exit 1"]
      interval: 30s
      timeout: 5s
      retries: 5
    stop_grace_period: 45s
    restart: unless-stopped
    networks:
      - dokploy-network

  channel:
    image: memohai/server:1.0.2
    container_name: memoh-channel
    entrypoint: ["/app/memoh-channel", "serve"]
    environment:
      MEMOH_INTERNAL_RPC_SHARED_SECRET: ${MEMOH_INTERNAL_RPC_SHARED_SECRET:?MEMOH_INTERNAL_RPC_SHARED_SECRET is required}
    volumes:
      - /opt/memoh/config.toml:/app/config.toml:ro
      - /etc/localtime:/etc/localtime:ro
    expose:
      - "8081"
      - "9091"
    depends_on:
      server:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "wget --spider -q http://127.0.0.1:8081/health || exit 1"]
      interval: 30s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    networks:
      - dokploy-network

  web:
    image: memohai/web:1.0.2
    container_name: memoh-web
    environment:
      MEMOH_SERVER_UPSTREAM: memoh-server:8080
      MEMOH_CHANNEL_UPSTREAM: memoh-channel:8081
    expose:
      - "8082"
    depends_on:
      server:
        condition: service_healthy
      channel:
        condition: service_healthy
    restart: unless-stopped
    networks:
      - dokploy-network

networks:
  dokploy-network:
    external: true

volumes:
  postgres_data:
  pgvector_data:
  containerd_data:
  memoh_data:
  server_cni_state:

Generiere dann das Shared Secret und setze die Environment-Werte im Environment-Tab des Dokploy-Services (Dokploy schreibt sie in eine .env neben der Compose-Datei, gegen die sich die ${...}-Platzhalter auflösen):

bash
openssl rand -hex 32   # -> MEMOH_INTERNAL_RPC_SHARED_SECRET
openssl rand -base64 16   # -> POSTGRES_PASSWORD (same value as [postgres] password in config.toml)
Variable Wert
MEMOH_INTERNAL_RPC_SHARED_SECRET Ausgabe von openssl rand -hex 32
POSTGRES_PASSWORD wie [postgres] password in config.toml

Pflicht: RPC-Secret

Die Compose-Datei verweigert ohne MEMOH_INTERNAL_RPC_SHARED_SECRET den Start. Sowohl server als auch channel nutzen den :?-Guard, eine fehlende Variable bricht also mit MEMOH_INTERNAL_RPC_SHARED_SECRET is required ab, statt einen halb gepairten Stack zu booten. Das ist der häufigste Deploy-Fehler seit 1.0 überhaupt. Persistiere das Secret und verwende es über Recreates hinweg wieder: Es authentifiziert das Server-Channel-RPC, und eine Rotation bricht das Pairing.

Hinweise zum Dokploy-Setup

  • Alle Services nutzen expose statt ports; Dokploys Proxy übernimmt das externe Routing. Schau dir wie man eine Docker-Compose-App in Dokploy deployt an, falls der Workflow neu für dich ist.
  • config.toml wird von /opt/memoh/config.toml auf dem Host gemountet. Das Datenbankpasswort muss sowohl in der Config-Datei als auch in POSTGRES_PASSWORD übereinstimmen. Wenn du ein separates PGVECTOR_PASSWORD setzt, lass auch die [pgvector]-Sektion dazu passen.
  • Der Server-Container braucht privileged: true und pid: host, damit containerd Agent-Workspaces verwalten kann.
  • mem_limit: 8g und GOMEMLIMIT: 7GiB sind die Upstream-Defaults. Wenn du das Limit senkst, halte GOMEMLIMIT bei grob 85 % davon.

Schritt 4: Domain und Port

Erstelle eine Domain in Dokploy und mappe sie auf den web-Service auf Port 8082. Öffne nach dem Deploy https://your-domain.com und logge dich ein.

Exponiere die anderen Ports nicht. Die komplette Default-Portliste, damit du weißt, was geschlossen bleiben muss: 8082 (Web, der Einzige, den du veröffentlichst), 8080 und 1455 (Server-API und Display), 30000/udp (WebRTC-Remote-Display), 8421 (Connect-It-Admin, nur falls aktiviert) und 9090/9091 (internes RPC, niemals veröffentlichen). Zum Firewall-Verhalten bei publizierten Ports: Docker umgeht deine Firewall standardmäßig, also steuere die Exposition auf Compose-Ebene.

Sicherheit

Ändere alle Default-Passwörter vor dem Deploy. Der Admin-Default ist admin/admin123, und der Silent-Modus des One-Click-Installers setzt das Postgres-Passwort memoh123 obendrauf. Rotiere das JWT-Secret und schütze .env. Falls du einen anderen Reverse Proxy als Dokploy brauchst, funktioniert Traefik in Docker gut.

SSE und HTTP/2

Memoh streamt massig Server-Sent Events. Wenn dein Reverse Proxy auf HTTP/1.1 downgraded, können die grob sechs Verbindungen pro Origin des Browsers durch SSE-Long-Pins erschöpft werden, und die UI fängt an zu hängen (Upstream-Issue #822). Der Web-Container bringt genau dafür einen auskommentierten HTTPS/HTTP2-Listener auf 8443 mit. Entweder liefere HTTP/2 vom Proxy aus oder aktiviere diesen Listener – und schalte Proxy-Buffering für SSE-Routen ab.

Option 3: Memoh mit Docker Compose deployen (Standalone)

Das ist der Weg, bei dem du jede Zeile besitzt. Er funktioniert auf jeder Linux-Box mit Docker.

Schritt 1: Projektverzeichnis und Config

bash
mkdir -p /opt/memoh && cd /opt/memoh
git clone --depth 1 --recurse-submodules --shallow-submodules https://github.com/felinics/Memoh.git upstream
cp upstream/conf/app.docker.toml config.toml
mkdir -p conf/providers
cp -r upstream/conf/providers/. conf/providers/

Bearbeite config.toml und ändere dieselben drei Keys wie im Dokploy-Pfad: [admin]-Credentials, [auth] jwt_secret und [postgres] password.

Schritt 2: Secrets und die .env-Datei generieren

Du brauchst drei Secrets:

bash
openssl rand -base64 32   # jwt_secret -> config.toml [auth]
openssl rand -hex 32      # MEMOH_INTERNAL_RPC_SHARED_SECRET -> .env
openssl rand -base64 16   # postgres password -> config.toml [postgres] + .env

Schreibe die .env neben deine Compose-Datei:

bash
cat > .env << 'EOF'
POSTGRES_PASSWORD=YOUR_DB_PASSWORD
MEMOH_INTERNAL_RPC_SHARED_SECRET=YOUR_RPC_SECRET
EOF

POSTGRES_PASSWORD muss mit [postgres] password in config.toml übereinstimmen. Das RPC-Secret authentifiziert das Server-Channel-Paar: Persistiere es und verwende es über Recreates hinweg wieder. Es mitten im Betrieb zu rotieren bricht das Pairing, bis beide Services mit dem neuen Wert neustarten.

Secrets auf der Platte

.env und config.toml enthalten produktive Credentials. Halte beide aus der Versionskontrolle und schränke die Berechtigungen ein (chmod 600 .env config.toml). Für das große Ganze rund um Compose-Secrets siehe Docker-Compose-Secrets: Was funktioniert und sichere Alternativen.

Schritt 3: Die Compose-Datei erstellen

yaml
name: "memoh"
services:
  postgres:
    image: postgres:18-alpine
    container_name: memoh-postgres
    environment:
      POSTGRES_DB: memoh
      POSTGRES_USER: memoh
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD is required}
    volumes:
      - postgres_data:/var/lib/postgresql
      - /etc/localtime:/etc/localtime:ro
    expose:
      - "5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U memoh"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    networks:
      - memoh-network

  pgvector:
    image: pgvector/pgvector:pg18
    container_name: memoh-pgvector
    environment:
      POSTGRES_DB: memoh_vector
      POSTGRES_USER: memoh
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD is required}
    volumes:
      - pgvector_data:/var/lib/postgresql
      - /etc/localtime:/etc/localtime:ro
    expose:
      - "5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U memoh -d memoh_vector"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    networks:
      - memoh-network

  migrate:
    image: memohai/server:1.0.2
    container_name: memoh-migrate
    entrypoint: ["/app/memoh-server", "migrate", "up"]
    volumes:
      - ./config.toml:/app/config.toml:ro
      - memoh_data:/opt/memoh/data
      - /etc/localtime:/etc/localtime:ro
    depends_on:
      postgres:
        condition: service_healthy
      pgvector:
        condition: service_healthy
    restart: "no"
    networks:
      - memoh-network

  server:
    image: memohai/server:1.0.2
    container_name: memoh-server
    privileged: true
    pid: host
    mem_limit: ${MEMOH_SERVER_MEMORY_LIMIT:-8g}
    environment:
      MEMOH_INTERNAL_RPC_SHARED_SECRET: ${MEMOH_INTERNAL_RPC_SHARED_SECRET:?MEMOH_INTERNAL_RPC_SHARED_SECRET is required}
      GOMEMLIMIT: ${MEMOH_GOMEMLIMIT:-7GiB}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - ./config.toml:/app/config.toml:ro
      - ./conf/providers:/app/conf/providers:ro
      - containerd_data:/var/lib/containerd
      - server_cni_state:/var/lib/cni
      - memoh_data:/opt/memoh/data
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "8080:8080"
      - "1455:8080"
      - "30000:30000/udp"
    depends_on:
      migrate:
        condition: service_completed_successfully
      pgvector:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "wget --spider -q http://127.0.0.1:8080/health || exit 1"]
      interval: 30s
      timeout: 5s
      retries: 5
    stop_grace_period: 45s
    restart: unless-stopped
    networks:
      - memoh-network

  channel:
    image: memohai/server:1.0.2
    container_name: memoh-channel
    entrypoint: ["/app/memoh-channel", "serve"]
    environment:
      MEMOH_INTERNAL_RPC_SHARED_SECRET: ${MEMOH_INTERNAL_RPC_SHARED_SECRET:?MEMOH_INTERNAL_RPC_SHARED_SECRET is required}
    volumes:
      - ./config.toml:/app/config.toml:ro
      - /etc/localtime:/etc/localtime:ro
    expose:
      - "8081"
      - "9091"
    depends_on:
      server:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "wget --spider -q http://127.0.0.1:8081/health || exit 1"]
      interval: 30s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    networks:
      - memoh-network

  web:
    image: memohai/web:1.0.2
    container_name: memoh-web
    environment:
      MEMOH_SERVER_UPSTREAM: memoh-server:8080
      MEMOH_CHANNEL_UPSTREAM: memoh-channel:8081
    ports:
      - "8082:8082"
    depends_on:
      server:
        condition: service_healthy
      channel:
        condition: service_healthy
    restart: unless-stopped
    networks:
      - memoh-network

volumes:
  postgres_data:
  pgvector_data:
  containerd_data:
  memoh_data:
  server_cni_state:

networks:
  memoh-network:
    driver: bridge

Ein paar Operator-Notizen, die in diese Datei eingebaut sind: stop_grace_period: 45s auf dem Server gibt Workspaces Zeit zum Checkpointen, und v0.21+ nimmt unterbrochene Sessions nach einem Graceful Shutdown wieder auf. mem_limit ist über MEMOH_SERVER_MEMORY_LIMIT tunbar, mit GOMEMLIMIT bei grob 85 % davon (halt das Verhältnis, wenn du einen der Werte änderst). Die GPU-CDI-Mounts (/etc/cdi, /var/run/cdi) sind Upstream auskommentiert; füge sie hinzu, wenn du eine GPU in Workspaces durchreichst. Wenn du nur die Web-UI hinter einem Proxy brauchst, lösch den ports-Block des Servers komplett und veröffentliche nichts außer 8082.

Schritt 4: Den Stack starten

bash
sudo docker compose up -d

Der erste Start dauert ein paar Minuten, während die Images pullen (das Server-Image ist das große). Beobachte ihn:

bash
sudo docker compose logs -f

Ein gesunder erster Boot in den Logs, der Reihe nach: Postgres und pgvector ready, migrate spielt das Schema ein und beendet sich, server startet seine API, channel registriert sich über RPC, und web serviert. Jede Abweichung von dieser Reihenfolge ist dein erster Hinweis.

Sobald die Logs sich beruhigt haben, öffne http://your-server-ip:8082 und logge dich mit den Admin-Credentials aus config.toml ein. Der migrate-Service läuft bei jedem Start, Schema-Updates werden also automatisch eingespielt, wenn du neue Images pullst. Führe danach die Smoke-Tests aus, bevor du etwas Echtes anbindest.

Dein Memoh-Deployment verifizieren

Verlass dich nicht allein auf up -d. Führe die Smoke-Tests der Reihe nach aus:

  • docker compose ps zeigt alle sechs Kernservices als laufend, mit memoh-migrate bei Exited (0)
  • docker compose logs migrate --tail 50 zeigt applizierte Migrationen und keine Fehler
  • docker compose logs channel | tail zeigt den registrierten Channel-Worker
  • Health-Endpunkte antworten (siehe die Curl-Kommandos unten)
  • Du kannst dich als Admin in der Web-UI einloggen
  • Eine Testnachricht bekommt eine Antwort in der Web-UI
  • Ein externer Channel (zum Beispiel Telegram) liefert eine Nachricht Ende-zu-Ende
bash
sudo docker compose ps
sudo docker compose logs migrate --tail 50
sudo docker compose logs channel | tail

curl -s http://localhost:8080/health
curl -s http://localhost:8081/health

Ein gesundes docker compose ps zeigt memoh-postgres und memoh-pgvector als healthy, memoh-migrate als Exited (0) und memoh-server, memoh-channel, memoh-web als running (Server und Channel mit einem (healthy)-Marker, sobald ihre Checks durch sind). Das Migrate-Log sollte sich wie applizierte Schema-Versionen lesen, nicht wie ein Stacktrace. Das Channel-Log sollte zeigen, dass er sich am Server registriert hat, nicht Retry-Loops.

Die Compose-Health-Checks rufen /health auf 8080 und 8081 auf – diese Pfade sind also die Arbeitsannahme. Falls ein Curl einen 404 zurückgibt, keine Panik: Schau stattdessen in docker compose logs server und channel, da sich exakte Endpunkt-Pfade zwischen Releases verschieben können.

Wie “kaputt” aussieht: Ein memoh-migrate, das im Restart hängt, bedeutet meist ein Datenbank-Passwort-Mismatch. Ein memoh-channel, der läuft, aber stumm bleibt, bedeutet meist ein falsches RPC-Secret. Keine Antwort von einem neuen Agenten bedeutet meist, dass noch kein Provider konfiguriert ist. Lösungen findest du unter Troubleshooting bei Memoh-Deployment-Problemen.

Nach dem Deployment

Einen KI-Provider hinzufügen

Gehe nach dem Login zu Settings > Providers und füge deinen API-Key für OpenAI, Anthropic, Google oder einen kompatiblen Endpunkt hinzu. Ohne Provider machen Agenten nichts Nützliches. Ein OpenAI-kompatibles Setup braucht drei Dinge: eine Base-URL, einen API-Key und mindestens einen Modelnamen (zum Beispiel gpt-4o-mini oder was auch immer dein Endpunkt anbietet). Das ist gleichzeitig der Fluchtweg für lokale Modelle hinter einem OpenAI-kompatiblen Gateway wie LiteLLM oder Ollamas OpenAI-Shim. Für nicht-standardisierte Endpunkte leben Custom-Provider-Definitionen im ./conf/providers-Verzeichnis, das read-only in den Server gemountet ist.

Deinen ersten Agenten erstellen

  1. Klick in der Sidebar auf Bots
  2. Klick auf Create Bot
  3. Gib ihm einen Namen und wähle ein Modell deines konfigurierten Providers
  4. Der Agent bekommt automatisch seinen eigenen containerd-Workspace (Image memohai/workspace:debian-latest)

Der Workspace ist der wichtige Teil: ein echter Container mit eigenem Dateisystem und Netzwerk, kein Prompt-Fenster. Dateien, die der Agent schreibt, persistieren dort; MCP-Server, die er fährt, bleiben sandboxed; und ein Agent, der abraucht, reißt die anderen nicht mit. Du kannst sofort aus der Web-UI mit ihm chatten. Externe Channels anzubinden ist der nächste Schritt, wenn er auf Telegram oder Discord antworten soll.

Messaging-Channels verbinden

Memoh 1.0 unterstützt neun externe Channels. Konfiguriere sie unter Settings > Channels:

Channel Was du brauchst
Telegram Ein Bot-Token von @BotFather
Slack Bot-Token und App-Token aus der Slack-API
Discord Ein Bot-Application-Token aus dem Discord Developer Portal
Feishu (Lark) App ID und App Secret
DingTalk App-Credentials aus der DingTalk-Konsole
WeCom Corp ID und App Secret
WeChat Service-Account-Credentials
QQ Bot-Credentials von der QQ-Open-Platform
LINE Channel-Token und Channel-Secret

Jeder Channel hat seinen eigenen Walkthrough unter docs.memoh.ai/integrations/channels. Der eingebaute E-Mail-Support wurde in v0.21.0 entfernt – such also nicht nach einer SMTP-Zeile. Verkabel einen Channel nach dem anderen und schick eine Testnachricht, bevor du zum nächsten übergehst: Channel-Credentials und Webhook-URLs schlagen auf leise Weise fehl, und die Verify-Checkliste oben fängt sie schneller als ein Nutzer, der sich drei Tage später beschwert.

Keine öffentliche IP? Nutze den Webhook-Tunnel

Das optionale webhook-tunnel-Profil (--profile webhook-tunnel) fährt einen cloudflared Quick Tunnel, damit Telegram und Co. deinen Channel-Worker ohne Port-Forwarding oder öffentliche IP erreichen. Perfekt für eine Home-Box oder einen NAT-ed VPS.

Coding-Agenten in Memoh fahren (ACP)

Das ist das Feature, das Memoh 1.0 über Chatbots hinaus interessant macht. Über ACP (Agent Client Protocol) kannst du echte Coding-Agenten in einem Agent-Workspace fahren: Claude Code, Codex, OpenCode oder Hermes. Der Workspace ist ein richtiger Container mit eigenem Dateisystem – Repo-Arbeit bleibt also in der Sandbox statt auf deinem Host.

Wofür es gut ist:

  • Repo-Arbeit: klonen, editieren, Tests fahren und Diffs aus dem Workspace heraus reporten
  • Geplante Tasks mit Per-Run-Sessions, damit jeder Run sauber startet statt einen langen Chat zu erben
  • Ein Approvals-/Trust-Modell für alles Destruktive, bevor es ausgeführt wird
  • Mit einem Coding-Agenten über Telegram reden, während er in einem Container auf deinem Server arbeitet

Wenn du die zugrunde liegenden Tools vergleichst, schau dir die besten AI-Coding-Tools und -Agenten 2026 an und wie man die Codex-App mit jedem Modell nutzt. Wenn du zwischen Modellen routest, vereinheitlicht Agent Router den Zugriff auf Claude Code, Codex und Gemini CLI unter einem Key, und OpenCode ist ein Open-Source-Coding-Agent, den du im Workspace hosten kannst. Die ACP-Flows sind auf docs.memoh.ai/guides/acp dokumentiert, und die Desktop-App kann sich seit v0.16 remote mit dem Server verbinden.

Ressourcen-Hinweis

Coding-Agenten verbrennen RAM und CPU pro Workspace – obendrauf auf den 8-GB-Basis-Stack. Wenn du vorhast, mehrere parallel zu fahren, dimensioniere die Box größer und setze Per-Workspace-Ressourcenlimits in Memohs Einstellungen.

Wie Agent-Memory funktioniert

Memoh paart pgvector für Embeddings mit Postgres als Source of Truth für strukturierte Daten und nutzt hybride Vektor- und Keyword-Abfrage, um Kontext zurückzuholen. Seit März hat die Engine semantische Memory-Compaction (v0.13), getypte Conversation-History und Compaction (v0.17 und v0.18) und ein konfigurierbares Memory-Modell mit Usage-Tracking (v0.21) bekommen – was behalten und was kompaktiert wird, ist jetzt tunbar statt fix. Compaction ist das Stück, das langlebige Agenten davor bewahrt, in ihrer eigenen Historie zu ertrinken: Alte Turns werden zu Fakten zusammengefasst, und das rohe Transkript rollt aus dem Hot Path. Du kannst Memory-Compaction und Rebuild aus den Agent-Settings triggern, und das Usage-Tracking sagt dir, wie viel des Kontext-Budgets jeder Agent verbrennt. Wenn du für andere Projekte ein anderes Memory-Backend willst, ist Cognee für Agent-Memory self-hosten einen Blick wert.

Daten, Updates und Backups verwalten

Alle persistenten Daten liegen in Docker Named Volumes:

Volume Inhalt
postgres_data PostgreSQL-Datenbankdateien (Nutzer, Agenten, Config)
pgvector_data pgvector-Embeddings (Memory)
containerd_data Agent-Workspace-Images und Snapshots
memoh_data Agent-Workspace-Daten
server_cni_state CNI-Netzwerk-State für Workspace-Networking

Diese Volumes überleben docker compose down. Sichere beide Datenbanken plus die zwei Secret-Dateien (config.toml und .env):

bash
sudo docker compose exec postgres pg_dump -U memoh memoh > memoh-$(date +%F).sql
sudo docker compose exec pgvector pg_dump -U memoh memoh_vector > memoh_vector-$(date +%F).sql
cp config.toml .env /some/backup/location/

Der Restore ist der umgekehrte Weg, in einen laufenden Stack:

bash
cat memoh-2026-11-16.sql | sudo docker compose exec -T postgres psql -U memoh memoh
cat memoh_vector-2026-11-16.sql | sudo docker compose exec -T pgvector psql -U memoh memoh_vector

Zieh beide Dumps nach Plan (nächtlicher Cron reicht für eine persönliche Flotte) und halte die Secret-Dateien daneben. Ein Backup ohne config.toml und .env ist ein halbes Backup: Du hast die Daten und keine Möglichkeit, den wiederhergestellten Stack zu authentifizieren. Für den Dokploy-Pfad: Sichere Dokploy-Deployments auf Cloudflare R2 und häng diese Dumps in dieselbe Pipeline.

down -v löscht alles

docker compose down -v löscht die Named Volumes: beide Datenbanken, alle Workspace-Images, alle Agent-Daten. Es gibt kein Undo. Gewöhn es dir gar nicht erst an.

Um Memoh zu aktualisieren, wähle deinen Weg:

One-Click-Installer

Führe den Installer erneut aus; er erkennt eine bestehende Installation und bietet Upgrade- oder Reinstall-Modi an, und er pinnt die Image-Tags auf das Release, das er installiert:

bash
curl -fsSL https://memoh.sh | sh

Docker Compose

Pull die neuesten Images und recreate. Der migrate-Service läuft beim Start automatisch, um Schema-Änderungen einzuspielen:

bash
sudo docker compose pull && sudo docker compose up -d

In Produktion pinne die Image-Tags in deiner Compose-Datei (memohai/server:1.0.2 und Freunde, wie in den Dateien oben) und bumpe sie bewusst. :latest floatet, und ein routinemäßiges up -d kann eine Major-Version ziehen, über die du nichts gelesen hast.

Nützliche Day-2-Kommandos:

bash
# Check service status
sudo docker compose ps

# View logs for a specific service
sudo docker compose logs -f server

# Restart the stack
sudo docker compose restart

# See where the disk went (workspace images add up)
sudo docker system df

Disk ist die Ressource, die sich anschleicht. Jeder Agent-Workspace ist eine memohai/workspace:debian-latest-Instanz plus containerd-Snapshots, jede Conversation legt Rows in beiden Datenbanken ab, und containerd_data hortet alte Image-Layer bis zum Prune. Wirf monatlich einen Blick auf docker system df. Prune ungenutzte Workspace-Images, nachdem du Agenten löschst. Wenn der Box die Platte ausgeht, ist Postgres das Erste, was umkippt – und eine volle Platte macht aus einem Routine-Restart einen Recovery-Job.

Production-Checkliste und Sicherheit

  • Ersetze alle Default-Passwörter (admin123, das memoh123 des Installers, plus PostgreSQL und das JWT-Secret)
  • Generiere MEMOH_INTERNAL_RPC_SHARED_SECRET mit openssl rand -hex 32, lagere es in .env und committe es nie
  • Richte HTTPS über einen Reverse Proxy ein (Dokploy übernimmt das, oder Caddy/Traefik/Nginx) und halte HTTP/2 im Pfad für SSE
  • Firewall die Box zu: veröffentliche nur 8082; 8080/1455 und 30000/udp nur, wenn du das Remote-Display nutzt; 8421 nur, wenn Connect-It aktiviert ist; niemals 9090/9091
  • Denk dran, dass Docker Ports standardmäßig an deinen Firewall-Regeln vorbei veröffentlicht
  • Setze Memory- und CPU-Limits (MEMOH_SERVER_MEMORY_LIMIT, GOMEMLIMIT bei ~85 %, Per-Workspace-Limits)
  • Sichere beide Postgres-Instanzen plus config.toml und .env
  • Monitor die Disk-Nutzung; Workspace-Images, containerd-Snapshots und Vector-Daten wachsen über die Zeit
  • Pinne Image-Tags (1.0.2) statt :latest

Privileged-Modus

Der Server-Container läuft mit privileged: true und pid: host. Das gibt ihm weitreichenden Zugriff auf Host-Kernel und Dateisysteme. Behandle einen kompromittierten Agent-Workspace wie einen kompromittierten Host: Halte Memoh auf einer eigenen Box, weg von Kundendaten und anderen Produktivservices, und härte SSH auf dem Host. Fürs Monitoring decken Beszel und Uptime Kuma die üblichen Basen ab.

Was 24/7 läuft, sind die sechs Kernservices. Die Per-Agent-Kosten sind der Workspace-Container plus sein Image – eine Handvoll größtenteils idler Agenten ist also billig, eine Flotte Coding-Agenten nicht. Budgetier Disk entsprechend.

Zu Updates: Pinne die Tags, lies die Release-Notes der Version, auf die du springst (v0.21.0 hat E-Mail gebrochen, 1.0 das ganze Service-Layout), und zieh vor jedem Upgrade einen Datenbank-Dump. Memoh bewegt sich schnell für ein so junges Projekt, und “pull and pray” funktioniert genau bis zu dem Tag, an dem es das nicht mehr tut. Wenn ein Upgrade schiefgeht, ist die Rollback-Story die gepinnten alten Images plus deine Dumps: docker compose down, Tags zurückeditieren, beide Datenbanken restaurieren, docker compose up -d.

Lizenz

Memoh ist AGPL-3.0. Okay für persönliche und interne Nutzung; lies die Lizenz, bevor du es als Teil eines kommerziellen Services anbietest.

Troubleshooting bei Memoh-Deployment-Problemen

Häufigster Fehler

Fehlendes MEMOH_INTERNAL_RPC_SHARED_SECRET. Compose bricht mit MEMOH_INTERNAL_RPC_SHARED_SECRET is required ab (der :?-Guard), oder der Channel-Worker startet und pairt nie. Generiere es mit openssl rand -hex 32, leg es in .env oder im Dokploy-Environment-Tab ab und starte neu.

Symptom Fix
Compose bricht ab: MEMOH_INTERNAL_RPC_SHARED_SECRET is required Mit openssl rand -hex 32 generieren, in .env / Dokploy-Environment eintragen, neu deployen
Container schlagen beim Start sofort mit einem Mount-Fehler fehl config.toml fehlt oder ist am Mount-Pfad falsch benannt; ohne sie zu starten schlägt laut Doku fehl
memoh-migrate exitet non-zero oder loopt POSTGRES_PASSWORD stimmt nicht mit [postgres] password in config.toml überein. Wenn du PGVECTOR_PASSWORD gesetzt hast, lass auch [pgvector] dazu passen
memoh-channel läuft, aber Bots antworten nie auf Telegram/Discord Meist ein RPC-Secret-Mismatch (prüfe, ob beide Services dasselbe MEMOH_INTERNAL_RPC_SHARED_SECRET bekommen haben) oder die Channel-Config unter Settings > Channels ist unvollständig. Check docker compose logs channel auf Registrierungsfehler
Agent-Erstellung schlägt fehl oder der Workspace wird nie ready Das Workspace-Image (memohai/workspace:debian-latest) konnte nicht pullen, oder dem Server fehlt Platz für containerd-Snapshots. Check docker compose logs server und docker system df
Image-Pull-Timeouts oder langsame Downloads Nutze den CN-Mirror: USE_CN_MIRROR=true beim Installer oder [container] registry = "memoh.cn" plus das docker/docker-compose.cn.yml-Overlay
Web-UI hängt, Chat hört hinter einem Proxy auf zu streamen SSE über HTTP/1.1 erschöpft die Browser-Verbindungen. Liefere HTTP/2 aus (oder den h2-Listener des Containers auf 8443) und deaktiviere Proxy-Buffering für SSE-Routen
port is already allocated auf 8080/8082/1455/30000/8421 Ein anderer Prozess besitzt den Port. Remappe die linke Seite der ports-Einträge oder stoppe den konkurrierenden Service
Platte füllt sich über ein paar Wochen Workspace-Images (memohai/workspace:debian-latest pro Agent) und containerd-Snapshots summieren sich. Check docker system df, prune alte Workspace-Images und behalte pgvector_data im Auge
Upgrade vom März-Stack (Qdrant) Stand November 2026 gibt es keine dokumentierte In-Place-Migration von Qdrant zu pgvector. Exportiere, was du brauchst, und installiere frisch

FAQ

Warum braucht der Server-Container den Privileged-Modus?

Memoh bettet containerd in den Server-Container ein, um jedem Agenten seine eigene Sandbox zu geben. Containerd braucht Zugriff auf Linux-Kernel-Features (Namespaces, Cgroups), die erhöhte Privilegien erfordern. Es gibt keinen Weg daran vorbei, wenn du Isolation auf Container-Ebene pro Agent willst. Das ist auch der Grund, warum dieser Stack auf eine Box gehört, die du vollständig kontrollierst.

Kann ich Memoh ohne API-Key eines KI-Providers nutzen?

Du kannst es deployen und durch die UI klicken, aber Agenten generieren keine Antworten, bis du mindestens einen Provider hinzufügst. Jeder OpenAI-kompatible, Anthropic- oder Google-Endpunkt funktioniert.

Wie viel RAM braucht Memoh?

Plane 8 GB ein. Upstream setzt mem_limit: 8g und GOMEMLIMIT: 7GiB als Defaults auf dem Server-Container. Wenn du auf einer kleineren Box fahren musst, senke MEMOH_SERVER_MEMORY_LIMIT und setze GOMEMLIMIT auf grob 85 % des neuen Limits. Jeder Agent-Workspace legt Overhead obendrauf, und Coding-Agenten nochmal deutlich mehr. Ich würde keine Idle-Zahl nennen, ohne deine eigene Installation gemessen zu haben.

Kann ich nur die Web-UI exponieren und die API intern halten?

Ja, und das solltest du. Seit 1.0 spricht die Web-UI mit zwei Upstreams (Server und Channel), also halte beide intern: veröffentliche nichts außer 8082 (oder route durch einen Reverse Proxy und veröffentliche gar nichts). Exponiere niemals die RPC-Ports 9090/9091, und lass 1455 und 30000/udp geschlossen, es sei denn, du nutzt das Remote-Display-Feature. Entferne im Standalone-Compose-File die ports-Blöcke für server und channel.

Was ist der Channel-Service und das RPC-Secret?

Der channel-Container ist ein Worker, der die Webhook- und Messaging-Verbindungen besitzt (Telegram, Discord und so weiter). Er spricht über internes RPC auf den Ports 9090/9091 mit dem server. MEMOH_INTERNAL_RPC_SHARED_SECRET authentifiziert diese Verbindung: Beide Prozesse müssen denselben Wert haben, sonst registriert sich der Channel nie. Generiere es einmal, lagere es in .env und verwende es über Recreates hinweg wieder.

Warum gibt es zwei Postgres-Container?

postgres ist das System of Record. pgvector/pgvector:pg18 hält Memory-Embeddings in der memoh_vector-Datenbank. Die Trennung hält Vector-Index-Churn aus deiner Hauptdatenbank und lässt dich beide unabhängig sichern oder tunen. Beide brauchen Backups.

Wie fahre ich Claude Code innerhalb von Memoh?

Nutze die ACP-Integration: Erstelle einen Agenten, binde Claude Code (oder Codex, OpenCode, Hermes) als seine ACP-Runtime an, und der Coding-Agent läuft im Workspace-Container des Agenten. Setup-Details stehen auf docs.memoh.ai/guides/acp; siehe auch den ACP-Abschnitt oben.

Wie aktualisiere ich Memoh?

Installer-Pfad: Führe curl -fsSL https://memoh.sh | sh erneut aus und wähle Upgrade. Compose-Pfad: sudo docker compose pull && sudo docker compose up -d. Der migrate-Service spielt Schema-Änderungen bei jedem Start ein. Pinne Image-Tags in Produktion, damit Updates dann passieren, wenn du es entscheidest. Die Update-Kommandos stehen auch in Daten, Updates und Backups verwalten.

Fazit

Memoh 1.0 ist ein genuin anderer Stack als die März-Version: pgvector-Memory, in-process Agenten, ein dedizierter Channel-Worker und ACP-Hosting für echte Coding-Agenten. Es bleibt eine Compose-Datei oder ein Curl entfernt – auf Hardware, die du kontrollierst. Das Fazit für den Betrieb: 8 GB RAM, nur trusted Hosts (Privileged-Modus ist kein Theater), pinne deine Image-Tags und halte Backups beider Datenbanken plus deiner Secrets. Starte mit dem One-Click-Installer, wenn du es heute Abend einfach laufen willst; nimm den Dokploy-Pfad, wenn es eine echte Domain braucht; nimm den Standalone-Compose-Pfad, wenn du vorher jede Zeile kennen willst. In jedem Fall: Führe die Smoke-Tests aus, bevor du ihm etwas Echtes anvertraust.

Wenn du statt einer Multi-Agenten-Flotte nur einen einzelnen Chat-Assistenten brauchst, ist ein leichteres Setup wie OpenClaw die bessere Wahl. Für andere Memory-Backends folgt der Cognee-Self-host-Guide demselben Deploy-Pattern.

Memoh auf GitHub ansehen
#AI Agents#Memoh#Docker Compose

Hat diese Anleitung bei dir funktioniert?

Brauchst du Hilfe bei Astro, VPS oder einer Self-hosted-App? Services ansehen →