Skip to main content
Glama
RTFD (Read The F*****g Docs)

RTFD (Read The F*****g Docs)

by aserper

RTFD Logo RTFD (Read The F*****g Docs) MCP Server

Tests GHCR PyPI Supported Python versions License: MIT

GitHub stars GitHub forks

The RTFD (Read The F*****g Docs) MCP Server acts as a bridge between Large Language Models (LLMs) and real-time documentation. It allows coding agents to query package repositories like PyPI, npm, crates.io, GoDocs, DockerHub, GitHub, and Google Cloud Platform (GCP) to retrieve the most up-to-date documentation and context.

This server solves a common problem where LLMs hallucinate APIs or provide outdated code examples because their training data is months or years old. By giving agents access to the actual documentation, RTFD ensures that generated code is accurate and follows current best practices.

⚠️ Security Warning

Security Warning: This MCP server grants agents access to unverified code and content from external sources (GitHub, PyPI, etc.). This introduces significant risks, including indirect prompt injection and the potential for malicious code execution, particularly when operating in autonomous or "YOLO" modes. Use at your own risk. The maintainers assume no responsibility for any damage or security compromises resulting from the use of this tool.

You can mitigate these risks by configuring specific environment variables to restrict functionality. For example, setting RTFD_FETCH=false disables all content fetching tools (allowing only metadata lookups), and VERIFIED_BY_PYPI=true restricts Python package documentation to only PyPI-verified sources. See the Configuration section for more details.

Related MCP server: Context7 MCP

Why use RTFD?

  • Accuracy: Agents can access the latest documentation for libraries, ensuring they use the correct version-specific APIs and avoid deprecated methods.

  • Context Awareness: Instead of just getting a raw text dump, the server extracts key sections like installation instructions, quickstart guides, and API references, giving the agent exactly what it needs.

  • Privacy: Unlike cloud-based documentation services, RTFD runs entirely on your local machine. Your queries are sent DIRECTLY to the source (no servers in the middle, no API keys needed, etc) and the documentation you access never leave your system, ensuring complete privacy and no data collection.

  • Supported Sources: PyPI (Python), npm (JavaScript/TypeScript), crates.io (Rust), GoDocs (Go), Zig docs, DockerHub, GitHub Container Registry (GHCR), GitHub repositories, and Google Cloud Platform (GCP).

Use Cases

RTFD helps in scenarios like:

  • Refactoring old code: Fetch current pandas docs to find deprecated methods and their replacements. Instead of guessing what changed, the LLM reads the actual upgrade guide.

  • Unfamiliar libraries: Integrating a Rust crate you've never seen? Look up the exact version, feature flags, and examples directly from the docs instead of guessing the API from general patterns.

  • Libraries after training cutoff: Using a library released after the LLM's training data ends? Fetch the actual README and code examples from GitHub so the LLM can write correct usage instead of hallucinating APIs.

  • Docker optimization: When optimizing a Dockerfile, inspect the official python:3.11-slim image to see exactly what packages and OS layers are included, rather than making assumptions.

  • Dependency audits: Check PyPI, npm, and crates.io for available updates across all your dependencies. The LLM sees the latest versions and can generate an audit report without manually visiting each registry.

Dependency audit example

Features

  • Documentation Content Fetching: Retrieve actual documentation content (README and key sections) from PyPI, npm, and GitHub rather than just URLs.

  • Smart Section Extraction: Automatically prioritizes and extracts relevant sections such as "Installation", "Usage", and "API Reference" to reduce noise.

  • Format Conversion: Automatically converts reStructuredText and HTML to Markdown for consistent formatting and easier consumption by LLMs.

  • Multi-Source Search: Aggregates results from PyPI, npm, crates.io, GoDocs, Zig docs, DockerHub, GHCR, GitHub, and GCP.

  • GitHub Repository Browsing: Browse repository file trees (list_repo_contents, get_repo_tree) and read source code files (get_file_content) directly.

  • GitHub Packages (GHCR): List packages and get versions for any GitHub user or organization to find the right image tag.

  • PyPI Verification: Optional security feature (VERIFIED_BY_PYPI) to ensure packages are verified by PyPI before fetching documentation.

  • Smart GCP Search: Hybrid search approach combining local service mapping with cloud.google.com search to find documentation for any Google Cloud service.

  • Pluggable Architecture: Easily add new documentation providers by creating a single provider module.

  • Error Resilience: Failures in one provider do not crash the server; the system is designed to degrade gracefully.

Installation

Claude Code Plugin (For Claude Code Users)

Install RTFD as a Claude Code plugin in two steps:

# Step 1: Add the RTFD marketplace
claude plugin marketplace add aserper/RTFD

# Step 2: Install the plugin
claude plugin install rtfd-mcp@rtfd-marketplace

For detailed configuration options and installation alternatives, see PLUGIN.md.

pip install rtfd-mcp

Or with uv:

uv pip install rtfd-mcp

From source

Clone the repository and install:

git clone https://github.com/aserper/RTFD.git
cd RTFD
uv sync --extra dev

Docker (GHCR)

You can run RTFD directly from the GitHub Container Registry without installing Python or dependencies locally.

docker run -i --rm \
  -e GITHUB_AUTH=token \
  -e GITHUB_TOKEN=your_token_here \
  ghcr.io/aserper/rtfd:latest

Available Tags:

  • :latest - Stable release (updates on new releases)

  • :edge - Development build (updates on push to main)

  • :vX.X.X - Specific version tags

Quickstart

RTFD is an MCP server that needs to be configured in your AI agent of choice.

1. Install RTFD

pip install rtfd-mcp
# or with uv:
uv pip install rtfd-mcp

2. Configure your Agent

Claude Code

Simplest Method (Recommended): Use Claude Code plugin marketplace:

# Step 1: Add the RTFD marketplace
claude plugin marketplace add aserper/RTFD

# Step 2: Install the plugin
claude plugin install rtfd-mcp@rtfd-marketplace

Alternative Methods:

Manually add RTFD as an MCP server using the following command to automatically add it to your configuration:

# Using GITHUB_TOKEN for authentication (default)
claude mcp add rtfd -- command="rtfd" --env GITHUB_AUTH=token --env GITHUB_TOKEN=your_token_here --env RTFD_FETCH=true

# Or using GitHub CLI for authentication
claude mcp add rtfd -- command="rtfd" --env GITHUB_AUTH=cli --env RTFD_FETCH=true

# Or using both methods with fallback
claude mcp add rtfd -- command="rtfd" --env GITHUB_AUTH=auto --env GITHUB_TOKEN=your_token_here --env RTFD_FETCH=true

# Or using Docker
claude mcp add rtfd -- type=docker -- image=ghcr.io/aserper/rtfd:latest --env GITHUB_AUTH=token --env GITHUB_TOKEN=your_token_here

Or manually edit ~/.claude.json:

{
  "mcpServers": {
    "rtfd": {
      "command": "rtfd",
      "env": {
        "GITHUB_AUTH": "token", // Options: "token", "cli", "auto", or "disabled"
        "GITHUB_TOKEN": "your_token_here",
        "RTFD_FETCH": "true"
      }
    }
  }
}

Cursor

  1. Go to Settings > Cursor Settings > MCP Servers

  2. Click "Add new MCP server"

  3. Name: rtfd

  4. Type: stdio

  5. Command: rtfd

  6. Add Environment Variable: GITHUB_AUTH = token (Options: token, cli, auto, disabled)

  7. Add Environment Variable: GITHUB_TOKEN = your_token_here

  8. Add Environment Variable: RTFD_FETCH = true

Or manually edit ~/.cursor/mcp.json:

{
  "mcpServers": {
    "rtfd": {
      "command": "rtfd",
      "env": {
        "GITHUB_AUTH": "token", // Options: "token", "cli", "auto", or "disabled"
        "GITHUB_TOKEN": "your_token_here",
        "RTFD_FETCH": "true"
      }
    }
  }
}

Windsurf

  1. Open Settings > Advanced Settings > Model Context Protocol

  2. Edit ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "rtfd": {
      "command": "rtfd",
      "env": {
        "GITHUB_AUTH": "token", // Options: "token", "cli", "auto", or "disabled"
        "GITHUB_TOKEN": "your_token_here",
        "RTFD_FETCH": "true"
      }
    }
  }
}

Gemini CLI

Edit ~/.gemini/settings.json:

{
  "mcpServers": {
    "rtfd": {
      "command": "rtfd",
      "env": {
        "GITHUB_AUTH": "token", // Options: "token", "cli", "auto", or "disabled"
        "GITHUB_TOKEN": "your_token_here",
        "RTFD_FETCH": "true"
      }
    }
  }
}

Codex

Edit ~/.codex/config.toml:

[mcpServers.rtfd]
command = "rtfd"
[mcpServers.rtfd.env]
GITHUB_AUTH = "token" # Options: "token", "cli", "auto", or "disabled"
GITHUB_TOKEN = "your_token_here"
RTFD_FETCH = "true"

3. Verify

Ask your agent: "What tools do you have available?" or "Search for documentation on pandas".

Testing with MCP Inspector

The MCP Inspector tool allows you to test the RTFD MCP server directly without requiring an IDE or agent integration. This is useful for development and debugging.

Installation

# Install the MCP Inspector tool globally
npm install -g @modelcontextprotocol/inspector

Usage

# Run RTFD with the MCP Inspector
npx @modelcontextprotocol/inspector rtfd

# If you need to pass environment variables
npx @modelcontextprotocol/inspector rtfd -e GITHUB_AUTH=auto

The Inspector tool will open an interactive terminal where you can directly call the RTFD tools and see their responses.

Configuration

RTFD can be configured using the following environment variables:

Variable

Default

Description

GITHUB_AUTH

token

GitHub authentication method: token (use GITHUB_TOKEN only), cli (use gh CLI auth only), auto (try GITHUB_TOKEN, then gh CLI), or disabled (no GitHub access).

GITHUB_TOKEN

None

GitHub API token. Highly recommended to increase rate limits (60 -> 5000 requests/hour).

RTFD_FETCH

true

Enable/disable content fetching tools. Set to false to only allow metadata lookups.

RTFD_CACHE_ENABLED

true

Enable/disable caching. Set to false to disable.

RTFD_CACHE_TTL

604800

Cache time-to-live in seconds (default: 1 week).

RTFD_TRACK_TOKENS

false

Enable/disable token usage statistics in tool response metadata.

RTFD_CHUNK_TOKENS

2000

Maximum tokens per response chunk. Set to 0 to disable chunking. Prevents context overflow from large documentation.

VERIFIED_BY_PYPI

false

If true, only allows fetching documentation for packages verified by PyPI.

Token Optimization with Deferred Loading

RTFD provides 33 tools across multiple providers. By default, all tool descriptions are loaded into context, consuming ~10-15K tokens. You can reduce this to ~2-3K tokens (~80-85% reduction) using the defer_loading feature.

How It Works

defer_loading is a client-side configuration that marks tools as discoverable but not initially loaded. When an LLM needs a deferred tool, it's loaded on-demand. RTFD provides tier classifications and a config generator to help you configure this.

Tool Tier Classification

Tier

Defer

Category

Tools

1

No

Core

search_library_docs, github_repo_search

2

Yes

Frequent

pypi_metadata, npm_metadata, github_code_search, search_docker_images

3

Yes

Regular

fetch_pypi_docs, fetch_npm_docs, fetch_github_readme, list_repo_contents, get_file_content, get_repo_tree, docker_image_metadata, fetch_docker_image_docs, search_crates, crates_metadata

4

Yes

Situational

get_commit_diff, fetch_dockerfile, search_gcp_services, fetch_gcp_service_docs, godocs_metadata, fetch_godocs_docs

5

Yes

Niche

list_github_packages, get_package_versions, zig_docs

6

Yes

Admin

get_cache_info, get_cache_entries, get_next_chunk

Result: 2 tools always loaded, 31 tools deferred (~93% token reduction)

Config Generator CLI

RTFD includes a CLI tool to generate optimized configurations:

# Generate Claude Desktop configuration
rtfd-config --format claude-desktop

# Generate with custom defer tiers (e.g., only defer tiers 4-6)
rtfd-config --format claude-desktop --defer-tiers 4,5,6

# View tier summary
rtfd-config --format summary

# List all tools with tier info
rtfd-config --format tools

Sample Claude Desktop Configuration

{
  "mcpServers": {
    "rtfd": {
      "command": "uvx",
      "args": ["rtfd-mcp"],
      "type": "mcp_toolset",
      "default_config": {"defer_loading": true},
      "configs": {
        "search_library_docs": {"defer_loading": false},
        "github_repo_search": {"defer_loading": false}
      }
    }
  }
}

This configuration keeps the two most essential tools always loaded while deferring everything else.

Programmatic Access

You can access tier information programmatically:

from RTFD.config_generator import (
    get_all_tools_with_tiers,
    get_tools_by_tier,
    generate_claude_desktop_config,
)

# Get all tools with their tier info
tools = get_all_tools_with_tiers()
print(tools["search_library_docs"])  # {'tier': 1, 'defer_recommended': False, 'category': 'search'}

# Get tools organized by tier
by_tier = get_tools_by_tier()
print(by_tier[1])  # ['github_repo_search', 'search_library_docs']

# Generate config programmatically
config = generate_claude_desktop_config(defer_tiers=[3, 4, 5, 6])

Releases & Versioning

For maintainers, see CONTRIBUTING.md for the automated release process.

Available Tools

All tool responses are returned in JSON format.

Aggregator

  • search_library_docs(library, limit=5): Combined lookup across all providers (PyPI, npm, crates.io, GoDocs, GCP, GitHub). Note: Zig and DockerHub are accessed via dedicated tools.

Cache Management

  • get_cache_info(): Get cache statistics including entry count, database size, and location.

  • get_cache_entries(): Get detailed information about all cached items including age, size, and content preview.

Documentation Content Fetching

  • fetch_pypi_docs(package, max_bytes=20480): Fetch Python package documentation from PyPI.

  • fetch_npm_docs(package, max_bytes=20480): Fetch npm package documentation.

  • fetch_godocs_docs(package, max_bytes=20480): Fetch Go package documentation from godocs.io (e.g., 'github.com/gorilla/mux').

  • fetch_gcp_service_docs(service, max_bytes=20480): Fetch Google Cloud Platform service documentation from docs.cloud.google.com (e.g., "storage", "compute", "bigquery").

  • fetch_github_readme(repo, max_bytes=20480): Fetch README from a GitHub repository (format: "owner/repo").

  • fetch_docker_image_docs(image, max_bytes=20480): Fetch Docker image documentation and description from DockerHub (e.g., "nginx", "postgres", "user/image").

  • fetch_dockerfile(image): Fetch the Dockerfile for a Docker image by parsing its description for GitHub links (best-effort).

Metadata Providers

  • pypi_metadata(package): Fetch Python package metadata.

  • npm_metadata(package): Fetch JavaScript package metadata.

  • crates_metadata(crate): Get Rust crate metadata.

  • search_crates(query, limit=5): Search Rust crates.

  • godocs_metadata(package): Retrieve Go package documentation.

  • search_gcp_services(query, limit=5): Search Google Cloud Platform services by name or keyword (e.g., "storage", "compute", "bigquery").

  • zig_docs(query): Search Zig documentation.

  • docker_image_metadata(image): Get DockerHub Docker image metadata (stars, pulls, description, etc.).

  • search_docker_images(query, limit=5): Search for Docker images on DockerHub.

  • github_repo_search(query, limit=5, language="Python"): Search GitHub repositories.

  • github_code_search(query, repo=None, limit=5): Search code on GitHub.

  • list_github_packages(owner, package_type="container"): List GitHub packages for a user or organization.

  • get_package_versions(owner, package_type, package_name): Get versions for a specific GitHub package.

  • list_repo_contents(repo, path=""): List contents of a directory in a GitHub repository (format: "owner/repo").

  • get_file_content(repo, path, max_bytes=102400): Get content of a specific file from a GitHub repository.

  • get_repo_tree(repo, recursive=False, max_items=1000): Get the complete file tree of a GitHub repository.

  • get_commit_diff(repo, base, head): Get the diff between two commits, branches, or tags.

LogScale (Humio) Query Language

  • search_logscale_docs(query, limit=10): Search LogScale query language documentation for syntax topics, functions, and operators.

  • list_logscale_functions(category=None): List LogScale functions by category (aggregate, string, math, regex, etc.), or list all categories when no category is specified.

  • logscale_syntax(topic, max_bytes=20480): Fetch detailed syntax documentation for a topic (filters, operators, fields, regex, time, macros, etc.).

  • logscale_function(function_name, max_bytes=20480): Fetch documentation for a specific LogScale function (e.g., "regex", "splitString", "array:append").

Provider-Specific Notes

GCP (Google Cloud Platform)

  • Service Discovery: Uses a local service mapping (20+ common services), direct search on cloud.google.com (for general queries), and GitHub API search of the googleapis/googleapis repository.

  • Documentation Source: Fetches documentation by scraping docs.cloud.google.com and converting to Markdown.

  • GitHub Authentication: Configure using GITHUB_AUTH environment variable. Options are token (default), cli, auto, or disabled.

  • GitHub Token: Optional but recommended. Without a GITHUB_TOKEN, GitHub API search is limited to 60 requests/hour. With a token, the limit increases to 5,000 requests/hour.

  • Supported Services: Cloud Storage, Compute Engine, BigQuery, Cloud Functions, Cloud Run, Pub/Sub, Firestore, GKE, App Engine, Cloud Vision, Cloud Speech, IAM, Secret Manager, and more.

  • Service Name Formats: Accepts various formats (e.g., "storage", "cloud storage", "Cloud Storage", "kubernetes", "k8s" for GKE).

LogScale (Humio)

  • Documentation Source: Fetches documentation from the LogScale library.

  • Syntax Topics: Comments, filters, operators, fields, user-input, conditional, array, expressions, user-functions, function-calls, time, timezones, relative-time, macros, regex, regex-syntax, regex-flags, and regex-engines.

  • Function Categories: Aggregate, array, comparison, conditional, data-manipulation, event, filter, formatting, geolocation, hash, join, math, network, parsing, regex, security, statistics, string, time-date, and widget.

  • No Authentication Required: All documentation is publicly accessible.

Other Providers

  • Token Counting: Disabled by default. Set RTFD_TRACK_TOKENS=true to see token stats in Claude Code logs.

  • Rate Limiting: The crates.io provider respects the 1 request/second limit.

  • Dependencies: mcp, httpx, beautifulsoup4, markdownify, docutils, tiktoken.

Architecture

  • Entry point: src/RTFD/server.py contains the main search orchestration tool. Provider-specific tools are in src/RTFD/providers/.

  • Framework: Uses mcp.server.fastmcp.FastMCP to declare tools and run the server over stdio.

  • HTTP layer: httpx.AsyncClient with a shared _http_client() factory that applies timeouts, redirects, and user-agent headers.

  • Data model: Responses are plain dicts for easy serialization over MCP.

  • Serialization: Tool responses use serialize_response_with_meta() from utils.py.

  • Token counting: Optional token statistics in the meta field (disabled by default). Enable with RTFD_TRACK_TOKENS=true.

Serialization and Token Counting

Tool responses are handled by serialize_response_with_meta() in utils.py:

  • Token statistics: When RTFD_TRACK_TOKENS=true, the response includes a _meta field with token counts (tokens_json, tokens_sent, bytes_json).

  • Token counting: Uses tiktoken library with cl100k_base encoding (compatible with Claude models).

  • Zero-cost metadata: Token statistics appear in the _meta field of CallToolResult, which is visible in Claude Code's special metadata logs but NOT sent to the LLM, costing 0 tokens.

Token-Efficient Tool Descriptions

RTFD uses a compact, structured format for MCP tool descriptions to minimize token consumption while preserving semantic clarity. With 29 tools exposed to LLMs, verbose descriptions would consume ~6,000+ tokens per context load. The optimized format reduces this to ~1,500 tokens—a 75% reduction.

Design Principles

  1. Terse summaries - One-line description of what the tool does

  2. Structured metadata - When:, Args:, Ex: format for easy parsing

  3. Inline examples - Compact parameter examples with actual values

  4. Cross-references - See also: for related tools instead of verbose explanations

  5. No redundancy - Avoid describing response format (LLMs see the actual response)

Example Format

"""
{One-line summary}. For related usage, see other_tool.

When: {brief condition}
Args: param="example_value", param2=default_value
Ex: tool_name("arg") → brief result description
"""

This format provides LLMs with exactly the information needed to:

  • Understand when to use the tool

  • Call the tool with correct parameters

  • Interpret what the response represents

For guidelines on writing tool descriptions, see Tool Description Guidelines in CONTRIBUTING.md.

Extensibility & Development

Adding Providers

The RTFD server uses a modular architecture. Providers are located in src/RTFD/providers/ and implement the BaseProvider interface. New providers are automatically discovered and registered upon server restart.

To add a custom provider:

  1. Create a new file in src/RTFD/providers/.

  2. Define async functions decorated with @mcp.tool().

  3. Ensure tools return CallToolResult using serialize_response_with_meta(result_data).

Development Notes

  • Dependencies: Declared in pyproject.toml (Python 3.10+).

  • Testing: Use pytest to run the test suite.

  • Environment: If you change environment-sensitive settings (e.g., GITHUB_TOKEN), restart the rtfd process.

Available Tools

27 tools
crates_metadataA
        Get detailed metadata for a specific Rust crate from crates.io.

        USE THIS WHEN: You need comprehensive information about a specific Rust crate.

        RETURNS: Detailed crate metadata including version, URLs, downloads, and license.
        Does NOT include full documentation content.

        The response includes:
        - Crate name, version, description
        - Documentation URL (docs.rs) - can be passed to WebFetch for full API docs
        - Repository URL (usually GitHub) - can be used with GitHub provider
        - Homepage, license, categories, keywords
        - Download statistics, creation/update dates
        - Minimum Rust version required

        Args:
            crate: Crate name (e.g., "serde", "tokio", "actix-web")

        Returns:
            JSON with comprehensive crate metadata

        Example: crates_metadata("serde") → Returns metadata with docs.rs link and GitHub repo
        

Inputs: crate (required).

docker_image_metadataA
        Get detailed metadata for a specific Docker image from DockerHub.

        USE THIS WHEN: You need comprehensive information about a Docker image (stats, description, tags).

        RETURNS: Image metadata including popularity metrics and description.
        Does NOT include full README documentation.

        The response includes:
        - Image name, namespace, description
        - Star count (popularity)
        - Pull count (total downloads)
        - Last updated timestamp
        - Official/community status

        Args:
            image: Docker image name (e.g., "nginx", "postgres", "username/custom-image")

        Returns:
            JSON with comprehensive image metadata

        Example: docker_image_metadata("nginx") → Returns stars, pulls, description for nginx image
        

Inputs: image (required).

fetch_dockerfileA
        Fetch the actual Dockerfile used to build a Docker image.

        USE THIS WHEN: You need to see exactly how an image is built (base image, installed packages, configuration).

        BEST FOR: Understanding image composition, security analysis, or learning how to build similar images.
        Attempts to find Dockerfile link in DockerHub description and fetches from source (usually GitHub).

        Useful for:
        - Seeing what base image is used
        - Identifying installed packages and dependencies
        - Understanding build process and optimizations
        - Security auditing (what's included in the image)
        - Learning Dockerfile best practices from official images

        Note: Not all images have publicly accessible Dockerfiles. Many official images do.

        Args:
            image: Docker image name (e.g., "nginx", "python", "postgres")

        Returns:
            JSON with Dockerfile content, source URL, and metadata (or error if not found)

        Example: fetch_dockerfile("nginx") → Returns Dockerfile from nginx GitHub repository
        

Inputs: image (required).

fetch_docker_image_docsA
        Fetch actual Docker image documentation and README from DockerHub.

        USE THIS WHEN: You need usage instructions, environment variables, volume mounts, or examples.

        BEST FOR: Understanding how to use a Docker image and configure it properly.
        Better than using curl or WebFetch because it:
        - Extracts README content from DockerHub
        - Includes image description and key details
        - Formats content in readable Markdown
        - Prioritizes important sections (Usage, Environment Variables, Examples)

        Typical content includes:
        - How to run the container
        - Available environment variables
        - Volume mount points
        - Port configurations
        - Usage examples and docker-compose snippets

        Args:
            image: Docker image name (e.g., "nginx", "postgres", "redis")
            max_bytes: Maximum content size, default 20KB (increase for detailed docs)

        Returns:
            JSON with README content, size, and source info

        Example: fetch_docker_image_docs("nginx") → Returns README with usage instructions
        

Inputs: image (required), max_bytes.

fetch_gcp_service_docsA
        Fetch actual documentation content for a GCP (Google Cloud Platform) service.

        USE THIS WHEN: You need detailed documentation, guides, tutorials, or API reference for a GCP service.

        BEST FOR: Getting complete documentation with setup instructions, usage examples, and API details.
        Better than using curl or WebFetch because it:
        - Automatically extracts relevant content from cloud.google.com
        - Converts HTML to clean Markdown format
        - Prioritizes important sections (Overview, Quickstart, API Reference)
        - Removes navigation, ads, and other non-content elements
        - Handles multi-word service names (e.g., "gke audit policy")

        Works with:
        - Exact service names (e.g., "Cloud Storage", "Compute Engine")
        - Common abbreviations (e.g., "GCS", "GKE", "BigQuery")
        - Multi-word queries (e.g., "gke audit policy configuration")

        Args:
            service: Service name or topic (e.g., "Cloud Storage", "vertex ai", "gke audit")
            max_bytes: Maximum content size, default 20KB (increase for comprehensive docs)

        Returns:
            JSON with documentation content, size, source URL, truncation status

        Example: fetch_gcp_service_docs("vertex ai") → Returns formatted documentation from cloud.google.com
        

Inputs: service (required), max_bytes.

fetch_github_readmeA
        Fetch README file from a GitHub repository.

        USE THIS WHEN: You need the project overview, quick start, or basic documentation.

        BEST FOR: Getting a high-level understanding of a project.
        The README typically contains installation, usage examples, and project description.

        For deeper code exploration, use:
        - get_repo_tree() to see the complete file structure
        - get_file_content() to read specific source files

        Args:
            repo: Repository in "owner/repo" format (e.g., "psf/requests")
            max_bytes: Maximum content size, default 20KB

        Returns: JSON with README content, size, and metadata

        Example: fetch_github_readme("psf/requests") → Returns the requests README
        

Inputs: repo (required), max_bytes.

fetch_godocs_docsA
        Fetch actual Go package documentation from godocs.io.

        USE THIS WHEN: You need package overview, function signatures, type definitions, or API reference.

        BEST FOR: Getting complete documentation for Go packages.
        Better than using curl or WebFetch because it:
        - Extracts package overview and descriptions
        - Includes function and type documentation
        - Formats content in readable text format
        - Limits output to avoid overwhelming context

        NOT SUITABLE FOR: Source code (use GitHub provider for that)

        Args:
            package: Go package path (e.g., "github.com/gin-gonic/gin", "golang.org/x/sync")
            max_bytes: Maximum content size, default 20KB (increase for large packages)

        Returns:
            JSON with documentation content, size, truncation status, and source info

        Example: fetch_godocs_docs("github.com/gin-gonic/gin") → Returns overview and API docs
        

Inputs: package (required), max_bytes.

fetch_npm_docsA
        Fetch actual npm package documentation from npm registry README.

        USE THIS WHEN: You need installation instructions, usage examples, API reference, or quickstart guides.

        BEST FOR: Getting complete, formatted documentation for JavaScript/Node.js packages.
        Better than using curl or WebFetch because it:
        - Automatically extracts relevant sections (Installation, Usage, Examples, API)
        - Prioritizes most useful content sections
        - Already in Markdown format (npm requires Markdown READMEs)

        NOT SUITABLE FOR: External documentation sites (use docs_url from npm_metadata + WebFetch)

        Args:
            package: npm package name (e.g., "express", "react", "axios")
            max_bytes: Maximum content size, default 20KB (increase for large packages)

        Returns:
            JSON with actual documentation content, size, truncation status, version

        Example: fetch_npm_docs("express") → Returns formatted README with installation and usage
        

Inputs: package (required), max_bytes.

fetch_pypi_docsA
        Fetch actual Python package documentation from PyPI README/description.

        USE THIS WHEN: You need installation instructions, usage examples, API reference, or quickstart guides.

        BEST FOR: Getting complete, formatted documentation for Python packages.
        Better than using curl or WebFetch because it:
        - Automatically extracts relevant sections (Installation, Usage, Examples)
        - Converts reStructuredText to Markdown
        - Prioritizes most useful content sections
        - Falls back to GitHub README if PyPI description is minimal

        NOT SUITABLE FOR: External documentation sites (use docs_url from pypi_metadata + WebFetch)

        Args:
            package: PyPI package name (e.g., "requests", "numpy", "pandas")
            max_bytes: Maximum content size, default 20KB (increase for large packages)
            ignore_verification: Skip PyPI verification check if VERIFIED_BY_PYPI is enabled

        Returns: JSON with actual documentation content, size, truncation status

        Example: fetch_pypi_docs("requests") → Returns formatted README with installation and usage
        

Inputs: package (required), max_bytes, ignore_verification.

get_cache_entriesB

Get detailed information about all cached entries.

Inputs: no named parameters.

get_cache_infoB

Get information about the current cache usage.

Inputs: no named parameters.

get_commit_diffA
        Get the diff between two commits, branches, or tags in a GitHub repository.

        USE THIS WHEN: You need to see what changed between two versions of code.

        BEST FOR: Analyzing changes, reviewing pull requests (by comparing branches), or checking version differences.
        Returns the raw git diff output.

        Args:
            repo: Repository in format "owner/repo" (e.g., "psf/requests")
            base: Base commit SHA, branch name, or tag (e.g., "main", "v1.0.0", "a1b2c3d")
            head: Head commit SHA, branch name, or tag (e.g., "feature-branch", "v1.1.0", "e5f6g7h")

        Returns:
            JSON with the raw git diff content.

        Example: get_commit_diff("psf/requests", "v2.28.0", "v2.28.1") → Returns diff between versions
        

Inputs: repo (required), base (required), head (required).

get_file_contentA
        Get content of a specific file from a GitHub repository.

        USE THIS WHEN: You need to read the actual source code or contents of a specific file.

        BEST FOR: Examining implementation details, understanding how code works, or reading configuration files.
        Returns the full file content (UTF-8 text only, binary files are rejected).

        Automatically handles:
        - Base64 decoding from GitHub API
        - UTF-8 conversion with safe truncation
        - Binary file detection

        Args:
            repo: Repository in format "owner/repo" (e.g., "psf/requests")
            path: Path to file (e.g., "requests/api.py")
            max_bytes: Maximum content size (default 100KB, increase for large files)

        Returns:
            JSON with file content, size, truncation status, and metadata

        Example: get_file_content("psf/requests", "requests/api.py") → Returns source code of api.py
        

Inputs: repo (required), path (required), max_bytes.

get_package_versionsA
        Get versions for a specific GitHub package.

        USE THIS WHEN: You found a package using list_github_packages and want to see available tags/versions.

        Args:
            owner: GitHub username or organization name
            package_type: Type of package (e.g., "container")
            package_name: Name of the package (e.g., "rtfd")

        Returns:
            JSON list of versions/tags.
        

Inputs: owner (required), package_type (required), package_name (required).

get_repo_treeA
        Get the full file tree of a GitHub repository.

        USE THIS WHEN: You need to see the overall structure and organization of a repository.

        BEST FOR: Understanding project layout, finding specific files, or getting a complete directory listing.
        Returns all file paths, types (file/directory), and sizes in a single call.

        Use recursive=True for complete tree (all files in all subdirectories).
        Use recursive=False for just top-level overview (faster, less data).

        After getting the tree, use:
        - get_file_content() to read specific files you identified
        - list_repo_contents() to browse specific directories in detail

        Args:
            repo: Repository in format "owner/repo" (e.g., "psf/requests")
            recursive: Whether to get full tree recursively (default False)
            max_items: Maximum number of items to return (default 1000)

        Returns:
            JSON with complete file tree structure, branch, and count

        Example: get_repo_tree("psf/requests", recursive=True) → Returns complete file listing
        

Inputs: repo (required), recursive, max_items.

godocs_metadataA
        Get Go package metadata from godocs.io (name, summary, URLs).

        USE THIS WHEN: You need basic package info or links to documentation sites.

        RETURNS: Package metadata ONLY - does NOT include actual documentation content.
        For full documentation, use fetch_godocs_docs instead.

        The response includes:
        - Package name and summary/description
        - godocs.io URL
        - pkg.go.dev source URL

        Args:
            package: Go package path (e.g., "github.com/gin-gonic/gin", "golang.org/x/tools")

        Example: godocs_metadata("github.com/gin-gonic/gin") → Returns metadata with summary
        

Inputs: package (required).

list_github_packagesA
        List packages (including GHCR images) for a GitHub user or organization.

        USE THIS WHEN: You want to find Docker images or other packages hosted on GitHub for a specific user/org.
        Note: GitHub does not support global package search; you must provide an owner.

        Args:
            owner: GitHub username or organization name (e.g. "github", "octocat")
            package_type: Type of package to list. Defaults to "container" (GHCR).
                          Options: "container", "npm", "maven", "rubygems", "nuget", "docker" (legacy)

        Returns:
            JSON list of packages with metadata (name, repository, version count, etc.)
        

Inputs: owner (required), package_type.

list_repo_contentsA
        List contents of a directory in a GitHub repository.

        USE THIS WHEN: You need to browse or explore the structure of a repository directory.

        BEST FOR: Discovering what files and folders exist in a specific location.
        Returns names, paths, types (file/dir), sizes for each item.

        Common workflow:
        1. Use github_repo_search() to find the repository
        2. Use get_repo_tree() to see the overall structure
        3. Use list_repo_contents() to browse specific directories
        4. Use get_file_content() to read individual files

        Args:
            repo: Repository in format "owner/repo" (e.g., "psf/requests")
            path: Path to directory (empty string for root, e.g., "src/utils")

        Returns:
            JSON with list of files and directories with metadata

        Example: list_repo_contents("psf/requests", "requests") → Lists files in requests/ directory
        

Inputs: repo (required), path.

npm_metadataA
        Get npm package metadata (name, version, URLs, maintainers).

        USE THIS WHEN: You need basic package info, version numbers, or links to external documentation.

        RETURNS: Package metadata ONLY - does NOT include actual documentation content.
        For full documentation, use fetch_npm_docs instead.

        The response includes:
        - Package name, version, description
        - Documentation URL (docs_url/homepage) - can be passed to WebFetch for external docs
        - Repository URL (usually GitHub)
        - License, keywords, maintainers

        Args:
            package: npm package name (e.g., "express", "react", "lodash")

        Example: npm_metadata("express") → Returns metadata with links to expressjs.com
        

Inputs: package (required).

pypi_metadataA
        Get Python package metadata from PyPI (name, version, URLs, summary).

        USE THIS WHEN: You need basic package info, version numbers, or links to external documentation.

        RETURNS: Package metadata ONLY - does NOT include actual documentation content.
        For full documentation, use fetch_pypi_docs instead.

        The response includes:
        - Package name, version, summary
        - Documentation URL (docs_url) - can be passed to WebFetch for external docs
        - Project URLs (homepage, repository, etc.)

        Args:
            package: PyPI package name (e.g., "requests", "flask", "django")
            ignore_verification: Skip PyPI verification check if VERIFIED_BY_PYPI is enabled

        Example: pypi_metadata("requests") → Returns metadata with docs_url pointing to readthedocs
        

Inputs: package (required), ignore_verification.

search_cratesA
        Search for Rust crates on crates.io by name or keywords.

        USE THIS WHEN: You need to find Rust packages/crates for a specific purpose or library.

        BEST FOR: Discovering which Rust crates exist for a topic or functionality.
        Returns multiple matching crates with names, versions, descriptions, download counts, and URLs.

        After finding a crate, use:
        - crates_metadata() to get detailed information about a specific crate
        - The documentation URL to read full docs (use WebFetch)

        Args:
            query: Search keywords (e.g., "http client", "web framework", "serde")
            limit: Maximum number of results (default 5, max 100)

        Returns:
            JSON with list of matching crates, total results, and metadata

        Example: search_crates("web framework") → Finds actix-web, rocket, axum, etc.
        

Inputs: query (required), limit.

search_docker_imagesA
        Search for Docker images on DockerHub by name or keywords.

        USE THIS WHEN: You need to find Docker container images for a specific service, application, or technology.

        BEST FOR: Discovering official and community Docker images.
        Returns multiple matching images with names, descriptions, star counts, pull counts, and whether they're official.

        After finding an image, use:
        - docker_image_metadata() for detailed information
        - fetch_docker_image_docs() for README and usage instructions
        - fetch_dockerfile() to see how the image is built

        Args:
            query: Search query (e.g., "nginx", "postgres", "machine learning", "python")
            limit: Maximum number of results (default 5)

        Returns:
            JSON with list of matching images including name, description, stars, pulls, official status

        Example: search_docker_images("postgres") → Finds official postgres image and alternatives
        

Inputs: query (required), limit.

search_gcp_servicesA
        Search for GCP (Google Cloud Platform) services and documentation.

        USE THIS WHEN: You need to find Google Cloud services, APIs, or documentation for a specific GCP topic.

        BEST FOR: Discovering which GCP services exist for a use case or finding service documentation.
        Returns multiple matching services with names, descriptions, API endpoints, and docs URLs.

        Searches:
        1. Local service mapping (exact and partial matches)
        2. cloud.google.com website (fallback for specific queries)
        3. googleapis GitHub repository (API definitions)

        After finding a service, use:
        - fetch_gcp_service_docs() to get full documentation content
        - The docs_url with WebFetch for external documentation

        Note: GitHub API search (fallback) is limited to 60 requests/hour without GITHUB_TOKEN.

        Args:
            query: Service name or keywords (e.g., "storage", "vertex ai", "gke audit", "bigquery")
            limit: Maximum number of results (default 5)

        Returns:
            JSON with list of matching services including name, description, API endpoint, docs URL

        Example: search_gcp_services("vertex ai") → Finds Vertex AI service with docs links
        

Inputs: query (required), limit.

search_library_docsC

Find docs for a library using PyPI metadata and GitHub repos combined. Returns data in JSON format with token statistics.

Inputs: library (required), limit.

zig_docsA
        Search Zig programming language documentation.

        USE THIS WHEN: You need information about Zig language features, syntax, stdlib, or concepts.

        BEST FOR: Learning Zig language specifics and finding relevant documentation sections.
        Searches the official Zig documentation (ziglang.org/documentation/master/) and returns
        matching sections with titles, summaries, and relevance scores.

        Good for queries about:
        - Language features (e.g., "comptime", "async", "optionals")
        - Standard library (e.g., "ArrayList", "HashMap", "allocators")
        - Memory management (e.g., "allocator", "defer", "errdefer")
        - Error handling (e.g., "error sets", "try", "catch")
        - Build system (e.g., "build.zig", "zig build")

        NOT SUITABLE FOR: Third-party Zig packages (use GitHub provider for that)

        Args:
            query: Search keywords (e.g., "comptime", "async", "ArrayList", "error handling")

        Returns:
            JSON with matching documentation sections, relevance scores, and source URL

        Example: zig_docs("comptime") → Returns sections about compile-time code execution
        

Inputs: query (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 27 tools

    Disambiguation4/5

    Most tools have distinct purposes targeting specific ecosystems (GitHub, Docker, npm, PyPI, etc.), but there is some overlap between fetch_*_docs tools and their corresponding *_metadata tools, which could cause confusion about when to use metadata vs. full docs. Additionally, get_cache_entries and get_cache_info are vague and could be conflated with other tools.

    Naming Consistency4/5

    The naming follows a consistent verb_noun pattern (e.g., fetch_godocs_docs, search_docker_images, get_file_content) with clear actions and targets. However, there are minor deviations like crates_metadata (plural noun) vs. docker_image_metadata (singular noun) and inconsistent use of underscores in compound terms (e.g., github_code_search vs. search_gcp_services).

    Tool Count3/5

    With 27 tools, the count is high but justifiable given the broad scope of fetching documentation and metadata across multiple ecosystems (GitHub, Docker, npm, PyPI, GCP, Rust, Go, Zig). However, it borders on being heavy and could overwhelm users, as some tools (like get_cache_entries/info) seem peripheral to the core purpose.

    Completeness5/5

    The toolset provides comprehensive coverage for documentation and metadata retrieval across supported ecosystems, including search, metadata fetching, and full documentation fetching. Each ecosystem has consistent tooling (e.g., search, metadata, docs fetch), and there are no obvious gaps for the stated purpose of reading documentation from various sources.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers