modelcontextprotocol

Appearance

Getting started ​

modelcontextprotocol is a single Rust binary that provides four Model Context Protocol (MCP) servers over stdio:

ServerIdentityWhat it does
filesystemmcp-filesystemSecure read/write access restricted to allowed directories
fetchmcp-fetchFetch URLs, convert HTML to markdown, robots.txt enforcement
memorymcp-memoryPersistent knowledge-graph memory as JSONL
shellmcp-shellExecute local programs directly with a restricted working directory

All four implement the MCP 2026-07-28 specification (see Protocol).

Requirements ​

  • Using the prebuilt binaries: none — just a supported OS. No Rust toolchain needed.
  • Building from source: a recent Rust toolchain (the crate declares MSRV 1.97 and edition 2024).
  • A 64-bit desktop OS; the prebuilt binaries also cover Windows ARM64, 32-bit ARM Linux, Android, and iOS (details below).
  • Node.js 24 is only needed to build and preview this documentation site, not to use the servers.

Installation ​

One-line installer (macOS / Linux / Android) ​

bash
curl -fsSL https://github.com/maxylev/modelcontextprotocol/releases/latest/download/install.sh | bash

The script detects your OS and CPU, downloads the matching prebuilt binary (MSRV build), verifies its SHA-256 checksum, and installs it to ~/.local/bin ($PREFIX/bin under Termux). Override the directory with INSTALL_DIR:

bash
curl -fsSL https://github.com/maxylev/modelcontextprotocol/releases/latest/download/install.sh | INSTALL_DIR=/usr/local/bin bash

Requires curl, tar, and sha256sum (Linux/Android) or shasum (macOS). The script lives in the repository root (install.sh).

Prebuilt binaries (no Rust required) ​

Every v* tag publishes prebuilt binaries to GitHub Releases. Download your platform's archive, extract it, and put the modelcontextprotocol executable in your bin folder (or anywhere on your PATH).

Direct links to the latest version of each package (replace rust-msrv with rust-stable for the build made with the latest stable Rust):

The -musl Linux builds are fully static and run on any distribution; the Windows builds link the CRT statically (no VC++ runtime needed). Not sure about your architecture? Run uname -m (macOS/Linux) or echo %PROCESSOR_ARCHITECTURE% (Windows). Every release ships a .sha256 checksum file named after the archive base — e.g. modelcontextprotocol-aarch64-apple-darwin-rust-msrv.sha256 — covering the archive and the install.sh script.

Install on macOS ​

bash
curl -L -O https://github.com/maxylev/modelcontextprotocol/releases/latest/download/modelcontextprotocol-aarch64-apple-darwin-rust-msrv.tar.gz
tar -xzf modelcontextprotocol-aarch64-apple-darwin-rust-msrv.tar.gz
sudo install -m 755 modelcontextprotocol /usr/local/bin/

(On Intel Macs, use the x86_64-apple-darwin archive above.)

Install on Linux ​

bash
curl -L -O https://github.com/maxylev/modelcontextprotocol/releases/latest/download/modelcontextprotocol-x86_64-unknown-linux-musl-rust-msrv.tar.gz
tar -xzf modelcontextprotocol-x86_64-unknown-linux-musl-rust-msrv.tar.gz
sudo install -m 755 modelcontextprotocol /usr/local/bin/

(The static musl build works on every x86_64 distribution. On aarch64 devices — Raspberry Pi 4/5, Apple Silicon VMs — use the aarch64-unknown-linux-musl archive, or armv7-unknown-linux-musleabihf on 32-bit ARM.)

Install on Windows (PowerShell) ​

powershell
Invoke-WebRequest -Uri "https://github.com/maxylev/modelcontextprotocol/releases/latest/download/modelcontextprotocol-x86_64-pc-windows-msvc-rust-msrv.zip" -OutFile modelcontextprotocol.zip
Expand-Archive modelcontextprotocol.zip -DestinationPath modelcontextprotocol
New-Item -ItemType Directory -Force -Path "$HOME\bin" | Out-Null
Move-Item modelcontextprotocol\modelcontextprotocol.exe "$HOME\bin\"

Then add %USERPROFILE%\bin to your PATH (System Properties → Environment Variables, or setx PATH "%PATH%;%USERPROFILE%\bin" and reopen the terminal).

Install on Android (Termux) ​

bash
curl -L -O https://github.com/maxylev/modelcontextprotocol/releases/latest/download/modelcontextprotocol-aarch64-linux-android-rust-msrv.tar.gz
tar -xzf modelcontextprotocol-aarch64-linux-android-rust-msrv.tar.gz
mv modelcontextprotocol "$PREFIX/bin/"

Verify a download ​

bash
# macOS / Linux — download the archive, its checksum, and the installer,
# then verify all three against the release checksum file
curl -L -O https://github.com/maxylev/modelcontextprotocol/releases/latest/download/modelcontextprotocol-aarch64-apple-darwin-rust-msrv.tar.gz
curl -L -O https://github.com/maxylev/modelcontextprotocol/releases/latest/download/modelcontextprotocol-aarch64-apple-darwin-rust-msrv.sha256
curl -L -O https://github.com/maxylev/modelcontextprotocol/releases/latest/download/install.sh
shasum -a 256 -c modelcontextprotocol-aarch64-apple-darwin-rust-msrv.sha256

# Windows PowerShell
Get-FileHash modelcontextprotocol.zip -Algorithm SHA256

iOS note ​

The iOS archive is an unsigned Mach-O binary. iOS has no user-installable bin folder, so it cannot be run on a device as-is; it is provided for signing and embedding into an app.

From crates.io ​

bash
cargo install modelcontextprotocol

From the source repository ​

bash
cargo install --git https://github.com/maxylev/modelcontextprotocol

All three install the modelcontextprotocol binary into your Cargo bin directory. The release profile is tuned for a small binary (about 5 MB).

Verify the install:

bash
modelcontextprotocol --version
modelcontextprotocol --help

Configure your MCP client ​

Each server is selected on the command line. Both a subcommand form and an equivalent flag form are supported, so the binary fits any client's configuration style. The subcommand form is recommended.

Subcommand form:

json
{
  "mcpServers": {
    "filesystem": {
      "command": "modelcontextprotocol",
      "args": ["filesystem", "${HOME}/Developer"]
    },
    "fetch": {
      "command": "modelcontextprotocol",
      "args": ["fetch"]
    },
    "memory": {
      "command": "modelcontextprotocol",
      "args": ["memory"]
    },
    "shell": {
      "command": "modelcontextprotocol",
      "args": ["shell", "${HOME}/Developer/my-project"]
    }
  }
}

Flag form:

json
{
  "mcpServers": {
    "filesystem": {
      "command": "modelcontextprotocol",
      "args": ["--filesystem", "${HOME}/Developer"]
    },
    "fetch": {
      "command": "modelcontextprotocol",
      "args": ["--fetch"]
    },
    "memory": {
      "command": "modelcontextprotocol",
      "args": ["--memory"]
    },
    "shell": {
      "command": "modelcontextprotocol",
      "args": ["--shell", "${HOME}/Developer/my-project"]
    }
  }
}

See Command line (CLI) for the complete reference, including options, conflict rules, and environment variables.

Validate a running server ​

The fastest offline check is to run the binary without arguments: it prints the usage summary to stderr and exits with code 1.

bash
modelcontextprotocol
# modelcontextprotocol: exactly one server must be selected, ...

To inspect the live server (tools, prompts, resources), connect any MCP client. A practical check is to launch the binary and use a generic stdio client, or exercise it interactively with the MCP Inspector — see Verification for worked examples.

Read before you trust ​

  • The shell server executes arbitrary local programs with the OS permissions of the MCP server process. Its working-directory restriction is not a sandbox and there is no command filter.
  • The fetch server can reach local and internal network addresses; there is no SSRF protection.
  • Only connect these servers to clients you trust, and never expose them over an untrusted network. See Security model.

Next steps ​

Released under the MIT License.

modelcontextprotocol documentation