xknow-mcp
This server lets an MCP-capable agent locally search, read, explore, list, and cite the XKnow SEO/SaaS/LLM knowledge base without an API key.
Search the knowledge base (
search_knowledge): ranked results with snippets and URLs for natural-language queries; optional limit and section filter (seo, saas, blog).Read a full note (
get_page): fetch a note by exact title or slug, preserving[[wikilinks]].Explore the knowledge graph (
explore_concept): get a note plus its outbound links and backlinks, with optional depth 1 or 2.Discover topics (
list_topics): list all available notes grouped by section, optionally filtered.Generate citations (
cite): return canonical title, description, and URL for a note so answers can attribute the source.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@xknow-mcpsearch XKnow for SaaS pricing models and summarize the trade-offs"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
xknow-mcp
An MCP server for the XKnow Knowledge Base — a curated, cross-linked body of SEO, SaaS, and LLM-wiki knowledge. Give any MCP-capable agent (Claude, Cursor, Cline, opencode, and others) the ability to search and cite it.
Local and private. Runs on your machine over stdio. No server, no account, no API key.
Static data. The free layer is a snapshot of the public XKnow guides, bundled with the package. Nothing is fetched at query time.
Graph-aware. Beyond keyword search,
explore_conceptwalks the cross-links between notes, so an agent can follow a topic instead of getting a flat list.
Quick start
Add it to your MCP client.
Claude Desktop (claude_desktop_config.json), Cursor, Cline, and most clients:
{
"mcpServers": {
"xknow": {
"command": "npx",
"args": ["-y", "xknow-mcp"]
}
}
}Claude Code
claude mcp add xknow -- npx -y xknow-mcpopencode (opencode.json)
{
"mcp": {
"xknow": { "type": "local", "command": ["npx", "-y", "xknow-mcp"], "enabled": true }
}
}Then ask your agent something like:
"Use the xknow tools to explain keyword difficulty and cite the source." "Search XKnow for SaaS pricing models and summarise the trade-offs."
Related MCP server: OpenCode LLM Wiki MCP Server
Tools
Tool | What it does |
| Ranked search over the knowledge base. Returns titles, snippets, and URLs. |
| Full text of one note by title or slug (preserves |
| A note plus its outbound links and backlinks — walks the knowledge graph. |
| Lists every note grouped by section ( |
| The XKnow SEO/SaaS content self-check rubric — each rule with priority (P0–P3), reasoning, fix, and the knowledge-base notes that back it. |
| Returns the canonical citation (title, description, URL) for a note. |
Two knowledge layers
Layer | Content | How |
Free (default) | The 57 public XKnow guides and blog posts | Bundled snapshot — just |
Full vault | Your purchased XKnow Knowledge Base (500+ linked notes) |
|
The full-vault mode reads a local folder of Markdown notes, so your purchased copy never
leaves your machine. Set it once with the XKNOW_VAULT environment variable if you prefer:
export XKNOW_VAULT="/path/to/SEO-SaaS-Vault"
npx -y xknow-mcpHow it works
xknow-mcp is a Node.js stdio server. The free layer is a static JSON snapshot generated
from the public site and bundled in the package (data/knowledge.json); search is a small,
dependency-free ranking pass over the bundled notes. Vault mode parses Markdown notes from
a local folder on the fly. No network calls, no vector database, no telemetry.
Development
npm install
npm run build:data # refresh data/knowledge.json from https://xknow.org/mcp/knowledge.json
npm run build # tsc
npm run smoke # exercise every tool over a real stdio connection
# also test against a local vault
SMOKE_VAULT=/path/to/SEO-SaaS-Vault npm run smokeLinks
Product page: https://xknow.org/mcp
Knowledge base: https://xknow.org/vaults/seo
Registry: https://registry.modelcontextprotocol.io/servers/io.github.techreone/xknow-mcp
License
MIT — see LICENSE.
Available Tools
5 toolsciteGet a citation for a noteA
Return the canonical citation (title, description, URL) for a note, so an answer can attribute the XKnow source.
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Exact title or slug to cite |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the disclosure burden, and it does state the return shape and that this is a read-style lookup. It does not mention what happens when the slug does not resolve, whether matching is exact-only, or any rate/permission considerations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence that leads with the action and resource, then gives the rationale. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read-only tool with no annotations and no output schema, the description adequately explains the return contents and intent. It is nearly complete; only failure behavior and sibling routing are left unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single parameter is documented as 'Exact title or slug to cite'. The description's phrase 'for a note' reinforces that the slug identifies a note, but adds no format or matching details beyond the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('Return') and resource ('the canonical citation ... for a note') and even enumerates the returned fields (title, description, URL). It is unambiguous what the tool does, though it never contrasts itself with the closest sibling, get_page, which also fetches note content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'so an answer can attribute the XKnow source' implies the trigger condition (attribution needed in an answer), which is useful implied usage. However, there is no explicit when-to-use vs. when-not guidance and no mention of alternatives such as get_page for full content.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
explore_conceptExplore a concept and its graphA
Return a note together with the notes it links to (outbound) and the notes that link back to it (inbound). Use to walk the knowledge graph around a concept instead of a flat search.
| Name | Required | Description | Default |
|---|---|---|---|
| depth | No | 1 = direct neighbours (default), 2 = two hops | |
| concept | Yes | A concept title or slug, e.g. 'Retrieval-Augmented Generation' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It usefully discloses the return shape (the note plus outbound-linked notes and inbound backlinks), which is real behavioral content. However, it says nothing about read-only safety, behavior when the concept is missing, truncation or size limits on large graphs, or how depth affects result volume.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with zero waste; the output shape is front-loaded and the usage cue follows immediately. Nothing is restated from the title or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description must convey the return values, and it does so adequately (note + outbound + inbound neighbours). With only two fully documented parameters and no annotations, the main remaining gap is edge-case behavior (missing concept, large-graph limits), which keeps it short of a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the schema itself explains both 'depth' (1 = direct neighbours, 2 = two hops) and 'concept' (title or slug) with an example. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Return a note together with the notes it links to... and the notes that link back to it') and explicitly scopes it to graph traversal around a single concept. It also implicitly separates itself from the flat-search sibling by contrasting with 'a flat search'. An agent can tell what it produces without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Use to walk the knowledge graph around a concept instead of a flat search' gives a clear usage context and an implicit exclusion (flat search). It does not name the actual sibling tool (search_knowledge) or state when-not to use it (e.g., when you only need the note body, use get_page), so the guidance is clear but not fully routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_pageGet a knowledge-base noteA
Fetch the full text of one note by title or slug. Use after search_knowledge to read the note before answering. Preserves [[wikilinks]].
| Name | Required | Description | Default |
|---|---|---|---|
| slug | Yes | Exact title or slug, e.g. 'keyword-research' or 'Keyword Research' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It usefully discloses that output 'Preserves [[wikilinks]]' and that it returns the full untruncated text, but says nothing about failure behavior when the exact title/slug does not match, permission requirements, or size limits for large notes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, no filler, with the core action front-loaded and the usage cue and output trait following in priority order. Every clause carries information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read tool with no output schema, the description tells the agent what it gets back (full text, wikilinks intact) and where it fits in the workflow. What is missing is the behavior on a non-matching title/slug, which matters because the input must be exact.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% — the single 'slug' parameter already documents the exact title-or-slug format with examples. The description's 'by title or slug' phrasing mirrors rather than extends the schema, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Fetch the full text of one note') plus the identifier options (title or slug), which an agent can immediately distinguish from search_knowledge, explore_concept, list_topics and cite. The scope is precisely delimited to a single note.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly sequences the tool: 'Use after search_knowledge to read the note before answering,' naming the sibling and the condition that selects this tool. It stops short of saying when NOT to use it (e.g. when only a summary or citation is needed), but the positive routing guidance is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_topicsList knowledge-base topicsA
List the available notes, grouped by section (seo, saas, blog). Use to discover what the knowledge base covers.
| Name | Required | Description | Default |
|---|---|---|---|
| section | No | Restrict to one section |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does disclose the shape of the result (notes grouped by section), which is genuine value, but says nothing about read-only semantics, pagination, or permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with what the tool returns before the usage hint; nothing is redundant or padded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-required-param, no-output-schema read tool with full schema coverage, the description supplies enough: what is listed and how results group. Only the absence of sibling routing keeps it from being fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single section parameter already carries its own enum and description, so the schema does the heavy lifting. The description only echoes the enum values, adding no extra filtering semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and resource (notes/topics) and previews the grouping dimension (section, with the three enum values). It does not explicitly contrast itself with the closest sibling search_knowledge, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
"Use to discover what the knowledge base covers" gives one implied use case (browsing/overview) but names no alternative and no when-not condition, leaving the agent to infer that search_knowledge is for targeted lookup.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_knowledgeSearch the XKnow knowledge baseA
Search curated, source-backed SEO, SaaS, and LLM-wiki knowledge. Returns ranked notes with a snippet and URL. Use this to ground answers about search-engine optimization, SaaS business models, or AI knowledge bases.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 8) | |
| query | Yes | Natural-language query, e.g. 'keyword difficulty' or 'saas pricing models' | |
| section | No | Restrict to one section |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It discloses the return shape (ranked notes with snippet and URL), which is genuinely useful, but says nothing about authentication, rate limits, or how ranking is determined. Adequate but incomplete for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences, front-loaded with the purpose and scope before the usage hint. Every sentence contributes; the only minor redundancy is the restatement of the SEO/SaaS/AI domain in the third sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 3-parameter read tool with full schema coverage, the description covers purpose, corpus scope, and return values, compensating for the absence of an output schema. The remaining gap is sibling differentiation against four related tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters (query, limit, section) are already fully documented with examples and enum values. The description adds no syntax or format meaning beyond the schema, making the baseline of 3 appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (search) and a named resource (curated, source-backed SEO/SaaS/LLM-wiki knowledge) with clear scope. It distinguishes itself from generic search by naming the corpus, though it does not explicitly separate itself from siblings like explore_concept or list_topics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
"Use this to ground answers about..." gives implied context for retrieval use, which is helpful. However, it offers no explicit when-not-to-use guidance and never contrasts with the four sibling tools (get_page, explore_concept, list_topics, cite), leaving alternative selection to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v1.0.1- First observed
cite - First observed
explore_concept - First observed
get_page - First observed
list_topics - First observed
search_knowledge
TDQS
Scored across 5 tools
Each tool targets a distinct operation: search, read, explore graph, list, and cite. No overlap in purpose or output, making selection straightforward.
Mostly consistent verb_noun patterns (search_knowledge, get_page, explore_concept, list_topics), but 'cite' deviates as a bare verb without an object. Minor inconsistency.
Five tools perfectly cover the core workflows of a knowledge retrieval server: discover, search, read, explore connections, and cite. Well-scoped with no extraneous tools.
Covers all essential operations for a read-only knowledge base. Missing tools for editing or adding notes, but the server appears curated and source-backed, so writes may be intentionally out of scope.
Related MCP Connectors
Cloud or self-hosted knowledge for AI agents: hybrid search, reranking, GraphRAG, scoped MCP tools.
Shared, peer-validated knowledge archive for AI agents — search, contribute, and validate via MCP
Shared knowledge base for AI agents. Semantic search across agents, no setup required — just a URL.
Multi-engine search for AI agents. Trust scoring, local corpus, MCP-native. Self-hostable, BYOK.
Related MCP Servers
- AlicenseAqualityAmaintenanceProvides local-first web intelligence over MCP with tools for search, fetch, crawl, extract, cache, find-similar, research, and autonomous agent loops, requiring no API keys.10839 npm5,245AGPL 3.0
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to interact with a persistent knowledge graph backend using MCP tools for reading, searching, and analyzing wiki pages with vector search and graph algorithms.4-
- AlicenseBqualityAmaintenanceProvides AI assistants with a local knowledge base and research library, enabling semantic and full-text retrieval, memory persistence, and multi-agent collaboration via 58 MCP tools.762MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to search, read, and traverse a local knowledge base of Markdown files using full-text search and relationship graph, reducing token usage.MIT