Best MCP servers for writing and content

The best MCP servers for writing aren't fancy prose generators — they give the model memory and access to where your writing already lives: your notes, your docs, your vault. That's the whole game. An LLM writes fine on its own; what it lacks is your context and a place to keep it. This shortlist covers the four that earn a slot, the two memory backends worth arguing about, and what to skip.

One number frames every choice below: clients like Cursor start to degrade past ~40 active tools, and the average server ships ~12, so you get about four servers before you hit the wall. For a writing setup that means picking deliberately — one memory server, one or two doc backends, done. The full math is in the Cursor tool-limit trap.

What "writing" actually needs from an MCP server

The best MCP servers for writing fall into two buckets: memory (so the model stops starting cold every session) and document access (so it reads and edits your real notes). Prose quality is the model's job. Context and persistence are the server's job.

Skip anything that markets itself as a "writing assistant" wrapping the same completion you already get. What moves the needle:

• Persistence — facts about you, your projects, and your style survive across sessions.
• Read + search over your existing corpus, so drafts are grounded in what you've already written.
• Guarded writes — an agent that can edit your vault should edit surgically, not overwrite files.

Almost all of these run locally. About 90% of MCP servers run over stdio on your own machine, and for personal writing that's the right default: your notes never leave your laptop.

The memory layer: pick one, not three

Start with the official Memory (Knowledge Graph) server — it's the simplest thing that works and it's a first-party reference server. It runs over stdio with no auth, stores a local knowledge graph of entities, relations, and observations, and persists to a single JSONL file you control:

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-memory"],
  "env": { "MEMORY_FILE_PATH": "/absolute/path/to/memory.jsonl" }
}

That's the entire setup. The model can now remember your voice, recurring characters, project facts — across every session, in a file you can read, diff, and back up.

If you want memory shared across tools, look at OpenMemory MCP from Mem0. It runs one local store that Claude Desktop, Cursor, and others plug into over SSE via per-client URLs, so a fact you save in one app is searchable from the rest. It's Dockerized and community-built (not official), which is the trade: more setup, one memory brain instead of several.

For long, evolving projects where when something was true matters — a series bible, a changing style guide — Graphiti MCP from Zep adds a time axis. Each add_memory ingests an episode; search_memory_facts can filter by validity date. It's a real graph over Neo4j or FalkorDB, runs over HTTP via Docker, and it's overkill for a single blog. Reach for it only when a flat memory file stops being enough.

Server	Transport	Auth	Official	Best for
Memory	stdio	none	Yes (reference)	Default, single-app persistence
OpenMemory	SSE	local	Community	One memory shared across clients
Graphiti	HTTP	Docker	Community	Long projects where time/versioning matters

Pick one. Running all three doesn't give the model "more memory" — it gives it three inconsistent stores and burns your tool budget.

The document layer: connect the model to where you write

If your writing lives in Notion or Obsidian, add exactly one document server and stop. These are what turn "the model can write" into "the model can write from and into my actual notes."

For Notion, use the official Notion MCP Server. It reads, searches, creates, and updates pages and databases through the Notion API, runs locally over stdio, and needs a single integration token:

{
  "command": "npx",
  "args": ["-y", "@notionhq/notion-mcp-server"],
  "env": { "NOTION_TOKEN": "<your-notion-integration-token>" }
}

Being the first-party server matters here for the boring reasons that always separate official from community: auth handled correctly and maintenance kept current, not extra features.

For Obsidian, mcp-obsidian connects an agent to your vault through the Local REST API community plugin (uvx mcp-obsidian). It browses, reads, and searches — and crucially edits surgically: patch_content inserts relative to a specific heading or block reference instead of rewriting the file. That guardrail is the difference between an agent that helps and one that clobbers your notes. It's community-built but verified, and it stays local.

One caveat: the Notion server needs an integration token and network access to Notion's API, so your content does traverse Notion. The Obsidian route keeps everything on-device. Choose by where your trust already sits.

What to skip

Skip do-everything servers, duplicate memory stores, and code-focused tools you won't use for prose. Every one of them eats tools you can't spare.

• Multiple memory servers. Covered above — one store, or your context fragments.
• codebase-memory-mcp is excellent, but it indexes repositories into a knowledge graph for coding agents. If you write docs about code it's tempting; if you write prose it's off-topic. It belongs in a coding-agent stack, not a writing one.
• Giant multi-tool servers. A single 40-tool server can blow your whole budget. For writing you want narrow servers that do one thing.
• "AI writer" wrappers. If a server's only value is calling the model for you, your client already does that.

The discipline is the point: two to three focused servers beat a pile of half-used ones, every time.

A minimal writing stack that fits the budget

The setup I'd actually run: one memory server plus one document server — roughly 20-25 tools, comfortably under the ~40 ceiling. Concretely:

1. Memory (Knowledge Graph) for persistence — start here.
2. Notion or mcp-obsidian for your docs — whichever holds your writing.
3. Only if you outgrow a flat memory file, swap Memory for Graphiti.

Wire these up once and the model drafts from your notes, remembers your decisions, and edits in place. If you want to browse the full field before committing, the best MCP servers list and the capabilities view let you filter by exactly what a server does.