I gave my AI coding agent a research-backed SEO knowledge base over MCP

#seo #mcp #ai #tutorial

Every AI assistant I use — Claude Code, Cursor, opencode — will happily answer SEO questions. The problem is where the answer comes from. Ask "does keyword stuffing still matter?" and you get a confident paragraph assembled from training-data soup: partly right, partly 2019, partly invented. Ask it for a number and it will make one up with total sincerity.

I build XKnow, a research-backed SEO/SaaS knowledge base, and the obvious fix was to stop chatting about SEO and let agents search and cite a curated corpus instead. This post is about the plumbing: an MCP server that ships a whole knowledge base to any local agent, in about ten seconds of setup.

What MCP gives you here

MCP (Model Context Protocol) is the emerging standard for giving tools to AI clients. Most MCP servers wrap an API: search, weather, your database. That works less well for knowledge, because the valuable part is not the lookup — it's the curation: which sources you trust, how notes cross-reference each other, and whether claims carry evidence.

So instead of a thin wrapper, the server ships the corpus itself:

search_knowledge — ranked search over the whole knowledge base, returning titles, snippets and URLs
get_page — full text of one note, preserving the original [[wikilinks]]
explore_concept — a note plus its outbound links and backlinks, so the agent can walk the graph instead of getting a flat list
list_topics — every note grouped by section
cite — the canonical citation (title, description, URL) for a note
lint_rules — a self-check rubric for SEO/SaaS content writing, each rule backed by knowledge-base notes

The graph-aware part matters more than I expected. SEO topics form a web — canonical URLs link to crawl budget, which links to log-file analysis, which links to faceted navigation. A flat keyword search returns five unrelated pages; walking the graph reads like a person learning the territory.

The ten-second setup

The server is open source (MIT) and runs locally over stdio. For Claude Code:

claude mcp add xknow -- npx -y xknow-mcp

For Claude Desktop, Cursor, Cline and most other clients:

{
  "mcpServers": {
    "xknow": {
      "command": "npx",
      "args": ["-y", "xknow-mcp"]
    }
  }
}

For opencode:

{
  "mcp": {
    "xknow": {
      "type": "local",
      "command": ["npx", "-y", "xknow-mcp"],
      "enabled": true
    }
  }
}

No server, no account, no API key. The free layer is a static snapshot bundled with the npm package — nothing is fetched at query time, so it works offline and your queries never leave the machine.

Then you can just ask things like:

"Use the xknow tools to explain keyword difficulty and cite the source."
"Search XKnow for SaaS pricing models and summarise the trade-offs."

Two knowledge layers

The default layer is the free one: the public guides and posts, bundled as a snapshot. If you own the full XKnow Knowledge Base — 500+ cross-linked notes — the same server can serve your purchased copy locally:

npx -y xknow-mcp --vault /path/to/SEO-SaaS-Vault
# or export XKNOW_VAULT=/path/to/SEO-SaaS-Vault

Vault mode parses the Markdown notes from your local folder on the fly. The purchased copy never leaves your machine — the same local-first logic as the free layer.

Why this beats pasting docs into a prompt

I tried the obvious alternatives first:

Paste the docs into context. Works until you blow the context window on a topic the agent only glances at. MCP tools let the agent pull what it needs, when it needs it.

RAG with embeddings. Fine for recall, but the infrastructure bill is real: vector store, chunking pipeline, re-ranking. For a corpus of hundreds of curated notes, a small dependency-free ranking pass over structured notes turned out to be enough — and it runs on a laptop with zero network calls.

Just trust the model. This is the one that quietly costs the most. SEO is a domain where stale and invented facts look identical to fresh ones in a chat bubble. When every claim can be traced back to a note with sources, "the agent said so" becomes "the knowledge base says so, here's the citation".

Under the hood

The server is a small Node.js stdio process. The free layer ships a static JSON snapshot generated from the public site; search is a compact ranking pass over the bundled notes; vault mode reads Markdown from disk. No vector database, no telemetry, no network calls. The whole thing is one npm package: xknow-mcp, with the source on GitHub if you want to see how the graph walk works.

If you're building agent workflows that touch SEO or SaaS growth questions — content audits, brief writing, competitor analysis — I'd rather have the agent answer from a curated, cited corpus than from memory. Setup is one command; unfork it if it doesn't earn its keep.

Links: XKnow MCP · Knowledge base · Source

DEV Community