Docmost (self-hosted)

docmost-mcp-remote

Let your team's AI assistants read and edit your Docmost wiki, each member as themselves.

A self-hosted remote MCP server for Docmost Community Edition.

English · Русский

Highlights · Comparison · Quick start · Connect a client · Tools · Security · Configuration · Feedback

Run it next to your Docmost, put it behind your domain, and connect Claude, Claude Code, Cursor, VS Code or any other MCP client. Every member signs in with their own Docmost account, so the assistant sees exactly what they can see and every change in Docmost carries their name.

Independent community project, not affiliated with or endorsed by Docmost, Inc.

Docmost is a trademark of Docmost, Inc.; the name is used only to say which

software this server works with.

✨ Highlights

• 👥 One server for the whole team. Each member signs in once in the browser with their own Docmost account. Everything their AI client does is done as them, with their Docmost rights.
• 🔐 Real authorization. OAuth 2.1 for remote connectors (Claude.ai, Claude Desktop, Claude Code, Cursor, VS Code) and personal tokens for scripts. There is no unauthenticated mode.
• 🛡️ Safe by default. Only read is granted without asking; write, delete and admin are opt-in per client. Nothing is deleted permanently, risky changes ask you first, and an encrypted snapshot of a page is saved before every change.
• 🧰 62 tools. Read, search, write by section, comment with @-mentions, move, label, export, restore old versions, check a space's health and run the workspace: spaces, groups, invitations and roles.
• 📎 Files without burning tokens. The assistant gives you an upload link: drop files in the browser, put them in order, and they land in the right place of the page.
• 🐳 Easy to host. One container plus Postgres with a ready compose.yaml, or pip install. Tested in CI against Docmost 0.80.1 to 0.97.

⭐ If this server is useful to you, please [star the repository](https://github.com/bbik52/docmost-mcp-remote/stargazers).

It helps other Docmost users find it and tells us the work is worth continuing.

🆚 How it compares

There are several open-source MCP servers for Docmost Community Edition. Most of them run on one person's machine with one shared Docmost account. This one is built to be shared by a team.

Based on the public Docmost CE MCP servers we could find in October 2026. They are good choices for a single person working locally over stdio, and some offer things this server does not, such as permanent deletion.

🧭 How it works

The first time a client connects, the member signs in with their Docmost email and password and picks what the client may do. They can see and revoke every connected app and token on their account page.

Choosing what a client may do Connected apps and personal tokens

🚀 Quick start

You need Docker with Compose, a Docmost reachable from the server, and a host name with https for the server itself, for example mcp.example.com.

1. Download the compose file and the settings template:

   mkdir docmost-mcp && cd docmost-mcp

curl -fsSLO https://raw.githubusercontent.com/bbik52/docmost-mcp-remote/master/compose.yaml curl -fsSL -o .env https://raw.githubusercontent.com/bbik52/docmost-mcp-remote/master/.env.example

1. Edit .env: set PUBLIC_URL (the https URL of this server), DOCMOST_URL, a long random POSTGRES_PASSWORD and SECRET_KEY (openssl rand -hex 32 gives a good value for both). Consider ALLOWED_EMAILS to limit who can sign in.

1. Start it and check that it is up:

   docker compose up -d

curl http://127.0.0.1:8000/healthz

1. Put a reverse proxy with https in front of 127.0.0.1:8000 (see Reverse proxy) and open PUBLIC_URL/login in a browser to check that you can sign in with your Docmost account.

1. Connect a client (see Connecting a client).

The server applies its database migrations at startup. Back up the Postgres volume like you back up Docmost: it holds the encrypted sessions, the snapshots and the audit log. Losing SECRET_KEY signs every member out and makes the snapshots unreadable.

The compose.yaml

# docmost-mcp-remote: the server and its Postgres.

Copy .env.example to .env and fill in the required values first, then put a

reverse proxy with https in front of port 8000.

services: server:

"1" follows 1.x releases; set IMAGE_TAG to a full version such as 1.1.0 to pin one.

image: ghcr.io/bbik52/docmost-mcp-remote:${IMAGE_TAG:-1} restart: unless-stopped environment: PUBLIC_URL: ${PUBLIC_URL:?set PUBLIC_URL to the public https URL of this server} DOCMOST_URL: ${DOCMOST_URL:?set DOCMOST_URL to the base URL of your Docmost} DOCMOST_ALLOW_INSECURE_HTTP: ${DOCMOST_ALLOW_INSECURE_HTTP:-false} DATABASE_URL: postgresql://docmost_mcp:${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD}@postgres:5432/docmost_mcp SECRET_KEY: ${SECRET_KEY:?set SECRET_KEY to a random value of at least 32 characters} SECRET_KEY_PREVIOUS: ${SECRET_KEY_PREVIOUS:-} ALLOWED_EMAILS: ${ALLOWED_EMAILS:-} ALLOWED_SPACES: ${ALLOWED_SPACES:-} RELOGIN_MODE: ${RELOGIN_MODE:-ask} SNAPSHOT_RETENTION_DAYS: ${SNAPSHOT_RETENTION_DAYS:-30} AUDIT_RETENTION_DAYS: ${AUDIT_RETENTION_DAYS:-90} UPLOAD_RETENTION_MINUTES: ${UPLOAD_RETENTION_MINUTES:-60} UPLOAD_MAX_MB: ${UPLOAD_MAX_MB:-50} TOOL_CALLS_PER_MINUTE: ${TOOL_CALLS_PER_MINUTE:-60} MAX_PAGE_CHARS: ${MAX_PAGE_CHARS:-60000}

Proxies on loopback or a private network; the client address is the last

untrusted one in X-Forwarded-For, so a header sent by the client is ignored.

FORWARDED_ALLOW_IPS: ${FORWARDED_ALLOW_IPS:-127.0.0.1,::1,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16,fc00::/7} LOG_LEVEL: ${LOG_LEVEL:-info} ports:

• "127.0.0.1:8000:8000" depends_on: postgres: condition: service_healthy read_only: true tmpfs:
• /tmp cap_drop:
• ALL security_opt:
• no-new-privileges:true

postgres: image: postgres:17-alpine restart: unless-stopped environment: POSTGRES_USER: docmost_mcp POSTGRES_DB: docmost_mcp POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD} volumes:

• postgres-data:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U docmost_mcp -d docmost_mcp"] interval: 10s timeout: 5s retries: 5

volumes: postgres-data:

The server is also on PyPI (pip install docmost-mcp-remote or uvx docmost-mcp-remote) for setups without containers; it needs Postgres and the same settings as environment variables.

Reverse proxy

The server listens on plain http and expects a reverse proxy that terminates https. Serve it at the root of its own host name; a sub-path is not supported. The proxy must not buffer responses, because MCP streams them.

Caddy (gets certificates by itself):

mcp.example.com {

reverse_proxy 127.0.0.1:8000 }

nginx

server {

listen 443 ssl; server_name mcp.example.com; ssl_certificate /etc/letsencrypt/live/mcp.example.com/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/mcp.example.com/privkey.pem;

location / { proxy_pass http://127.0.0.1:8000; proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Forwarded-For $remote_addr; proxy_set_header X-Forwarded-Proto $scheme; proxy_buffering off; proxy_read_timeout 1h; } }

The server uses X-Forwarded-For for its per-IP rate limits. The proxy must set the header to the address it sees, not pass on what the client sent: the nginx example above does that with $remote_addr, and Caddy and Traefik do it by default. The compose file trusts proxies on loopback and private networks (FORWARDED_ALLOW_IPS); if y