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., "@Shelby docs MCP search for how to configure the Shelby CLI"
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.
A lightweight, read-only MCP server that exposes Shelby documentation as searchable tools for MCP-compatible clients like Claude Code, Codex, Cursor, VS Code, and Gemini CLI.
This project is a docs-only server. It does not write data, talk to Shelby RPC endpoints, or modify anything in the network.
The server loads the full Shelby LLM docs bundle:
It parses that bundle into page-level chunks using the native Shelby format:
# Page Title (/path)
Page content...
# Next Page (/next-path)
Next page content...Related MCP server: mcp-docs
Add the MCP server with npx:
claude mcp add --transport stdio shelby-docs -- npx -y github:Jr-kenny/shelby-mcpThen start Claude Code:
claudeInside Claude Code, run:
/mcpYou should see the shelby-docs server and its tool endpoints listed.
Create .cursor/mcp.json and add:
{
"mcpServers": {
"shelby-docs": {
"command": "npx",
"args": ["-y", "github:Jr-kenny/shelby-mcp"]
}
}
}If Cursor does not recognizemcpServers in your version, try mcp_servers as the top-level key instead.
Add this to .vscode/mcp.json:
{
"servers": {
"shelby-docs": {
"type": "stdio",
"command": "npx",
"args": ["-y", "github:Jr-kenny/shelby-mcp"]
}
},
"inputs": []
}Add the MCP server globally:
gemini mcp add --scope user shelby-docs npx -y github:Jr-kenny/shelby-mcpConfirm it is registered:
gemini mcp listAdd the MCP server with the Codex CLI:
codex mcp add shelby-docs -- npx -y github:Jr-kenny/shelby-mcpConfirm it is registered:
codex mcp listAlternatively, add this to your Codex MCP config:
[mcp_servers.shelby-docs]
command = "npx"
args = ["-y", "github:Jr-kenny/shelby-mcp"]Then restart Codex if needed so it reloads the MCP config.
If you want to run the repository locally from source:
Clone the repo:
git clone https://github.com/Jr-kenny/shelby-mcp
cd shelby-mcpInstall dependencies and build:
npm install
npm run buildRun the local entrypoint:
node /absolute/path/to/shelby-mcp/dist/cli.jsThen substitute that node .../dist/cli.js command in any MCP client config if you prefer source-based usage over npx.
GitHub repository:
search_shelby_docs
Searches the Shelby documentation bundle and returns ranked matches with IDs and snippets.
read_shelby_doc
Reads a page by exact path, title, URL, page ID, or fuzzy query.
get_shelby_doc_chunk
Reads a specific page by the exact chunk ID returned from search results.
list_shelby_doc_pages
Lists available parsed pages and supports filtering by path or title text.
File/Folder | Purpose |
| MCP server setup, tool registration, and stdio startup |
| CLI entry point that starts the server |
| Shelby docs loading, parsing, search, and formatting helpers |
| Compiled JavaScript output generated by |
| Dependencies, scripts, package metadata, and CLI registration |
| TypeScript compiler settings |
| Usage and setup instructions |
This MCP server is a lightweight TypeScript implementation built on the official MCP SDK.
Built on @modelcontextprotocol/sdk
Uses StdioServerTransport for local MCP clients
Uses zod to validate tool inputs
Fetches Shelby docs from the official llms-full.txt bundle at startup
Parses the bundle into page chunks using Shelby's # Title (/path) format
Uses deterministic keyword scoring over titles, paths, URLs, and body text
Optional environment variables:
SHELBY_DOCS_URL: alternate docs bundle URL
SHELBY_DOCS_TIMEOUT_MS: HTTP timeout in milliseconds, default 15000
This repo is a good base if you want to publish other docs-only MCP servers backed by a single llms-full.txt style bundle.
Update package.json:
{
"name": "your-docs-mcp",
"description": "Docs-only MCP server for YourProduct documentation"
}Update the docs URL in src/shelbyDocs.ts:
const DEFAULT_DOCS_URL = "https://your-domain.com/llms-full.txt";Update the server name in src/index.ts:
name: "your-docs-mcp"Build and publish:
npm install
npm run buildThis section is only for working on the MCP server itself.
npm install
npm run build
npm run check
npm startnpm run check verifies that the server can fetch and parse the live Shelby docs bundle.
Read a specific Shelby documentation page by its exact chunk ID.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Exact page ID returned by search_shelby_docs. | |
| maxChars | No | Maximum characters to return. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide readOnlyHint=true and idempotentHint=true, indicating safe, repeatable reads. The description adds context beyond annotations by specifying that it reads a 'specific' page and mentions the maxChars parameter for output truncation, which is useful behavioral detail not covered by annotations. No contradiction with annotations.
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?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence contributes to clarity, making it appropriately sized and well-structured.
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?
Given the tool's low complexity (read operation), rich annotations (readOnlyHint, idempotentHint), and full schema coverage, the description is mostly complete. It lacks details on output format or error handling, which could be useful since there is no output schema, but it adequately covers the essential context for use.
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%, with clear descriptions for both parameters. The description adds minimal value beyond the schema by implying the 'id' parameter comes from search_shelby_docs, but does not provide additional syntax or format details. Baseline 3 is appropriate as the schema handles most documentation.
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 clearly states the specific action ('Read'), resource ('Shelby documentation page'), and scope ('by its exact chunk ID'), distinguishing it from siblings like list_shelby_doc_pages (list), read_shelby_doc (read by different identifier), and search_shelby_docs (search). It precisely communicates what the tool does.
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?
The description implies usage context by specifying 'by its exact chunk ID' and referencing 'search_shelby_docs' as the source for IDs, providing clear guidance on when to use this tool. However, it does not explicitly state when not to use it or name alternatives, such as read_shelby_doc for different access methods.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available Shelby documentation pages, optionally filtered by path or title text.
| Name | Required | Description | Default |
|---|---|---|---|
| prefix | No | Optional path or title filter. | |
| limit | No | Maximum number of pages to list. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds minimal behavioral context beyond this (e.g., it mentions filtering but not pagination or return format). With annotations covering key safety aspects, a baseline score of 3 is appropriate for the limited additional value.
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?
The description is a single, efficient sentence that front-loads the core purpose and includes optional filtering details. Every word earns its place, with no redundancy or unnecessary elaboration.
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?
Given the tool's low complexity (a simple list operation), rich annotations (readOnlyHint, idempotentHint), and full schema coverage, the description is reasonably complete. It lacks output schema details, but for this type of tool, the description suffices without needing to explain return values.
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%, with clear documentation for both parameters (prefix as an optional filter, limit with default and constraints). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for high coverage without extra value.
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 clearly states the verb ('List') and resource ('Shelby documentation pages'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from its siblings (get_shelby_doc_chunk, read_shelby_doc, search_shelby_docs), which would be needed for a perfect score.
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?
The description implies usage through the phrase 'optionally filtered by path or title text,' suggesting this is for listing with basic filtering. However, it doesn't provide explicit guidance on when to use this versus alternatives like search_shelby_docs, nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a Shelby documentation page by exact path, title, URL, page ID, or fuzzy query.
| Name | Required | Description | Default |
|---|---|---|---|
| page | Yes | Page path, title, URL, page ID, or fuzzy lookup query. | |
| maxChars | No | Maximum characters to return. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and idempotentHint=true, indicating safe, repeatable reads. The description adds value by specifying the input types and the maxChars parameter for output truncation, but does not disclose additional behavioral traits like rate limits, error handling, or pagination. With annotations covering safety, a 3 is appropriate as the description adds some context without rich behavioral details.
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?
The description is a single, efficient sentence that front-loads the purpose and key details without any wasted words. Every element (verb, resource, input types) earns its place, making it highly concise and well-structured.
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?
Given the tool's moderate complexity (2 parameters, 100% schema coverage, no output schema), the description is mostly complete. It covers the purpose, input types, and implies output handling via maxChars, but lacks details on return format or error cases. With annotations providing safety context, it is adequate but could be more comprehensive for a read operation.
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 the schema already fully documents both parameters. The description adds marginal value by listing the accepted input types for 'page' and implying output truncation with 'maxChars', but does not provide syntax or format details beyond the schema. Baseline 3 is correct when the schema does the heavy lifting.
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 clearly states the verb 'Read' and the resource 'Shelby documentation page', specifying the exact action and target. It distinguishes from siblings by focusing on reading a specific page rather than listing, searching, or chunking, making the purpose specific and well-differentiated.
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?
The description provides clear context by listing the types of inputs accepted (path, title, URL, page ID, or fuzzy query), which helps guide when to use this tool. However, it does not explicitly mention when not to use it or name alternatives like 'search_shelby_docs' for broader searches, so it lacks explicit exclusions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the Shelby documentation bundle and return the most relevant pages.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query for the Shelby docs. | |
| limit | No | Maximum number of results to return. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and idempotentHint=true, indicating safe, repeatable operations. The description adds minimal behavioral context by specifying it returns 'most relevant pages', hinting at ranking or relevance scoring, but doesn't detail aspects like search algorithm, pagination, or error handling. No contradiction with annotations.
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?
The description is a single, efficient sentence that front-loads the core action and outcome without unnecessary details. Every word earns its place, making it highly concise and well-structured for quick understanding.
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?
Given the tool's moderate complexity (search operation with 2 parameters), rich annotations (readOnlyHint, idempotentHint), and no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on output format, error cases, or integration with sibling tools, leaving gaps for an AI agent to infer usage.
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%, with clear descriptions for 'query' and 'limit' parameters. The description adds no additional semantic meaning beyond the schema, such as query formatting tips or result interpretation. Baseline score of 3 is appropriate as the schema adequately documents parameters.
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 clearly states the tool's purpose with a specific verb ('Search') and resource ('Shelby documentation bundle'), and indicates what it returns ('most relevant pages'). However, it doesn't explicitly differentiate from sibling tools like 'search_shelby_docs' vs 'list_shelby_doc_pages' or 'read_shelby_doc', which might have overlapping functionality.
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?
The description provides no guidance on when to use this tool versus alternatives like 'list_shelby_doc_pages' or 'read_shelby_doc'. It lacks context on scenarios where searching is preferred over listing or reading specific documents, and offers no exclusions or prerequisites for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0get_shelby_doc_chunklist_shelby_doc_pagesread_shelby_docsearch_shelby_docsScored across 4 tools
Multiple tools have overlapping purposes that could cause confusion. The 'read_shelby_doc' tool appears to cover most of the functionality of 'get_shelby_doc_chunk' and 'search_shelby_docs', as it can read by exact path, title, URL, page ID, or fuzzy query. This creates ambiguity about when to use each tool, especially between 'read_shelby_doc' and 'search_shelby_docs' for fuzzy queries.
The naming follows a mostly consistent pattern with 'shelby_doc' as the common prefix and snake_case throughout. However, there's a minor deviation with 'list_shelby_doc_pages' using 'pages' while others use 'doc' or 'docs', which slightly breaks consistency but doesn't significantly impact readability.
With 4 tools, the count is borderline for a documentation server. It feels slightly thin as there might be room for additional operations like updating or managing documentation, but it's reasonable for basic read-only access. The scope appears limited to retrieval and listing, which the tools cover adequately in number.
For a documentation server, the surface covers reading, listing, and searching, which are core operations. However, there are notable gaps such as no create, update, or delete tools, which might be expected if the server supports documentation management. This limits the server to read-only use cases, making it incomplete for full lifecycle coverage.
An MCP server that gives your AI access to the source code and docs of all public github repos
MCP server for accessing curated awesome list documentation
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
Read-only MCP server exposing a user ORANO library to their own AI agent.
