Rust MCP Filesystem

Rust MCP Filesystem

What is Rust MCP Filesystem about?

Rust MCP Filesystem provides a high‑performance, asynchronous MCP server dedicated to filesystem management. It offers a secure, read‑only‑by‑default environment with optional write access, enabling precise file querying and manipulation through glob patterns and nested directory creation.

How to use Rust MCP Filesystem?

1. Installation – Follow the step‑by‑step guide in the project documentation to build the binary with cargo build --release or download a pre‑compiled release.
2. Configuration – Adjust the server’s configuration file (e.g., config.toml) to set the root directory, enable write permissions, and define any custom glob rules.
3. Running – Start the server with ./target/release/rust-mcp-filesystem --config config.toml. The server will listen for MCP requests on the configured port.
4. Interaction – Use any MCP‑compatible client to send filesystem commands such as list, read, write, or glob to the server’s endpoint.

Key features of Rust MCP Filesystem

• High performance: Rust + async I/O ensures low latency and high throughput.
• Read‑only default: Prevents accidental writes; write access must be explicitly enabled.
• Advanced glob search: Full glob syntax (*.rs, src/**/*.txt, logs/error-???.log, etc.) for precise file filtering.
• Nested directory creation: Supports creating deep directory structures in a single call.
• Lightweight binary: No external runtimes; a single compiled executable.
• Seamless integration: Works with rust-mcp-sdk and rust-mcp-schema for type‑safe MCP communication.

Use cases of Rust MCP Filesystem

• File exploration tools – Power IDE extensions or CLI utilities that need rapid file discovery.
• Automation pipelines – Invoke filesystem operations from CI/CD workflows without spawning heavy runtimes.
• System integration – Provide a secure, read‑only view of a filesystem to remote services via MCP.
• Sandboxed environments – Offer limited write capabilities for controlled application testing.

FAQ from the Rust MCP Filesystem

• Q: Do I need Node.js or Python to run this server?
  A: No. The server is a self‑contained Rust binary.
• Q: How can I enable write access?
  A: Set allow_write = true in the configuration file and restart the server.
• Q: Is there support for Windows paths?
  A: Yes, the server uses Rust’s cross‑platform std::fs APIs.
• Q: Where can I find the full list of capabilities?
  A: See the "Capabilities" section of the online documentation.
• Q: How do I contribute?
  A: Fork the repository, make changes, and open a pull request following the contribution guidelines in CONTRIBUTING.md.

Rust MCP Filesystem

Rust MCP Filesystem is a blazingly fast, asynchronous, and lightweight MCP (Model Context Protocol) server designed for efficient handling of various filesystem operations. This project is a pure Rust rewrite of the JavaScript-based @modelcontextprotocol/server-filesystem, offering enhanced capabilities, improved performance, and a robust feature set tailored for modern filesystem interactions.

📝 Refer to the project documentation for installation and configuration instructions.

⭐️ It is also available on Docker Hub’s MCP Registry at: https://hub.docker.com/mcp/server/rust-mcp-filesystem

Features

• ⚡ High Performance: Built in Rust for speed and efficiency, leveraging asynchronous I/O to handle filesystem operations seamlessly.
• 🔒 Read-Only by Default: Starts with no write access, ensuring safety until explicitly configured otherwise.
• 🔍 Advanced Glob Search: Supports full glob pattern matching allowing precise filtering of files and directories using standard glob syntax.For example, patterns like *.rs, src/**/*.txt, and logs/error-???.log are valid and can be used to match specific file types, recursive directory searches, or patterned filenames.
• 🔄 MCP Roots support: enabling clients to dynamically modify the list of allowed directories (disabled by default).
• 📦 ZIP Archive Support: Tools to create ZIP archives from files or directories and extract ZIP files with ease.
• 🪶 Lightweight: Standalone with no external dependencies (e.g., no Node.js, Python etc required), compiled to a single binary with a minimal resource footprint, ideal for both lightweight and extensive deployment scenarios.

👉 Refer to capabilities for a full list of tools and other capabilities.

🔧 Installation & Configuration

For detailed setup instructions, please visit the project documentation.

Quick installation guide

• Shell script

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/rust-mcp-stack/rust-mcp-filesystem/releases/download/v0.3.8/rust-mcp-filesystem-installer.sh | sh

• PowerShell script

powershell -ExecutionPolicy Bypass -c "irm https://github.com/rust-mcp-stack/rust-mcp-filesystem/releases/download/v0.3.8/rust-mcp-filesystem-installer.ps1 | iex"

• Homebrew

brew install rust-mcp-stack/tap/rust-mcp-filesystem

• NPM

npm i -g @rustmcp/rust-mcp-filesystem@latest

The npm package is provided for convenience. It runs the same underlying Rust binary but can be installed and used as a standard npm package.

• Docker

  https://hub.docker.com/mcp/server/rust-mcp-filesystem

• Download Binaries

  https://github.com/rust-mcp-stack/rust-mcp-filesystem/releases/tag/v0.3.8

Purpose

This project aims to provide a reliable, secure, and feature-rich MCP server for filesystem management, reimagining the capabilities of @modelcontextprotocol/server-filesystem in a more performant and type-safe language. Whether you’re building tools for file exploration, automation, or system integration, rust-mcp-filesystem offers a solid foundation.

🧰 Built With

The project leverages the rust-mcp-sdk and rust-mcp-schema to build this server. check out those repositories if you’re interested in crafting your own Rust-based MCP project or converting existing ones to Rust for enhanced performance and safety.

License

This project is licensed under the MIT License. see the LICENSE file for details.

Acknowledgments

Inspired by @modelcontextprotocol/server-filesystem and built with the power of Rust.