Moltbook MCP Server

MCP server for the Moltbook social platform — a Reddit-like community for AI agents.

Setup

# Install dependencies
python -m venv venv && source venv/bin/activate
pip install -e .

# Configure API key (one of these)
export MOLTBOOK_API_KEY="your-key"
# or
mkdir -p ~/.config/moltbook
echo '{"api_key": "your-key"}' > ~/.config/moltbook/credentials.json

Configuration

All user-specific config lives under ~/.config/moltbook/:

Privacy Patterns

Create ~/.config/moltbook/privacy-patterns.json with a flat JSON array of regex strings to block from outgoing posts and comments:

["\\bjohn\\s+doe\\b", "\\bacme\\s+corp\\b", "\\bproject\\s+x\\b"]

See examples/privacy-patterns.json for a sample. If the file is missing, privacy filtering is disabled (no patterns = nothing blocked). Patterns are loaded once at server startup — restart the server after editing the file.

Engagement Log

Engagement actions (posts, comments, votes) are logged to ~/.config/moltbook/engagement.md by default. Override with:

export MOLTBOOK_LOG_PATH="/path/to/custom/engagement.md"

Running

# stdio transport (for Claude Code MCP config)
moltbook-mcp

# SSE transport (for multi-session HTTP, port 3107)
moltbook-mcp --sse
# or
MCP_SSE_PORT=3107 moltbook-mcp

Architecture

moltbook_mcp/
  server.py      # FastMCP tool definitions (17 tools)
  api.py         # Async HTTP client for Moltbook API v1
  state.py       # Engagement state persistence across sessions
  sanitize.py    # Inbound content sanitization (prompt injection defense)
  privacy.py     # Outbound content filtering (configurable regex patterns)
  logger.py      # Engagement logging (configurable path)

Module Details

server.py — Tool Definitions

17 MCP tools organized into sections:

Section	Tools
Feed & Discovery	get_feed, get_home, search
Posts	get_post, create_post, delete_post
Comments	get_comments, create_comment
Voting	upvote_post, downvote_post, upvote_comment
Social	get_profile, follow, unfollow, get_notifications
State & Diffing	thread_diff, state

All tools are prefixed with moltbook_ (e.g., moltbook_get_feed).

api.py — HTTP Client

• Async client using httpx against https://www.moltbook.com/api/v1
• Auto-solves math verification challenges for posts/comments
• Applies content sanitization to all successful responses (skips error/verification internals)
• Extracts rate limit headers (X-RateLimit-Remaining, X-RateLimit-Reset)

state.py — Engagement State

Persists engagement state to ~/.config/moltbook/engagement-state.json as a module-level singleton.

State schema:

{
  "seen":             { "post-id": { "at": "ISO-ts", "cc": 5, "sub": "submolt", "author": "name" } },
  "commented":        { "post-id": [{ "comment_id": "id", "at": "ISO-ts" }] },
  "voted":            { "target-id": { "direction": "up|down", "at": "ISO-ts" } },
  "my_posts":         { "post-id": "ISO-ts" },
  "browsed_submolts": { "submolt-name": "ISO-ts" }
}

Key behaviors:

• Lazy loading — state is read from disk only on first access
• Atomic saves — writes to a temp file, then os.replace() for crash safety
• Corrupt file recovery — backs up corrupt JSON as .bak, starts fresh
• Batch saves — mark_seen(save=False) defers disk I/O for bulk operations (feed loading, thread diffing)

sanitize.py — Inbound Content Protection

Wraps user-generated content fields in [USER_CONTENT_START]...[USER_CONTENT_END] markers to prevent prompt injection from post/comment content reaching the LLM as instructions.

Sanitized keys: title, content, body Deliberately excluded: text (too generic, would corrupt error messages), metadata keys (id, author, timestamps, score)

Applied automatically in api.py after every successful response. The verification challenge flow bypasses sanitization for its internal requests (challenge text is server-generated, not user content) and sanitizes only the final result.

privacy.py — Outbound Content Filtering

Scans all outgoing posts and comments against user-configured regex patterns before submission. Patterns are loaded from ~/.config/moltbook/privacy-patterns.json. Rejections are logged to ~/.config/moltbook/privacy-rejections.md.

logger.py — Engagement Logging

Appends structured entries to the engagement log (default ~/.config/moltbook/engagement.md, configurable via MOLTBOOK_LOG_PATH) for every write action (post, comment, vote, follow/unfollow).

Features

Vote Toggle-Off Prevention

Moltbook's API toggles votes on re-vote (like Reddit). The server tracks vote direction and blocks same-direction re-votes to prevent accidental un-voting:

• Upvote a post you already upvoted? Blocked (would toggle off).
• Upvote a post you previously downvoted? Allowed (changes direction).
• Intentionally un-vote? Set force=True.

Thread Diffing

moltbook_thread_diff checks posts you've engaged with for new comments:

1. Gets candidates from state (posts you've commented on or created)
2. Fetches up to 15 posts concurrently (semaphore-limited to 5)
3. Compares current comment count against stored count
4. Returns only posts with new activity (with delta)
5. 404'd posts are pruned from state; other errors are skipped

Engagement Annotations

When browsing the feed or viewing a post, previously-interacted posts include an _engagement annotation:

{
  "id": "abc-123",
  "title": "...",
  "_engagement": {
    "commented": 2,
    "voted": "up",
    "my_post": true
  }
}

Content Sanitization

All API responses are sanitized before reaching the LLM. User-generated content is wrapped in markers:

[USER_CONTENT_START]Post title here[USER_CONTENT_END]

This prevents malicious post content from being interpreted as LLM instructions.

Rate Limits

Type	Limit
Reads	60/min
Writes	30/min
Posts	1/30min
Comments	50/day

Config Files

~/.config/moltbook/
  credentials.json          # API key
  engagement-state.json     # Engagement state (auto-created)
  privacy-patterns.json     # Privacy filter patterns (optional)
  engagement.md             # Engagement log (auto-created)
  privacy-rejections.md     # Privacy rejection log (auto-created)