MCP server for filesystem access
bash
mcp-server-filesystem /path/to/dir1 /path/to/dir2
`
$3
You can also specify allowed directories using the MCP_FILESYSTEM_ALLOWED_DIRS environment variable. Multiple paths can be separated by commas defined in the environment variable string.
Example (Windows PowerShell):
`powershell
$env:MCP_FILESYSTEM_ALLOWED_DIRS="C:\Work\Project,C:\Logs"
npx -y @modelcontextprotocol/server-filesystem
`
Example (macOS/Linux):
`bash
export MCP_FILESYSTEM_ALLOWED_DIRS="/home/user/projects,/tmp/logs"
npx -y @modelcontextprotocol/server-filesystem
`
Configuration via claude_desktop_config.json:
`json
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem"],
"env": {
"MCP_FILESYSTEM_ALLOWED_DIRS": "/path/to/dir1,/path/to/dir2"
}
}
}
}
`
$3
MCP clients that support Roots can dynamically update the Allowed directories.
Roots notified by Client to Server, completely replace any server-side Allowed directories when provided.
Important: If server starts without command-line arguments AND client doesn't support roots protocol (or provides empty roots), the server will throw an error during initialization.
This is the recommended method, as this enables runtime directory updates via roots/list_changed notifications without server restart, providing a more flexible and modern integration experience.
$3
The server's directory access control follows this flow:
1. Server Startup
- Server starts with directories from command-line arguments (if provided)
- If no arguments provided, server starts with empty allowed directories
2. Client Connection & Initialization
- Client connects and sends initialize request with capabilities
- Server checks if client supports roots protocol (capabilities.roots)
3. Roots Protocol Handling (if client supports roots)
- On initialization: Server requests roots from client via roots/list
- Client responds with its configured roots
- Server replaces ALL allowed directories with client's roots
- On runtime updates: Client can send notifications/roots/list_changed
- Server requests updated roots and replaces allowed directories again
4. Fallback Behavior (if client doesn't support roots)
- Server continues using command-line directories only
- No dynamic updates possible
5. Access Control
- All filesystem operations are restricted to allowed directories
- Use list_allowed_directories tool to see current directories
- Server requires at least ONE allowed directory to operate
Note: The server will only allow operations within directories specified either via args or via Roots.
API
$3
- read_text_file
- Read complete contents of a file as text
- Inputs:
- path (string)
- head (number, optional): First N lines
- tail (number, optional): Last N lines
- Always treats the file as UTF-8 text regardless of extension
- Cannot specify both head and tail simultaneously
- read_media_file
- Read an image or audio file
- Inputs:
- path (string)
- Streams the file and returns base64 data with the corresponding MIME type
- read_multiple_files
- Read multiple files simultaneously
- Input: paths (string[])
- Failed reads won't stop the entire operation
- write_file
- Create new file or overwrite existing (exercise caution with this)
- Inputs:
- path (string): File location
- content (string): File content
- edit_file
- Make selective edits using advanced pattern matching and formatting
- Features:
- Line-based and multi-line content matching
- Whitespace normalization with indentation preservation
- Multiple simultaneous edits with correct positioning
- Indentation style detection and preservation
- Git-style diff output with context
- Preview changes with dry run mode
- Inputs:
- path (string): File to edit
- edits (array): List of edit operations
- oldText (string): Text to search for (can be substring)
- newText (string): Text to replace with
- dryRun (boolean): Preview changes without applying (default: false)
- Returns detailed diff and match information for dry runs, otherwise applies changes
- Best Practice: Always use dryRun first to preview changes before applying them
- create_directory
- Create new directory or ensure it exists
- Input: path (string)
- Creates parent directories if needed
- Succeeds silently if directory exists
- list_directory
- List directory contents with [FILE] or [DIR] prefixes
- Input: path (string)
- list_directory_with_sizes
- List directory contents with [FILE] or [DIR] prefixes, including file sizes
- Inputs:
- path (string): Directory path to list
- sortBy (string, optional): Sort entries by "name" or "size" (default: "name")
- Returns detailed listing with file sizes and summary statistics
- Shows total files, directories, and combined size
- directory_tree
- Get a recursive tree view of files and directories as a JSON structure
- Input: path (string): Starting directory path
- Returns JSON structure with:
- name: File/directory name
- type: "file" or "directory"
- children: Array of child entries (for directories only)
- Output is formatted with 2-space indentation for readability
- move_file
- Move or rename files and directories
- Inputs:
- source (string)
- destination (string)
- Fails if destination exists
- move_files
- Move or rename multiple files/directories sequentially
- Inputs:
- operations (array): List of { source, destination } pairs
- source (string): File path or glob pattern (e.g., .mp4, /path/to/.txt)
- destination (string): Destination directory or file path
- stopOnError (boolean, optional, default true): Stop at first failure or continue to collect errors
- Supports glob patterns in source paths to match multiple files:
- *.mp4 - All MP4 files in the directory
- file?.txt - Files like file1.txt, file2.txt, etc.
- [abc]*.log - Log files starting with a, b, or c
- When using glob patterns, all matched files will be moved to the destination directory
- Automatically treats an existing destination directory as the target folder while preserving the original filename
- Each path must remain within allowed directories
- search_files
- Recursively search for files/directories that match or do not match patterns
- Inputs:
- path (string): Starting directory
- pattern (string): Search pattern
- excludePatterns (string[]): Exclude any patterns.
- Glob-style pattern matching
- Returns full paths to matches
- directory_tree
- Get recursive JSON tree structure of directory contents
- Inputs:
- path (string): Starting directory
- excludePatterns (string[]): Exclude any patterns. Glob formats are supported.
- Returns:
- JSON array where each entry contains:
- name (string): File/directory name
- type ('file'|'directory'): Entry type
- children (array): Present only for directories
- Empty array for empty directories
- Omitted for files
- get_file_info
- Get detailed file/directory metadata
- Input: path (string)
- Returns:
- Size
- Creation time
- Modified time
- Access time
- Type (file/directory)
- Permissions
- list_allowed_directories
- List all directories the server is allowed to access
- No input required
- Returns:
- Directories that this server can read/write from
Usage with Claude Desktop
Add this to your claude_desktop_config.json:
Note: you can provide sandboxed directories to the server by mounting them to /projects. Adding the ro flag will make the directory readonly by the server.
$3
Note: all directories must be mounted to /projects by default.
`json
{
"mcpServers": {
"filesystem": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"--mount", "type=bind,src=/Users/username/Desktop,dst=/projects/Desktop",
"--mount", "type=bind,src=/path/to/other/allowed/dir,dst=/projects/other/allowed/dir,ro",
"--mount", "type=bind,src=/path/to/file.txt,dst=/projects/path/to/file.txt",
"mcp/filesystem",
"/projects"
]
}
}
}
`
$3
`json
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/username/Desktop",
"/path/to/other/allowed/dir"
]
}
}
}
`
Usage with VS Code
For quick installation, click the installation buttons below...
 
 
For manual installation, you can configure the MCP server using one of these methods:
Method 1: User Configuration (Recommended)
Add the configuration to your user-level MCP configuration file. Open the Command Palette (Ctrl + Shift + P) and run MCP: Open User Configuration. This will open your user mcp.json file where you can add the server configuration.
Method 2: Workspace Configuration
Alternatively, you can add the configuration to a file called .vscode/mcp.json in your workspace. This will allow you to share the configuration with others.
> For more details about MCP configuration in VS Code, see the official VS Code MCP documentation.
You can provide sandboxed directories to the server by mounting them to /projects. Adding the ro flag will make the directory readonly by the server.
$3
Note: all directories must be mounted to /projects by default.
`json
{
"servers": {
"filesystem": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"--mount", "type=bind,src=${workspaceFolder},dst=/projects/workspace",
"mcp/filesystem",
"/projects"
]
}
}
}
`
$3
`json
{
"servers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"${workspaceFolder}"
]
}
}
}
`
Build
Docker build:
`bash
docker build -t mcp/filesystem -f src/filesystem/Dockerfile .
``