Fast Filesystem MCP

Community

High-performance filesystem MCP server for Claude Desktop with large file handling and advanced editing.

How to install ↓ Compare GitHub source repository ↗

Category: Filesystem #18 of 24
Stars: ★ 64 Popular
Transport: stdio (local process)
Runtime: Node.js
Credentials: No credential needed
License: Apache-2.0
Last commit: 5 months ago
Tools: 26

47FMRS · D

This server offers comprehensive filesystem capabilities, especially suitable for Claude Desktop users dealing with large files and complex edits. Performance optimizations and backup mechanisms are standout features. As it is unofficial, use in trusted environments and be mindful of permissions.

Strongest · Setup experience 12/20 Weakest · Reliability 7/20

Reliability

7/20

Security and permissions

8/20

Maintenance

9/20

Documentation

11/20

Setup experience

12/20

Why each score

Reliability 7/20: Based solely on static source review, actual execution cannot be verified. Potential issues that could affect reliability: direct inclusion of stderr output in JSON responses (could break JSON parsing), reliance on external commands like 'du' and 'find', and some tools have weak error handling. Test directory exists but no comprehensive tests covering key paths were found. Therefore upper bound 12, scored 7.
Security and permissions 8/20: No red-flag issues like credential theft or malicious behavior found. The server allows running arbitrary shell commands (including rm -rf) but has explicit confirmation and tool-level protections, which is a significant risk. No interactive confirmation via TTY is present. Potential DoS (reading entire root directory) or cross-session sensitive data leakage when backups are enabled. Score 8 reflects identified risks with low certainty.
Maintenance 9/20: Repository shows activity: multiple commits, version tags, and recent releases. Open issues exist but responses are visible. License is Apache-2.0, clear. No security response channel seen. Dependencies are locked via package-lock.json. Overall well-maintained but lacks security advisories and release notes, so deduction.
Documentation 11/20: README is extensive, covering installation, configuration, environment variables, and includes examples and parameters for each tool. However, documentation is self-contradictory: it lists 'fast_search_and_replace' tool but it is not implemented in source code; missing error handling and limitations. Tool descriptions are incomplete, some advanced features are documented without deep guides. Hence score 11.
Setup experience 12/20: Installation path is 'npx fast-filesystem-mcp', but README later mentions 'npm install -g' which is redundant. No Windows hints provided, but config examples for Claude Desktop are present. Server is pure Node.js, can be started in multiple ways including CLI and stdio. Code is simple and setup takes few steps. No prebuilt packages. Score 12 because static review cannot verify execution.

Static review · not runListed 2026-08-07

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local files

Best for

Claude Desktop users needing fast file operations
Developers handling large files or streaming data
Scenarios requiring backups and fault-tolerant editing
Automated file management and sync tasks

Not for

Environments with high security requirements that distrust third-party MCP servers
Remote scenarios requiring network transport (e.g., SSE or HTTP)
Fully offline environments without Node.js
Needs for graphical interface or interactive file management

Required permissions

Read/write filesystem: can read, write, modify, and delete files and directories
Create backup files (if enabled)
Execute commands: via `npx`
Access network (for installation)

Risks and side effects

File operations may cause data loss or overwrites, despite backup mechanisms
Malicious prompts could induce unintended operations, requiring user confirmation
Third-party server may contain vulnerabilities
Improper allowed directories configuration may expose sensitive files

Setup

Before you start

Runtime：Node.js

Other optional settings (6)

CREATE_BACKUP_FILES optional Set to true to create timestamped backup files before modifications; defaults to false. See the Backup Configuration section.

DEBUG_MCP optional Set to true to enable debug logging to stderr; optional.

MCP_DEBUG optional Equivalent to DEBUG_MCP; set to true to enable debug logging; optional.

MCP_LOG_FILE optional Path to a log file (e.g. /path/to/log.txt); logs are written to the file instead of stderr; optional.

MCP_SILENT_ERRORS optional Set to true to suppress error messages in responses; optional.

SILENT_ERRORS optional Equivalent to MCP_SILENT_ERRORS; set to true to suppress error messages; optional.

Add the following to your Claude Desktop configuration:

Open the Claude Desktop config file (claude_desktop_config.json).
Add fast-filesystem under mcpServers using the command npx -y fast-filesystem-mcp.
Restart Claude Desktop.
Optionally set environment variable CREATE_BACKUP_FILES=true to enable backup file creation.

claude_desktop_config.json

{
  "mcpServers": {
    "fast-filesystem": {
      "command": "npx",
      "args": ["-y", "fast-filesystem-mcp"]
    }
  }
}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json

{
  "servers": {
    "fast-filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "fast-filesystem-mcp"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal

claude mcp add fast-filesystem -- npx -y fast-filesystem-mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

After adding the config to Claude Desktop, check that tools like fast_list_allowed_directories appear in the tool list, then ask "list the allowed directories" — a returned directory list confirms the server is connected.

Troubleshooting

If tool calls fail, check logs by setting `DEBUG_MCP=true` or `MCP_LOG_FILE`
Ensure file paths are within allowed directories; use `fast_list_allowed_directories` to view
For large files, use streaming write tools to avoid memory overflow
If encountering JSON parsing errors, disable debug output (disabled by default)

Things to try

Once connected, you can ask your AI assistant things like:

List my project directory and show the directory tree.
Replace all console.log calls with logger.info in /path/to/file.js using regex.
Find large files over a size threshold in my downloads folder.
Compress this folder into a tar.gz archive.

Tools 26

fast_read_file read-only

Read files with chunking support

fast_read_multiple_files read-only

Read multiple files simultaneously with sequential reading support

fast_write_file writes

Write or modify files

fast_large_write_file writes

Stream-based writing for large files

fast_get_file_info read-only

Get detailed file information

fast_copy_file writes

Copy files and directories with advanced options

fast_move_file writes

Move/rename files and directories safely

fast_delete_file destructive

Delete files and directories with protection

Show 18 more tools

fast_batch_file_operations writes

Execute multiple file operations in sequence

fast_compress_files writes

Create compressed archives (tar, tar.gz, tar.bz2)

fast_extract_archive writes

Extract compressed archives with options

fast_sync_directories writes

Advanced directory synchronization with multiple modes

fast_edit_file writes

Precise line-based file editing with multiple modes

fast_edit_block writes

Safe block editing with exact string matching

fast_edit_blocks writes

Batch block editing for multiple precise changes

fast_edit_multiple_blocks writes

Edit multiple sections in a single operation

fast_extract_lines read-only

Extract specific lines or ranges from files

fast_search_and_replace writes

Advanced search and replace with regex support

fast_list_directory read-only

List directory contents with pagination

fast_create_directory writes

Create directories recursively

fast_get_directory_tree read-only

Get directory tree structure

fast_search_files read-only

Search files by name or content

fast_search_code read-only

Advanced code search with ripgrep integration

fast_find_large_files read-only

Find large files in directories

fast_get_disk_usage read-only

Check disk usage information

fast_list_allowed_directories read-only

List allowed directories

Use cases

Efficient file reading, writing, and editing within Claude Desktop

Handling large files that exceed memory limits

Batch file operations and directory synchronization

Code search and replacement

Archive compression and extraction

Supported clients

Claude Desktop

Listed from the project's documentation, not tested by this site.

Overview

Fast Filesystem MCP is a high-performance MCP server built with Node.js and TypeScript, designed to provide secure and efficient filesystem access for Claude and other AI assistants. It supports streaming read/write of large files, chunked reading, directory synchronization, archive compression, batch editing, and more. Built-in features include backup creation, retry logic, and smart exclusion of system files. The server communicates via stdio and can be quickly integrated into Claude Desktop using npx.

Similar servers

Filesystem MCP Server 84 · B

Secure local file read/write access

★ 91.4k · Tools 6 Compare with this →

Vault Cortex MCP Server 79 · B

Standalone MCP server for Obsidian vaults: hybrid search, notes & files, structured memory, tasks, OAuth 2.1.

★ 30 · Tools 30 Compare with this →

Obsidian Web MCP 68 · C

Secure remote access to your Obsidian vault over HTTPS with OAuth 2.0 authentication.

★ 185 · Tools 20 Compare with this →

Safe Docx MCP Server 68 · C

AI-native surgical editing of Word and OpenDocument files with formatting preservation

★ 46 Compare with this →

Compare with other MCP servers

Source revision b265ee79a108 Data synced 2026-10-19 Read the FMRS scoring method