# MCP Documentation Helper

> An AI-powered developer tool that provides LLMs with instant access to MCP protocol specifications and TypeScript SDK documentation.

## Overview

MCP Documentation Helper is a Model Context Protocol (MCP) server that exposes comprehensive MCP documentation as structured resources. It enables AI assistants like Claude to provide accurate, context-aware guidance when building custom MCP servers.

### Features

- 📚 **Complete Documentation Access** - Full MCP protocol specification and TypeScript SDK docs
- 🔍 **Context-Aware Search** - Intelligent search with relevance scoring and focused results
- 📋 **Code Templates** - Ready-to-use implementation patterns for common MCP use cases
- 🎯 **Categorized Resources** - Quick access to tools, resources, prompts, transports, and examples
- 🤖 **AI-Optimized** - Designed specifically for LLM-assisted development workflows

## Prerequisites

- Node.js 18+ or Bun
- An MCP client (Claude Desktop, Cursor, or any MCP-compatible client)

## Installation

### 1. Clone the Repository

```bash
git clone https://github.com/yourusername/mcp-documentation-helper.git
cd mcp-documentation-helper
```

### 2. Install Dependencies

**Using npm:**
```bash
npm install
```

**Using Bun:**
```bash
bun install
```

That's it! The repository includes all necessary MCP documentation files in the `data` directory.

## Usage

### Running Locally

**Using npm:**
```bash
npm run dev
```

**Using Bun:**
```bash
bun run dev
```

**Using Node directly (after building):**
```bash
npm run build
npm run start
```

### Connecting to Claude Desktop

1. Open your Claude Desktop configuration file:
   - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
   - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
   - **Linux**: `~/.config/Claude/claude_desktop_config.json`

2. Add the MCP server configuration:

**For npm/Node:**
```json
{
  "mcpServers": {
    "mcp-docs": {
      "command": "node",
      "args": [
        "/absolute/path/to/mcp-documentation-helper/build/index.js"
      ]
    }
  }
}
```

**For Bun:**
```json
{
  "mcpServers": {
    "mcp-docs": {
      "command": "bun",
      "args": [
        "index.ts"
      ],
      "cwd": "/absolute/path/to/mcp-documentation-helper"
    }
  }
}
```

3. Replace `/absolute/path/to/mcp-documentation-helper` with your actual project path
4. Restart Claude Desktop

### Connecting to Cursor

1. Open Cursor Settings → MCP Servers
2. Click "Add MCP Server"
3. Configure the server:

**For npm/Node:**
```json
{
  "name": "mcp-docs",
  "command": "node",
  "args": [
    "/absolute/path/to/mcp-documentation-helper/build/index.js"
  ]
}
```

**For Bun:**
```json
{
  "name": "mcp-docs",
  "command": "bun",
  "args": [
    "index.ts"
  ],
  "cwd": "/absolute/path/to/mcp-documentation-helper"
}
```

4. Save and restart Cursor

### Using with VS Code (via MCP extension)

1. Install the MCP extension for VS Code
2. Add to your workspace settings (`.vscode/settings.json`):

```json
{
  "mcp.servers": {
    "mcp-docs": {
      "command": "node",
      "args": [
        "/absolute/path/to/mcp-documentation-helper/build/index.js"
      ]
    }
  }
}
```

## Available Resources

Once connected, the following resources are available:

| Resource URI | Description |
|--------------|-------------|
| `mcp://docs/complete` | Full MCP protocol and SDK documentation |
| `mcp://docs/quick-start` | Getting started guide |
| `mcp://docs/tools` | Tool implementation reference |
| `mcp://docs/resources` | Resource implementation reference |
| `mcp://docs/prompts` | Prompt implementation reference |
| `mcp://docs/transport` | Transport setup (stdio, HTTP, SSE) |
| `mcp://docs/examples` | Working code examples |

## Available Tools

### search-mcp-docs
Search across all MCP documentation with context-aware results.

**Parameters:**
- `query` (string): What you want to learn or implement
- `focus` (optional): `all`, `implementation`, `concepts`, `examples`, or `troubleshooting`

### get-implementation-template
Get code templates for common MCP patterns.

**Available Templates:**
- `basic-server` - Basic MCP server structure
- `tool-with-validation` - Tool with Zod validation
- `resource-static` - Static resource
- `resource-dynamic` - Dynamic resource with parameters
- `prompt-simple` - Simple prompt template
- `stdio-server` - stdio transport setup
- `http-server` - HTTP transport setup
- `error-handling` - Error handling patterns

## Available Prompts

### build-server
Start building a new MCP server with guided assistance.

### debug-server
Get help debugging an MCP server issue.

## Example Usage

Once connected to Claude Desktop or Cursor, you can:

```
You: "I want to build an MCP server that connects to a PostgreSQL database"

Claude: *Uses mcp-docs resources to provide accurate implementation guidance*
```

```
You: "How do I implement a dynamic resource with parameters?"

Claude: *Searches documentation and provides relevant examples*
```

```
You: "Show me how to set up an HTTP transport"

Claude: *Retrieves transport documentation and code templates*
```

## Development

### Project Structure

```
mcp-documentation-helper/
├── data/                      # Documentation files
│   ├── llms-full.txt         # MCP protocol documentation
│   └── typescript-sdk-readme.md  # TypeScript SDK docs
├── index.ts                   # Main server implementation
├── package.json              # Dependencies and scripts
└── tsconfig.json             # TypeScript configuration
```

### Scripts

- `npm run dev` - Run in development mode with tsx
- `npm run build` - Build TypeScript to JavaScript
- `npm run start` - Run the built server
- `bun run dev` - Run with Bun (if using Bun)

## How It Works

1. **Documentation Parsing**: The server parses MCP protocol and SDK documentation into structured sections
2. **Resource Exposure**: Documentation is exposed through MCP resources with semantic URIs
3. **Intelligent Search**: Built-in search tool provides context-aware results with relevance scoring
4. **Code Templates**: Pre-built templates help jumpstart common implementation patterns
5. **AI Integration**: LLMs can access documentation through standard MCP protocols

## Troubleshooting

### Server Not Showing Up in Claude Desktop

1. Check that the path in the config is absolute, not relative
2. Verify the `data` directory contains both required files
3. Restart Claude Desktop completely
4. Check Claude Desktop logs for errors

### Documentation Files Not Found

The repository includes all necessary documentation files. If you encounter this error:
1. Ensure you cloned the full repository with all files
2. Check that the `data` directory exists with both files:
```bash
ls data/
# Should show:
# llms-full.txt
# typescript-sdk-readme.md
```

### Build Errors (Node/npm)

Make sure you've run the build command before starting:
```bash
npm run build
npm run start
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Acknowledgments

- Built with the [Model Context Protocol SDK](https://github.com/modelcontextprotocol/typescript-sdk)
- Documentation sourced from [modelcontextprotocol.io](https://modelcontextprotocol.io)
- Inspired by the [Building MCP with LLMs](https://modelcontextprotocol.io/docs/guides/building-mcp-with-llms) guide

## Links

- [MCP Documentation](https://modelcontextprotocol.io)
- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
- [Claude Desktop](https://claude.ai/download)
- [Cursor](https://cursor.sh)

---

Made with ❤️ for the MCP community