Skip to content
MCP Filesystem Ultra

Introduction

What is MCP Filesystem Ultra?

Section titled “What is MCP Filesystem Ultra?”

MCP Filesystem Ultra is a safety-first filesystem server implementing the Model Context Protocol (MCP), optimized for Claude Desktop and Claude Code.

It provides:

  • 20 MCP tools (17 core + git + minify_js + help) for file operations, search, editing, version control, JavaScript minification, backups, and more (aliases and the fs super-tool are disabled by default to keep the tool surface small)
  • git tool — built-in git version control with hardened command construction. 9 actions since v4.5.25: status, diff, log, show, add, commit, restore, branch, init
  • minify_js tool — pure-Go JavaScript minifier, no Node.js dependency
  • help tool — first-call discovery tool that lists all 20 tools with their parameters
  • Intelligent auto-optimization — each tool automatically selects the best I/O strategy based on file size
  • Token efficiency through compact mode and surgical editing patterns
  • Security hardening with Go 1.26.5
  • WSL/Windows path integration for cross-platform work

The Problem It Solves

Section titled “The Problem It Solves”

Claude Desktop’s Limitations

Section titled “Claude Desktop’s Limitations”

Claude Desktop has known issues with file operations:

  • Timeouts with files larger than a few hundred kilobytes
  • Extreme slowness in write operations
  • Blocking that prevents continuation
  • High failure rate with large files
  • Tool overload — too many tools triggers lazy loading, requiring tool_search calls

The Solution: Intelligent Unified Tools

Section titled “The Solution: Intelligent Unified Tools”

MCP Filesystem Ultra v4.5.29 solves these problems with 20 tools (17 core + git + minify_js + help):

Core Tools (5)

Section titled “Core Tools (5)”
  • read_file — Auto-detects file size: direct read, chunked streaming, or base64. Replaces 6 old tools
  • write_file — Auto-detects content size: direct or streaming with progress. Replaces 5 old tools
  • edit_file — Search-and-replace with risk assessment, backup, regex mode. Replaces 7 old tools
  • search_files — Smart search with file type filters, count-only mode. Replaces 4 old tools
  • list_directory — Cached directory listing with WSL/Windows path support

Edit & File Management (5)

Section titled “Edit & File Management (5)”
  • multi_edit — Atomic multiple edits on a single file
  • move_file — Move or rename files/directories
  • copy_file — Copy files/directories
  • delete_file — Soft-delete (default) or permanent delete
  • create_directory — Create directories recursively

Advanced (7)

Section titled “Advanced (7)”
  • batch_operations — Batch ops, pipelines (12 actions), and batch rename
  • backup — List, restore, compare, cleanup, undo, trash recovery
  • analyze_operation — Dry-run analysis (file, optimize, write, edit, delete, compare)
  • wsl — WSL/Windows sync, status, autosync, and path conversion
  • server_info — Help, stats, and artifact management
  • get_file_info — File metadata and permissions
  • project_replace — Project-wide find/replace in one call

What Makes It Different

Section titled “What Makes It Different”

Compared to basic MCP filesystem implementations, this server provides:

  1. Safety-first design: automatic backups, step-through undo, OCC/expected_hash, and the accidental-rewrite guard (allow_rewrite) make AI-driven editing recoverable and auditable.
  2. Auto-optimization: detects file size and selects the appropriate I/O strategy (direct, streaming, or chunked).
  3. Resilience: streaming handles files that would cause timeouts with standard tools.
  4. Risk assessment: every mutation is assessed (LOW/MEDIUM/HIGH/CRITICAL) and proceeds with a backup — never blocked by risk level alone.
  5. Token efficiency: compact mode and surgical edit patterns reduce token consumption without inventing metrics.
  6. Security: hardened against path traversal, option injection, command injection, TOCTOU, and other common vulnerabilities.
  7. No lazy loading: 20 tools stay well under Claude Desktop’s ~30-tool threshold.

Key Features at a Glance

Section titled “Key Features at a Glance”

Safety

Section titled “Safety”
  • Automatic backups before every destructive operation, with step-through undo via backup(action:"undo_last", file_path:...)
  • OCC / expected_hash to detect external changes and chain edits safely
  • Accidental-rewrite guard (allow_rewrite) prevents unintended full-file rewrites
  • Soft-delete by default to recoverable trash
  • Risk assessment on every edit — never blocked by risk level, always backed up

Observability

Section titled “Observability”
  • Audit logging (--log-dir) with JSON Lines operation records
  • Enterprise dashboard for logs, metrics, backups, and trash recovery
  • Hooks (16 event types) for custom validation and workflows
  • Structured output on the 4 I/O core tools for strict MCP clients

Performance

Section titled “Performance”
  • Intelligent I/O tiers: direct (<100KB), streaming (<500KB), chunked (<5MB), special handling (<50MB)
  • 3-tier cache: BigCache + go-cache for files, directories, and metadata
  • Parallel execution in pipelines and project_replace
  • Embedded ripgrep backend for fast search (fallback to native search)

Security

Section titled “Security”
  • Go 1.26.5 with govulncheck clean dependency tree
  • Symlink traversal protection with filepath.EvalSymlinks()
  • ADS/Unicode/reserved-name blocking in path validation
  • Access control on all file operations
  • Backup security with sanitized IDs and permissions
  • No cmd.exe fallback in the git tool (removed in v4.5.29)

Advanced Capabilities

Section titled “Advanced Capabilities”
  • Backup and Recovery: persistent backups with 4-level risk assessment
  • Batch Operations: atomic operations with automatic rollback
  • Hooks System: pre/post operation custom commands
  • WSL Integration: automatic path conversion and sync
  • Plan Mode: dry-run analysis before dangerous operations
  • Pipeline System: multi-step transformations with conditions and template variables

Who Should Use This?

Section titled “Who Should Use This?”

MCP Filesystem Ultra is designed for:

  • Claude Desktop and Claude Code users needing reliable, recoverable file operations
  • Developers working with large codebases
  • WSL users requiring seamless Windows/Linux integration
  • Security-conscious teams needing controlled filesystem access
  • Cost-optimizers wanting to reduce token usage

Next Steps

Section titled “Next Steps”

Ready to get started?

Or dive deeper: