RTFD (Read The F*****g Docs)
The RTFD MCP Server bridges LLMs and real-time documentation, enabling AI agents to access up-to-date information from multiple sources to prevent hallucinations and generate accurate code.
Multi-Source Documentation Retrieval: Fetch documentation and metadata from PyPI (Python), npm (JavaScript/TypeScript), crates.io (Rust), GoDocs (Go), Zig docs, DockerHub, GitHub Container Registry (GHCR), GitHub repositories, and Google Cloud Platform services. Unified search queries across all sources simultaneously.
GitHub Repository Exploration: Search repositories and code, browse directory contents and file trees (recursive/non-recursive), read source files, fetch READMEs, and get commit diffs.
Smart Content Processing: Automatically extracts relevant sections (Installation, Usage, API Reference, Examples), converts formats (reStructuredText/HTML to Markdown), and prioritizes key content to reduce noise.
Cache Management: View cache statistics and entries with configurable TTL for improved performance.
Security & Privacy: Runs entirely locally with no data collection, configurable restrictions (PyPI verification, content fetching toggles), and flexible GitHub authentication options.
Token-Aware Responses: Optional token counting and configurable chunking to prevent context overflow.
Pluggable Architecture: Easily extensible with new documentation providers.
Provides tools for fetching Docker image documentation and metadata from DockerHub, including image descriptions, stats (stars, pulls), and Dockerfile retrieval for official and community images.
Enables comprehensive GitHub interaction including repository search, code search, browsing repository file trees, reading source files, viewing commit diffs, and managing GitHub Container Registry (GHCR) packages.
Provides access to Google Cloud Platform service documentation through hybrid search combining local service mapping with cloud.google.com, supporting 20+ services including Cloud Storage, Compute Engine, BigQuery, Cloud Functions, and GKE.
Fetches npm package documentation and metadata for JavaScript/TypeScript libraries, including README content, installation instructions, and package information.
Retrieves Python package documentation and metadata from PyPI, with smart section extraction for installation guides, quickstart instructions, and API references, plus optional verification filtering.
Provides search and metadata retrieval for Rust crates from crates.io, including crate information, version details, and documentation access.
Enables searching Zig language documentation to access language features and standard library information.
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., "@RTFD (Read The F*****g Docs) fetch the latest pandas API reference to check for deprecated methods"
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.
RTFD (Read The F*****g Docs) MCP Server
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=falsedisables all content fetching tools (allowing only metadata lookups), andVERIFIED_BY_PYPI=truerestricts 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
pandasdocs 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-slimimage 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.

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.comsearch 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-marketplaceFor detailed configuration options and installation alternatives, see PLUGIN.md.
From PyPI (Recommended)
pip install rtfd-mcpOr with uv:
uv pip install rtfd-mcpFrom source
Clone the repository and install:
git clone https://github.com/aserper/RTFD.git
cd RTFD
uv sync --extra devDocker (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:latestAvailable 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-mcp2. 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-marketplaceAlternative 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_hereOr 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
Go to Settings > Cursor Settings > MCP Servers
Click "Add new MCP server"
Name:
rtfdType:
stdioCommand:
rtfdAdd Environment Variable:
GITHUB_AUTH=token(Options:token,cli,auto,disabled)Add Environment Variable:
GITHUB_TOKEN=your_token_hereAdd 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
Open Settings > Advanced Settings > Model Context Protocol
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/inspectorUsage
# Run RTFD with the MCP Inspector
npx @modelcontextprotocol/inspector rtfd
# If you need to pass environment variables
npx @modelcontextprotocol/inspector rtfd -e GITHUB_AUTH=autoThe 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 authentication method: |
|
| GitHub API token. Highly recommended to increase rate limits (60 -> 5000 requests/hour). |
|
| Enable/disable content fetching tools. Set to |
|
| Enable/disable caching. Set to |
|
| Cache time-to-live in seconds (default: 1 week). |
|
| Enable/disable token usage statistics in tool response metadata. |
|
| Maximum tokens per response chunk. Set to |
|
| If |
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 |
|
2 | Yes | Frequent |
|
3 | Yes | Regular |
|
4 | Yes | Situational |
|
5 | Yes | Niche |
|
6 | Yes | Admin |
|
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 toolsSample 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_AUTHenvironment variable. Options aretoken(default),cli,auto, ordisabled.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=trueto 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.pycontains the main search orchestration tool. Provider-specific tools are insrc/RTFD/providers/.Framework: Uses
mcp.server.fastmcp.FastMCPto declare tools and run the server over stdio.HTTP layer:
httpx.AsyncClientwith 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()fromutils.py.Token counting: Optional token statistics in the
metafield (disabled by default). Enable withRTFD_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_metafield with token counts (tokens_json,tokens_sent,bytes_json).Token counting: Uses
tiktokenlibrary withcl100k_baseencoding (compatible with Claude models).Zero-cost metadata: Token statistics appear in the
_metafield ofCallToolResult, 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
Terse summaries - One-line description of what the tool does
Structured metadata -
When:,Args:,Ex:format for easy parsingInline examples - Compact parameter examples with actual values
Cross-references -
See also:for related tools instead of verbose explanationsNo 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:
Create a new file in
src/RTFD/providers/.Define async functions decorated with
@mcp.tool().Ensure tools return
CallToolResultusingserialize_response_with_meta(result_data).
Development Notes
Dependencies: Declared in
pyproject.toml(Python 3.10+).Testing: Use
pytestto run the test suite.Environment: If you change environment-sensitive settings (e.g.,
GITHUB_TOKEN), restart thertfdprocess.
Available Tools
27 toolscrates_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.
github_code_searchA
Search for code snippets across GitHub or within a specific repository.
USE THIS WHEN: You need to find code examples, function definitions, or usage patterns.
RETURNS: File paths and locations where code was found - NOT the actual file contents.
To read the files, use get_file_content() with the returned paths.
NOTE: Requires authentication - rate limited without GITHUB_TOKEN.
Args:
query: Code search query (e.g., "def parse_args", "class HTTPClient")
repo: Optional repository filter in "owner/repo" format
limit: Maximum number of results (default 5)
Example: github_code_search("async def fetch", repo="psf/requests")
Inputs: query (required), repo, limit.
github_repo_searchA
Search for GitHub repositories by keyword or topic.
USE THIS WHEN: You need to find repositories for a library, framework, or topic.
BEST FOR: Discovering which repository contains a specific project.
Returns repository names, descriptions, stars, and URLs - but NOT the code itself.
To explore code after finding a repo, use:
- get_repo_tree() to see all files
- list_repo_contents() to browse directories
- get_file_content() to read specific files
Args:
query: Search keywords (e.g., "machine learning", "web framework")
limit: Maximum number of results (default 5)
language: Filter by programming language (default "Python")
Example: github_repo_search("requests") → Finds psf/requests repository
Inputs: query (required), limit, language.
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
Scored across 27 tools
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.
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).
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.
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
Related MCP Connectors
Real-time package and vulnerability data (Python, npm, Cargo, Go, and more) for AI coding agents.
@latest documentation and code examples to 9000+ libraries for LLMs and AI code editors in a singl…
Provide your AI coding tools with token-efficient access to up-to-date technical documentation for…
Versioned documentation registry and semantic search for AI tools and coding assistants.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceProvides LLMs with up-to-date, version-specific documentation and code examples from library sources directly into prompts, eliminating outdated code generation and hallucinated APIs.MIT
- AlicenseAqualityDmaintenanceProvides up-to-date, version-specific documentation and code examples for libraries and frameworks directly into AI prompts, eliminating outdated code generation and hallucinated APIs.2MIT
- AlicenseAqualityDmaintenanceProvides LLMs with up-to-date, version-specific documentation and code examples directly from library sources, eliminating outdated training data and hallucinated APIs by fetching current documentation at prompt time.2MIT
- FlicenseNot gradedqualityDmaintenanceProvides real-time, up-to-date documentation for major LLM providers (OpenAI, Anthropic, Google Gemini) to prevent hallucinations and outdated code patterns in AI agents.7-