Rustdocs MCP Server

Rust is the language of AI

An MCP (Model Context Protocol) server that provides comprehensive access to Rust crate documentation, source code analysis, dependency trees, and module structure visualization. Built for agents to gain quality insights into Rust projects and build with confidence.

Warning

This is an entirely vibe coded project and was created as an experiment to see if LLMs can build a fully functional tool without human oversight.

The Problem: Agents Building in the Dark

The rise of AI agents has revolutionized software development, with new tools and libraries emerging at an unprecedented pace. However, this rapid evolution creates a critical challenge: agents cannot reliably build with tools they weren't trained on.

When an agent tries to use a new Rust crate:

• 🚫 Training data is outdated — The model hasn't seen recent crates or API changes
• 🚫 Documentation scraping is inefficient — Web scraping GitHub or docs.rs is slow and unreliable
• 🚫 Examples aren't enough — Copy-pasting README examples provides surface-level understanding
• 🚫 Internal structure is opaque — Agents can't explore how modules, traits, and types interconnect

This leads to frustrated developers watching their agents fail repeatedly, guessing at APIs, and producing broken code.

The Solution: Deep Crate Intelligence

This MCP server gives agents the tools they need to truly understand Rust crates:

• 🔍 Explore internal structure — Navigate module hierarchies and type relationships
• 📖 Access complete documentation — Full rustdoc with signatures, fields, and methods
• 🔗 Trace dependencies — Understand what a crate depends on and why
• 💾 Work offline — Cache crates locally for instant, reliable access
• 🎯 Query precisely — Search by pattern, kind, or path to find exactly what's needed

With these capabilities, agents can build confidently with any Rust crate — even ones released yesterday.

Agent Capabilities

• Multi-source caching — crates.io, GitHub repositories, local filesystem paths
• Workspace support — Individual member analysis and caching for cargo workspaces
• Documentation search — Pattern matching with kind/path filtering and preview modes
• Item inspection — Detailed signatures, fields, methods, and documentation strings
• Source code access — Line-level precision with parameterized surrounding context
• Dependency analysis — Direct and transitive dependency trees with metadata
• Module structure — Hierarchical tree generation via cargo-modules integration
• Offline operation — Full functionality after initial crate caching
• Token management — Response truncation and preview modes for LLM compatibility

MCP Tools

Cache Management

• cache_crate - Download and cache a crate from various sources. Set source_type to one of: cratesio, github, or local
  • For cratesio: Provide version (e.g., {crate_name: "serde", source_type: "cratesio", version: "1.0.215"})
  • For github: Provide github_url and either branch OR tag (e.g., {crate_name: "my-crate", source_type: "github", github_url: "https://github.com/user/repo", tag: "v1.0.0"})
  • For local: Provide path, optional version (e.g., {crate_name: "my-crate", source_type: "local", path: "~/projects/my-crate"})
  • Optional features: Specific features to enable instead of --all-features. Use for crates with mutually exclusive features (e.g., {crate_name: "leptos-use", source_type: "cratesio", version: "0.15.8", features: ["axum"]})
• remove_crate - Remove cached crate versions to free disk space
• list_cached_crates - View all cached crates with versions and sizes
• list_crate_versions - List cached versions for a specific crate
• get_crates_metadata - Batch metadata queries for multiple crates
• cache_operations - Manage and monitor background caching operations (list, status, cancel, clear)

Documentation Queries

• list_crate_items - Browse all items in a crate with optional filtering
• search_items - Full search with complete documentation (may hit token limits)
• search_items_preview - Lightweight search returning only IDs, names, and types
• get_item_details - Detailed information about specific items (signatures, fields, etc.)
• get_item_docs - Extract just the documentation string for an item
• get_item_source - View source code with configurable context lines

Dependency Analysis

• get_dependencies - Analyze direct and transitive dependencies with filtering

Structure Analysis

• structure - Generate hierarchical module tree using integrated cargo-modules

Search

• search_items_fuzzy - Fuzzy search with typo tolerance and semantic similarity

Configuration

Cache Directory

By default, crates are cached in ~/.rust-docs-mcp/cache/. You can customize this location using:

# Command line option
rust-docs-mcp --cache-dir /custom/path/to/cache
# or set the environment variable
export RUST_DOCS_MCP_CACHE_DIR=/custom/path/to/cache
rust-docs-mcp

GitHub Authentication

To access private repositories or increase GitHub API rate limits, set the GITHUB_TOKEN environment variable:

export GITHUB_TOKEN=your_github_personal_access_token

Benefits of authentication:

• Access private repositories — Cache and analyze private Rust crates
• Higher rate limits — 5,000 requests/hour (vs 60 unauthenticated)
• Avoid rate limit errors — Essential for caching multiple GitHub-hosted crates

Each crate version stores

• Complete source code in source/ directory
• Cache metadata and timestamps in metadata.json
• For workspace crates, individual members in members/ directory:
  • members/{member-name}/docs.json - Rustdoc JSON documentation
  • members/{member-name}/dependencies.json - Cargo dependency metadata
  • members/{member-name}/metadata.json - Member-specific cache metadata
• For single crates:
  • docs.json - Rustdoc JSON documentation
  • dependencies.json - Cargo dependency metadata

Installation

Quick Install

curl -sSL https://raw.githubusercontent.com/snowmead/rust-docs-mcp/main/install.sh | bash

Installation Options

One-liner (Recommended)

curl -sSL https://raw.githubusercontent.com/snowmead/rust-docs-mcp/main/install.sh | bash

Custom install directory

curl -sSL https://raw.githubusercontent.com/snowmead/rust-docs-mcp/main/install.sh | bash -s -- --install-dir /usr/local/bin

Cargo Install

cargo install rust-docs-mcp

Building from Source

Requirements

• Rust nightly toolchain (for Rustdoc JSON generation)

  rustup toolchain install nightly-2026-05-22
  

  Runtime prefers nightly-2026-05-22, which provides rustc 1.97.0-nightly (e96c36b6f 2026-05-21), so documentation generation can compile modern crates. The rustdoc-types dependency is kept in sync with that rustdoc JSON format. If the dated toolchain is missing, the runtime falls back to plain nightly, but only when it emits the same rustdoc JSON format version (57); newer nightlies will be rejected. You can override the choice with:

  export RUST_DOCS_MCP_TOOLCHAIN=nightly
  

• Network access to download crates from crates.io

git clone https://github.com/snowmead/rust-docs-mcp
cd rust-docs-mcp/rust-docs-mcp
cargo build --release
./target/release/rust-docs-mcp install

CLI Commands

rust-docs-mcp                   # Start MCP server (same as `serve`)
rust-docs-mcp serve             # Start MCP server explicitly

# One-shot operations (stateless – print JSON to stdout and exit)
rust-docs-mcp call cache-crate \
  --params '{"crate_name":"serde","source_type":"cratesio","version":"1.0.215"}'

rust-docs-mcp call search-items-fuzzy \
  --params '{"crate_name":"serde","version":"1.0.215","query":"Deserialize","limit":10}'

rust-docs-mcp call list-cached-crates

rust-docs-mcp call list-crate-versions \
  --params '{"crate_name":"serde"}'

# Maintenance commands
rust-docs-mcp install           # Install to ~/.local/bin
rust-docs-mcp install --force   # Force overwrite existing installation
rust-docs-mcp doctor            # Verify system environment and dependencies
rust-docs-mcp doctor --json     # Output diagnostic results in JSON format
rust-docs-mcp update            # Update to latest version from GitHub
rust-docs-mcp --help            # Show help

Note: call cache-crate is blocking — it downloads the crate, generates documentation, and builds the search index before returning. This is different from MCP mode where cache_crate returns a task ID immediately and completes in the background. If a one-shot tool returns an error JSON response, the CLI prints that JSON to stdout and exits with status 1.

Available one-shot tools: cache-crate, search-items-fuzzy, search-items-preview, search-items, list-crate-items, get-item-details, get-item-docs, get-item-source, list-cached-crates, list-crate-versions, get-dependencies, structure.

Troubleshooting

If you encounter issues during installation or runtime, run the doctor command to diagnose common problems:

rust-docs-mcp doctor

The doctor command checks:

• Rust toolchain availability (stable + nightly)
• Git installation
• Network connectivity to crates.io and GitHub
• Cache directory permissions and disk space
• Rustdoc JSON generation capability
• Optional dependencies (e.g., codesign on macOS)

For programmatic integration, use --json flag to get structured output.

MCP Configuration

Add the server to your MCP configuration:

{
  "rust-docs": {
    "command": "/path/to/rust-docs-mcp/target/release/rust-docs-mcp",
    "transport": "stdio"
  }
}