Skip to main content
Glama

Filesystem MCP β€” ARCHIVED

ARCHIVED / NON-PRIMARY
This product is not an active Sylphx agent-instrument.
Prefer independent products: Citra, Iris, Cue, Prism, Spine, Lookout.

Historical source remains for reference only. Do not treat npm/Docker badges or install CTAs below as current install authority.


Filesystem MCP

Your agent touched the repo. Did it stay in the project?

Secure, token-optimized filesystem operations for AI agents β€” batch reads, surgical edits, and project-root confinement without shell spawn overhead.

npm version Docker Pulls License TypeScript

Batch operations Β· Project root safety Β· Zod validation Β· 13 MCP tools Β· Docker-ready

⭐ Star this repo if agents should read and edit your codebase safely β€” not spawn shells per file. Β· Quick start Β· See it work Β· Why not shell commands? Β· Roadmap


The problem

Agents need filesystem access to read code, apply edits, and search across a repo. The default path is shell commands β€” one spawn per operation, no batching, stderr parsing, and paths that can wander outside the project.

That costs tokens, adds latency, and turns every file touch into a trust exercise.

Filesystem MCP is built for the moment your agent needs fast, bounded, batch-friendly file operations β€” confined to the project root.

Related MCP server: image-reader MCP Server

Why not shell commands?

Shell commands per file

Filesystem MCP

One operation per spawn

Batch 10+ files in one MCP call

Full shell access

Confined to server cwd at launch

stderr parsing

Per-item success/failure in structured JSON

High token round trips

Fewer host↔server calls

Path traversal risk

Relative paths only; traversal blocked

No schema

Zod-validated arguments on every tool

Full benchmark contract: docs/benchmark.md.

See it work

Configure once. Read many files in one call.

claude mcp add filesystem -- npx @sylphx/filesystem-mcp
{
  "paths": ["src/index.ts", "package.json", "README.md"]
}

read_content returns per-file results in one response:

{
  "results": [
    { "path": "src/index.ts", "content": "...", "success": true },
    { "path": "package.json", "content": "...", "success": true },
    { "path": "README.md", "content": "...", "success": true }
  ]
}

Important: launch the MCP server with cwd set to your project root. All paths are relative to that directory.

Why agents use it

Need

What you get

Read multiple files

read_content β€” batch paths, optional line ranges

Write or append

write_content β€” multiple files per call

Surgical edits

apply_diff, replace_content β€” diff output and per-file status

Search the tree

search_files β€” regex with context

Refactor across files

replace_content β€” multi-file search & replace

Explore structure

list_files β€” recursive listing with optional stats

Move/copy/delete

move_items, copy_items, delete_items

Permissions

chmod_items, chown_items

Inspect metadata

stat_items, create_directories

Quick Start

Claude Code

claude mcp add filesystem -- npx @sylphx/filesystem-mcp

Run from your project directory so cwd is the repo root.

Claude Desktop / any MCP host

{
  "mcpServers": {
    "filesystem-mcp": {
      "command": "npx",
      "args": ["@sylphx/filesystem-mcp"]
    }
  }
}

Set the host's working directory to your project root.

Docker

{
  "mcpServers": {
    "filesystem-mcp": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "/path/to/your/project:/app",
        "sylphx/filesystem-mcp:latest"
      ]
    }
  }
}

Local development

git clone https://github.com/SylphxAI/filesystem-mcp.git
cd filesystem-mcp
bun install
bun run build
bun run test

MCP Tool Surface

Tool

Use it when the agent needs to...

read_content

Read one or more files (optional line ranges)

write_content

Write or append to files

apply_diff

Apply structured diffs across files

search_files

Regex search with context lines

replace_content

Multi-file search and replace

list_files

List a directory tree (optional stats)

stat_items

Get detailed file/directory metadata

create_directories

Create directories (with parents)

delete_items

Remove files or directories

move_items

Move or rename items

copy_items

Copy files or directories

chmod_items

Change POSIX permissions

chown_items

Change ownership

Release proof

Claims are backed by CI benchmark:release-gate, safety fixture corpus, and the shipped-path matrix (Rust-default primary tools).

bun run benchmark:release-gate

Artifact: benchmark-artifacts/filesystem_release_gate.json β€” must report status: passed before release.

Performance benchmarks

Reproduce local throughput on the shipped Rust CLI path:

bunx vitest bench __tests__/benchmarks/throughput.bench.ts --run

See docs/benchmark.md for scenarios, design goals, and how to interpret results.

Security model

  • All operations confined to the server cwd at launch.

  • Absolute paths rejected; path traversal blocked.

  • Zod schemas validate every tool argument.

  • Batch tools return per-item status β€” one failure does not hide the rest.

Documentation

Development

bun run validate    # lint + typecheck + test
bun run docs:build  # VitePress + API docs
bun run benchmark   # vitest bench

Support

Help this reach more builders

If shell-per-file agent workflows have burned your tokens or your trust in path safety, this project is for you.

⭐ Star the repo β€” it helps more agent builders find secure, batch-friendly filesystem access.

Discovery (in progress)

Channel

Status

Glama MCP directory

Listed β€” claim server for full discoverability

Official MCP Registry

Not listed yet

mcp.so submit

Not listed yet β€” directory submission

mcpservers.org submit

Not listed yet β€” free web-form submission

Know another MCP directory? Open an issue with the link.

License

MIT Β© Sylphx

Available Tools

12 tools
chmod_itemsC

Change permissions mode for multiple specified files/directories (POSIX-style).

Inputs: mode (required), paths (required).

chown_itemsC

Change owner (UID) and group (GID) for multiple specified files/directories.

Inputs: gid (required), paths (required), uid (required).

copy_itemsC

Copy multiple specified files/directories.

Inputs: operations (required).

create_directoriesC

Create multiple specified directories (including intermediate ones).

Inputs: paths (required).

delete_itemsC

Delete multiple specified files or directories.

Inputs: paths (required).

list_filesC

List files/directories. Can optionally include stats and list recursively.

Inputs: include_stats, path, recursive.

move_itemsC

Move or rename multiple specified files/directories.

Inputs: operations (required).

read_contentC

Read content from multiple specified files.

Inputs: paths (required).

replace_contentC

Replace content within files across multiple specified paths.

Inputs: operations (required), paths (required).

search_filesB

Search for a regex pattern within files in a specified directory (read-only).

Inputs: regex (required), file_pattern, path.

stat_itemsC

Get detailed status information for multiple specified paths.

Inputs: paths (required).

write_contentC

Write or append content to multiple specified files (creating directories if needed).

Inputs: items (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 12 tools

    Disambiguation5/5

    Every tool has a clearly distinct purpose with no ambiguity. Each tool targets a specific filesystem operation (e.g., copy_items vs. move_items, read_content vs. write_content), and the descriptions clearly differentiate their functions. There is no overlap that would cause an agent to misselect between tools.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with snake_case throughout (e.g., list_files, create_directories, delete_items). The naming is predictable and readable, with no deviations or mixed conventions, making it easy for agents to understand and use the tool set.

    Tool Count5/5

    With 12 tools, the count is well-scoped for a filesystem server, covering essential operations without being overwhelming. Each tool earns its place by addressing a core filesystem task, such as file management, content handling, and metadata operations, making the set comprehensive yet manageable.

    Completeness5/5

    The tool set provides complete coverage for filesystem operations, including CRUD/lifecycle functions (create, read, update, delete), file manipulation (copy, move), permissions (chmod, chown), and search capabilities. There are no obvious gaps, and agents can perform typical filesystem workflows without dead ends.

    Maintenance

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers