manuals-mcp-server

rmrfslashbin/manuals-mcp-server

3.2

If you are the rightful owner of manuals-mcp-server and would like to certify it and/or have it hosted online, please leave a comment on the right or send an email to dayong@mcphub.com.

A standalone MCP server for querying hardware and software documentation libraries.

Tools
4
Resources
0
Prompts
0

Manuals MCP Server

Standalone MCP server for querying hardware and software documentation libraries

A Model Context Protocol (MCP) server that provides structured access to any documentation library. Built for hardware and software manuals, with support for GPIO pinouts, protocol specifications, device specs, and full-text search.

Key Features

  • Standalone & Portable - Works with any documentation library, not tied to a specific repo
  • GPIO Pinout Queries - Get formatted pinout tables with alternate functions and interface filtering (I2C, SPI, UART, PWM)
  • Full-Text Search - Search across all documentation with SQLite FTS5
  • Cross-Domain Support - Index hardware devices, software libraries, and protocol specifications
  • MCPB Bundle Format - One-click installation via Claude Desktop or Claude Code

Installation

Option A: MCPB Bundle (Recommended)

Download the latest .mcpb bundle from releases and install:

claude mcp install manuals-mcp-server-1.0.0.mcpb

Or install via Claude Desktop's MCP server manager GUI.

Option B: From Source

git clone https://github.com/rmrfslashbin/manuals-mcp-server
cd manuals-mcp-server
npm install
npm run build

Configuration

The server requires two paths to be configured:

  1. MANUALS_DOCS_PATH - Path to your documentation library root
  2. MANUALS_DB_PATH - Path to SQLite database (auto-created, optional)

Project-Level Configuration

Create .mcp.json in your documentation repository:

{
  "mcpServers": {
    "manuals": {
      "command": "node",
      "args": ["/path/to/manuals-mcp-server/dist/index.js"],
      "env": {
        "MANUALS_DOCS_PATH": "/path/to/your/docs",
        "MANUALS_DB_PATH": "/path/to/manuals-mcp-server/data/manuals.db"
      },
      "description": "Hardware & Software Documentation Library"
    }
  }
}

When Claude Code opens this directory, the MCP server auto-connects.

User-Level Configuration (Global)

Add via Claude Code CLI for access across all projects:

claude mcp add --transport stdio manuals --scope user \
  -- node /path/to/manuals-mcp-server/dist/index.js

Then set environment variables in ~/.claude.json:

{
  "mcpServers": {
    "manuals": {
      "env": {
        "MANUALS_DOCS_PATH": "/path/to/your/docs",
        "MANUALS_DB_PATH": "/path/to/manuals-mcp-server/data/manuals.db"
      }
    }
  }
}

Claude Desktop Configuration

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS):

{
  "mcpServers": {
    "manuals": {
      "command": "node",
      "args": ["/path/to/manuals-mcp-server/dist/index.js"],
      "env": {
        "MANUALS_DOCS_PATH": "/path/to/your/docs",
        "MANUALS_DB_PATH": "/path/to/manuals-mcp-server/data/manuals.db"
      }
    }
  }
}

Building the Index

After configuration, build the search index:

# Using environment variable
MANUALS_DOCS_PATH=/path/to/docs npm run index

# Using command-line argument
npm run index -- --docs-path /path/to/docs

# View help
npm run index -- --help

The indexer scans for:

  • *_Reference.md - Device/software documentation
  • *_Protocol.md - Protocol specifications

Available Tools

get_pinout

Get GPIO pinout information for a hardware device.

Parameters:

  • device (string): Device name or ID (e.g., "raspberry-pi-4", "esp32-s3")
  • interface (string, optional): Filter by interface (i2c, spi, uart, pwm, gpio, all)

Example:

Get the I2C pins for Raspberry Pi 4

Returns formatted ASCII pinout table with GPIO numbers, alternate functions, and pull resistor configuration.

search

Full-text search across all indexed documentation.

Parameters:

  • query (string): Search query
  • domain (string, optional): Filter by domain (hardware, software, protocol, all)
  • type (string, optional): Filter by device type
  • limit (number, optional): Max results (default: 10)

Example:

Search for devices with I2C interface

Returns ranked results with device metadata, tags, specs, and file paths.

list_hardware

List all available hardware devices, organized by category.

Example:

Show me all available hardware

get_stats

Get statistics about the indexed documentation.

Example:

How many devices are indexed?

Documentation Format

The server expects markdown files with YAML frontmatter:

---
manufacturer: Company Name
model: MODEL-NUMBER
category: sbc/raspberry-pi
version: v1.0
date: 2024-03-12
tags: [wifi, bluetooth, gpio, i2c, spi]
datasheets:
  - datasheets/filename.pdf
specs:
  cpu: "Quad-core ARM Cortex-A72 @ 1.5GHz"
  ram: "1GB/2GB/4GB/8GB LPDDR4"
  power: "USB-C 5V @ 3A"
---

# Device Name

Documentation content here...

## GPIO Pinout

| Physical Pin | GPIO | Name | Default Pull | Alt Functions |
|--------------|------|------|--------------|---------------|
| 8            | 14   | TXD0 | Low          | UART0 TX, ... |
| 10           | 15   | RXD0 | Low          | UART0 RX, ... |

Important: YAML frontmatter MUST be at the very beginning of the file (byte 0).

Architecture

manuals-mcp-server/
├── manifest.json           # MCPB bundle manifest
├── src/
│   ├── index.ts           # MCP server entry point
│   ├── types/
│   │   └── index.ts       # TypeScript definitions
│   ├── db/
│   │   ├── schema.ts      # SQLite schema + initialization
│   │   └── queries.ts     # Database operations
│   ├── indexer/
│   │   ├── markdown-parser.ts  # Parse frontmatter + tables
│   │   └── builder.ts          # Build index from docs
│   └── tools/
│       ├── hardware.ts    # Hardware-specific tools
│       └── search.ts      # Search tools
├── scripts/
│   ├── build-index.ts     # CLI for indexing docs
│   └── pack-mcpb.js       # Create .mcpb bundle
├── data/
│   └── manuals.db         # SQLite database (generated)
└── dist/                  # Compiled JavaScript (generated)

Database Schema

SQLite with FTS5 full-text search:

  • devices - Main device/artifact table (id, domain, type, name, path, metadata)
  • pinouts - GPIO pin information (device_id, physical_pin, gpio_num, alt_functions)
  • specifications - Device specs (device_id, key, value, unit)
  • cross_references - Links between devices (from_device_id, to_device_id, relationship)
  • search_fts - FTS5 virtual table (device_id, name, content, tags)

Indexes on domain, type, GPIO numbers for fast queries.

Development

Build & Test Locally

npm install
npm run build
npm run index -- --docs-path /path/to/test/docs
npm start  # Run MCP server directly

Watch Mode

npm run dev              # Auto-rebuild on changes
npm run index:watch      # Auto-rebuild index on doc changes

Create MCPB Bundle

npm run pack

Creates manuals-mcp-server-1.0.0.mcpb in the root directory.

Type Checking

npm run typecheck

Clean Build Artifacts

npm run clean

Example Documentation Repositories

This server can index any documentation library. Examples:

  • Hardware Reference Library - Raspberry Pi, ESP32, sensors, displays, power supplies
  • Software Library Docs - APIs, frameworks, tools, libraries
  • Protocol Specifications - I2C, SPI, UART, MQTT, Modbus
  • Mixed Documentation - Hardware + software + protocols (recommended)

Troubleshooting

"No devices found"

Ensure you've built the index:

npm run index -- --docs-path /path/to/docs

Check that markdown files have YAML frontmatter at byte 0.

"Cannot find module" errors

Rebuild the project:

npm run build

Database locked

Only one server instance can access the database at a time. Close other instances.

MCP server not appearing

  1. Verify paths are absolute (not relative)
  2. Check npm run build succeeded
  3. Review Claude logs:
    • macOS: ~/Library/Logs/Claude/
    • Look for MCP connection errors

Index build fails

npm run index -- --docs-path /path/to/docs --help

Verify YAML frontmatter is at the top of markdown files.

Extending the Server

Adding a New Tool

  1. Create tool in src/tools/
  2. Define input schema with Zod
  3. Register in src/index.ts ListToolsRequestSchema
  4. Add handler in CallToolRequestSchema

Example:

// src/tools/my-tool.ts
import { z } from 'zod';

export const MyToolSchema = z.object({
  param: z.string().describe("Parameter description")
});

export function myTool(db: Database, args: z.infer<typeof MyToolSchema>) {
  // Query database, process results
  return {
    content: [{
      type: 'text',
      text: 'Tool result'
    }]
  };
}

Adding Database Tables

Modify src/db/schema.ts:

db.exec(`
  CREATE TABLE IF NOT EXISTS my_table (
    id INTEGER PRIMARY KEY,
    device_id TEXT NOT NULL,
    data TEXT,
    FOREIGN KEY (device_id) REFERENCES devices(id)
  )
`);

Update clearDatabase() and indexer in src/indexer/builder.ts.

Future Enhancements

  • Vector embeddings for semantic search (pgvector, ChromaDB)
  • PDF text extraction (pdf.js, pdfplumber)
  • Multi-language code example extraction
  • Version management for software docs (semver)
  • Diagram/image indexing (OCR, image embeddings)
  • Web interface for browsing documentation
  • REST API endpoint (in addition to MCP)

Contributing

Contributions welcome! Please:

  1. Use TypeScript with proper types
  2. Define tool schemas with Zod
  3. Use prepared statements for database queries
  4. Update tests (when implemented)
  5. Follow existing code style

License

MIT License - Copyright (c) 2025 Robert Sigler

See for details.

Author

Robert Sigler Email: code@sigler.io GitHub: @rmrfslashbin

Links

A standalone MCP server for any documentation library