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.
Aktualisiert Veröffentlicht 67 Min. Lesezeit

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, Datenbankmemoh_vector). Derqdrant-Service ist weg. - Der Agent läuft in-process. Der eigenständige
memohai/agent-Service ist weg; die AI-Agent-Loop läuft innerhalb desserver-Containers. Die altenmemohai/agent- undmemohai/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 verpflichtendesMEMOH_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 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:
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: 8gundGOMEMLIMIT: 7GiBauf 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 testenVPS-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:
curl -fsSL https://memoh.sh | shDer 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:
# 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 shDefaults 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:
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:
openssl rand -base64 32 # -> [auth] jwt_secret
openssl rand -base64 16 # -> [postgres] passwordDrei Dinge müssen vor dem ersten Boot geändert werden:
[admin]: Username,passwordund E-Mail. Das Default-Passwort istadmin123.[auth]:jwt_secret. Füge die Ausgabe vonopenssl rand -base64 32ein.[postgres]:password. Füge die Ausgabe vonopenssl rand -base64 16ein. Sie muss mitPOSTGRES_PASSWORDin 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
- Öffne dein Dokploy-Projekt
- Klick Add Service und wähle Compose
- 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:
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):
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
exposestattports; 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.tomlwird von/opt/memoh/config.tomlauf dem Host gemountet. Das Datenbankpasswort muss sowohl in der Config-Datei als auch inPOSTGRES_PASSWORDübereinstimmen. Wenn du ein separatesPGVECTOR_PASSWORDsetzt, lass auch die[pgvector]-Sektion dazu passen.- Der Server-Container braucht
privileged: trueundpid: host, damit containerd Agent-Workspaces verwalten kann. mem_limit: 8gundGOMEMLIMIT: 7GiBsind die Upstream-Defaults. Wenn du das Limit senkst, halteGOMEMLIMITbei 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
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:
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] + .envSchreibe die .env neben deine Compose-Datei:
cat > .env << 'EOF'
POSTGRES_PASSWORD=YOUR_DB_PASSWORD
MEMOH_INTERNAL_RPC_SHARED_SECRET=YOUR_RPC_SECRET
EOFPOSTGRES_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
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: bridgeEin 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
sudo docker compose up -dDer erste Start dauert ein paar Minuten, während die Images pullen (das Server-Image ist das große). Beobachte ihn:
sudo docker compose logs -fEin 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 pszeigt alle sechs Kernservices als laufend, mitmemoh-migratebeiExited (0)docker compose logs migrate --tail 50zeigt applizierte Migrationen und keine Fehlerdocker compose logs channel | tailzeigt 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
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/healthEin 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
- Klick in der Sidebar auf Bots
- Klick auf Create Bot
- Gib ihm einen Namen und wähle ein Modell deines konfigurierten Providers
- 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 |
| Service-Account-Credentials | |
| 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):
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:
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_vectorZieh 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:
curl -fsSL https://memoh.sh | shDocker Compose
Pull die neuesten Images und recreate. Der migrate-Service läuft beim Start automatisch, um Schema-Änderungen einzuspielen:
sudo docker compose pull && sudo docker compose up -dIn 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:
# 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 dfDisk 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, dasmemoh123des Installers, plus PostgreSQL und das JWT-Secret) - Generiere
MEMOH_INTERNAL_RPC_SHARED_SECRETmitopenssl rand -hex 32, lagere es in.envund 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/1455und30000/udpnur, wenn du das Remote-Display nutzt;8421nur, wenn Connect-It aktiviert ist; niemals9090/9091 - Denk dran, dass Docker Ports standardmäßig an deinen Firewall-Regeln vorbei veröffentlicht
- Setze Memory- und CPU-Limits (
MEMOH_SERVER_MEMORY_LIMIT,GOMEMLIMITbei ~85 %, Per-Workspace-Limits) - Sichere beide Postgres-Instanzen plus
config.tomlund.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 ansehenHat diese Anleitung bei dir funktioniert?
Brauchst du Hilfe bei Astro, VPS oder einer Self-hosted-App? Services ansehen →


