mcp-methods

Shared Rust-powered utilities for Model Context Protocol servers. Pip-installable Python library, native Rust crate, and a generic CLI binary — three distribution shapes, one set of primitives.

What it is

Layer	What you get
Primitives	ripgrep_files, list_dir, read_file, github_discussions, git_api, html_to_text, compact_text, ElementCache — fast Rust implementations of the common building blocks an MCP tool server needs.
Framework	McpServer, ServerOptions, Manifest, Workspace, watch_dir, load_env_walk — an rmcp-backed boot sequence with YAML manifest, operating modes (bare / source-root / workspace / watch), advisory trust gates, and .env resolution.
CLI	mcp-server — generic binary that loads a YAML manifest and serves the MCP protocol over stdio. Ships in the pip wheel.

Pick a path

Tutorials

• Getting Started
  • Step 1 — Install
  • Step 2 — Run in bare mode
  • Step 3 — Add a source root
  • Step 4 — Write a manifest
  • Step 5 — Pick what to do next
• Core Concepts
  • The four building blocks
  • What the framework owns vs what you own
  • Read next

How-to Guides

• Writing a Manifest
  • Minimal manifest
  • Full schema
  • Field-by-field reference
  • Validation behaviour
  • See also
• Operating Modes
  • The five modes
  • Precedence
  • Boot sequence
  • Manifest auto-detection
  • Skills subcommands
  • See also
• Trust Gates
  • The three flags
  • The “framework records, consumer enforces” contract
  • Why advisory, not enforced?
  • What happens if you forget to enforce?
  • Adding a new trust gate
  • See also
• Downstream Binary
  • Quick start
  • Adding more tools
  • Loading a manifest
  • Operating modes
  • Distributing
  • Read the source
  • See also
• Python Bindings
  • Install
  • What you get
  • The library surface
  • The CLI
  • FastMCP helpers
  • Skills
  • Calling from a downstream Python project
  • When to use the pyo3 surface vs the CLI
  • See also
• Using FastMCP Helpers
  • Install
  • The helpers
  • The graph parameter
  • End-to-end example
  • When to use FastMCP vs the Rust binary
  • See also
• Watch + Workspace Modes
  • The PostActivateHook
  • Workspace (GitHub) mode
  • Workspace (local) mode
  • Watch-only mode
  • Calling the hook from your binary
  • See also
• Skills-Aware Manifests
  • The five-minute version
  • Adding a project skill
  • Adding a shared skill pack
  • Verifying what’s resolved
  • Backwards compatibility
  • Python / FastMCP path
  • See also
• Authoring Skills
  • When to author a skill
  • File format
  • Where to put skills
  • Size limits
  • Scaffold a starter skill
  • Lint and inspect
  • Auto-injection
  • See also
• Writing Effective Skills
  • How skill bodies reach the agent
  • The description is your discovery mechanism
  • Body anatomy
  • Decision trees for multi-mode tools
  • Tone and voice
  • Size targets
  • Predicate gating (0.3.36+)
  • What our framework adds
  • A note on iteration
  • See also

Explanation

• Architecture
  • The three crates
  • The wheel-bundled binary
  • Why this shape, briefly
  • Historical arc (0.3.20 → 0.3.30)
  • See also
• The Trust Pattern — Why Advisory, Not Enforced
  • What the framework does
  • Why advisory
  • What enforcement looks like
  • What can go wrong
  • Comparison: framework-enforced trust
  • See also
• Distribution Shape — Polars / Pydantic-Core Pattern
  • The three publication paths
  • The polars / pydantic-core pattern
  • Why kglite couldn’t keep the bundled-binary pattern (and why we can)
  • The 0.3.26 → 0.3.30 evolution
  • Comparison to other ecosystems
  • What this means for consumers
  • See also
• Three-Layer Skill Composition
  • The layers
  • Why three layers and not fewer
  • Resolution rules
  • Collision-logging
  • Authoring decision tree
  • See also

Reference

• Manifest Schema Reference
  • Top-level keys
  • trust: object
  • tools: list
  • embedder: object
  • builtins: object
  • workspace: object
  • skills: polymorphic value
  • extensions: object
  • Programmatic access
  • JSON shape from Manifest::to_json()
  • See also
• Python API Reference
  • File + directory navigation
  • ripgrep-backed search
  • GitHub
  • Git
  • Text processing
  • Caching
  • Skills
  • FastMCP helpers
  • See also
• Rust API Reference
  • Quick index
  • Features
  • See also

Examples

• Example: Minimal Manifest
• Example: GitHub Workspace
• Example: Local Workspace + Watch
• Example: Tools + Trust Gates

Project

• Contributing to mcp-methods
• Changelog

Install

pip install mcp-methods       # Python library + mcp-server CLI on PATH
cargo add mcp-methods         # Pure Rust library, zero pyo3

The mcp-server CLI bundled in the wheel is the same binary you’d get from cargo build --release -p mcp-server in the repo — built once per OS, packaged into the abi3 wheel, no Rust toolchain required for operators.

Where to start

• New to MCP servers → Getting Started — 15-minute walkthrough from pip install to a running server.

• Want to write your own server → Downstream Binary.

• Just need a YAML manifest → Writing a Manifest.

• Rust API reference → docs.rs/mcp-methods.