Filesystem Operations MCP

https://github.com/strawgate/filesystem-operations-mcp
Admin
An MCP server that exposes tools for performing bulk file and folder operations with centralized...
Tokens:17,226
Snippets:313
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### MCP_TRANSPORT Environment Variable Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Example of setting the MCP_TRANSPORT environment variable to 'sse' and starting the server.

```bash
export MCP_TRANSPORT=sse
python -m filesystem_operations_mcp.server
```

--------------------------------

### READ_FILE_EXCLUSIONS Environment Variable Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Example of setting the READ_FILE_EXCLUSIONS environment variable to exclude specific file patterns and starting the server.

```bash
export READ_FILE_EXCLUSIONS='["*.log", "*.tmp", "*.pyc", "*.bak"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### FilesystemOperationsMCPSettings Initialization Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Example of initializing the FilesystemOperationsMCPSettings class and accessing its properties.

```python
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings

# Load settings from environment variables
settings = FilesystemOperationsMCPSettings()

# Access individual settings
print(settings.mcp_transport)           # "stdio"
print(settings.disabled_file_tools)     # []
print(settings.disabled_folder_tools)   # []
print(len(settings.read_file_exclusions))     # 22 (default count)
print(len(settings.list_folder_exclusions))   # 13 (default count)
```

--------------------------------

### move() Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Example demonstrating how to move a folder from one location to another.

```python
result = await folder_ops.move(ctx, "/old/location", "/new/location")
if result:
    print("Folder moved successfully")
```

--------------------------------

### move() example usage

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Example of how to use the move() function to relocate a file.

```python
result = await file_ops.move(ctx, "/old/path/file.txt", "/new/path/file.txt")
if result:
    print("File moved successfully")
```

--------------------------------

### Integration Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

A complete example showing the setup and integration of bulk tools within a FastMCP server environment.

```python
from fastmcp import FastMCP
from fastmcp.contrib.bulk_tool_caller import BulkToolCaller
from filesystem_operations_mcp.servers.multi_file_operations import FileOperations
from filesystem_operations_mcp.servers.multi_folder_operations import FolderOperations
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings

# Initialize settings and create servers
settings = FilesystemOperationsMCPSettings()

root_mcp = FastMCP("FilesystemOperationsMCP", dependencies=["fastmcp"])
file_mcp = FastMCP("FileOperations", dependencies=["fastmcp"])
folder_mcp = FastMCP("FolderOperations", dependencies=["fastmcp"])

# Register file and folder operations
file_ops = FileOperations(denied_operations=settings.disabled_file_tools)
file_ops.register_all(file_mcp)

folder_ops = FolderOperations(
    denied_operations=settings.disabled_folder_tools,
    read_file_exclusions=settings.read_file_exclusions,
    list_folder_exclusions=settings.list_folder_exclusions,
)
folder_ops.register_all(folder_mcp)

# Register bulk tool caller on root MCP
bulk_caller = BulkToolCaller()
bulk_caller.register_all(root_mcp)

# Mount sub-servers
root_mcp.mount("file", file_mcp)
root_mcp.mount("folder", folder_mcp)

# Now available tools:
# - call_tool_bulk
# - call_tools_bulk
# - file.read, file.create, file.append, file.erase, file.move, file.delete
# - folder.create, folder.contents, folder.read_all, folder.move, folder.delete
```

--------------------------------

### FolderOperations Usage Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Example of how to instantiate and register FolderOperations with a FastMCP server.

```python
from filesystem_operations_mcp.servers.multi_folder_operations import FolderOperations
from fastmcp import FastMCP

folder_ops = FolderOperations()
mcp = FastMCP("FolderOps")
folder_ops.register_all(mcp)
```

--------------------------------

### DISABLED_FOLDER_TOOLS Environment Variable Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Example of setting the DISABLED_FOLDER_TOOLS environment variable to disable the 'delete' tool, and starting the server.

```bash
export DISABLED_FOLDER_TOOLS='["delete"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### FileOperations Usage Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Example of how to instantiate and register FileOperations with a FastMCP server.

```python
from filesystem_operations_mcp.servers.multi_file_operations import FileOperations
from fastmcp import FastMCP

file_ops = FileOperations()
mcp = FastMCP("FileOps")
file_ops.register_all(mcp)
```

--------------------------------

### FileReadSummary Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/types.md

Example of using FolderOperations.read_all() and processing its FileReadSummary result.

```python
result = await folder_ops.read_all(
    ctx,
    "/src",
    include=["**/*.py"],
    exclude=[],
    recurse=True
)

print(f"Processed {result.total_files} files")
print(f"Skipped {result.skipped_files} files")
print(f"Failed to read {len(result.errors)} files")
print(f"Successfully read {len(result.results)} files")

for success in result.results:
    lines = len(success.content.splitlines())
    print(f"  {success.file_path}: {lines} lines")

for error in result.errors:
    print(f"  ERROR {error.file_path}: {error.error}")
```

--------------------------------

### read_all() Example 1: Read all markdown files

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Example demonstrating how to read all markdown files recursively from a folder.

```python
# Read all markdown files
result = await folder_ops.read_all(
    ctx,
    "/docs",
    include=["**/*.md"],
    exclude=[],
    recurse=True
)

print(f"Read {len(result.results)} files")
print(f"Errors: {len(result.errors)}")
for error in result.errors:
    print(f"  {error.file_path}: {error.error}")

for success in result.results:
    print(f"File: {success.file_path}")
    print(f"Content: {success.content[:100]}...")
```

--------------------------------

### Configuration Integration Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Shows how to load settings and initialize FileOperations and FolderOperations with configuration.

```python
settings = FilesystemOperationsMCPSettings()  # Reads environment variables

file_operations = FileOperations(denied_operations=settings.disabled_file_tools)

folder_operations = FolderOperations(
    denied_operations=settings.disabled_folder_tools,
    read_file_exclusions=settings.read_file_exclusions,
    list_folder_exclusions=settings.list_folder_exclusions,
)
```

--------------------------------

### DISABLED_FILE_TOOLS Environment Variable Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Example of setting the DISABLED_FILE_TOOLS environment variable to disable 'delete' and 'erase' tools, and starting the server.

```bash
export DISABLED_FILE_TOOLS='["delete", "erase"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### create() Method Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Creates a folder at the specified path.

```python
result = await folder_ops.create(ctx, "/path/to/new_folder")
if result:
    print("Folder created successfully")
```

--------------------------------

### MCP Server Integration Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Example demonstrating how to register FileOperations with a FastMCP instance.

```python
from fastmcp import FastMCP
from filesystem_operations_mcp.servers.multi_file_operations import FileOperations

mcp = FastMCP("FileOperations")
file_ops = FileOperations()
file_ops.register_all(mcp)
mcp.run()
```

--------------------------------

### Example 1: Disable destructive operations

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Configuration example using environment variables to disable delete and erase operations for files and folders.

```bash
export DISABLED_FILE_TOOLS='["delete", "erase"]'
export DISABLED_FOLDER_TOOLS='["delete"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### FileReadSuccess Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/types.md

Example usage of the FileReadSuccess class.

```python
success = FileReadSuccess(
    file_path="README.md",
    content="# My Project\n\nThis is a great project."
)
```

--------------------------------

### delete() example usage

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Example of how to use the delete() function to remove a file.

```python
result = await file_ops.delete(ctx, "/path/to/file.txt")
if result:
    print("File deleted successfully")
```

--------------------------------

### Logger Initialization

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Example of how each module initializes its logger using Python's logging module.

```python
from logging import Logger, getLogger

logger: Logger = getLogger(__name__)
```

--------------------------------

### read_all() Example 2: Read first 10 lines

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Example demonstrating how to read only the first 10 lines of each Python file in a folder, excluding test files.

```python
# Read only the first 10 lines of each file
result = await folder_ops.read_all(
    ctx,
    "/src",
    include=["**/*.py"],
    exclude=["**/*_test.py"],
    recurse=True,
    head=10
)
```

--------------------------------

### Create File Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Creates a file with the specified content. If the file already exists, it will be overwritten.

```python
result = await file_ops.create(ctx, "/path/to/new_file.txt", "Hello, World!")
if result:
    print("File created successfully")
```

--------------------------------

### main() usage

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Entry point for running the Bulk Filesystem Operations MCP server. Initializes the root MCP server, registers FileOperations and FolderOperations sub-servers, registers the BulkToolCaller, and starts the server.

```python
from filesystem_operations_mcp.server import main
main()  # Starts the server and runs the event loop
```

--------------------------------

### Catching MCPFolderNotFoundError

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Example of how to catch MCPFolderNotFoundError when attempting to get folder contents.

```python
try:
    files = await folder_ops.contents(ctx, "/missing/folder", ["*"], [], False)
except MCPFolderNotFoundError as e:
    print(f"Folder not found: {e.folder_path}")
```

--------------------------------

### MCP Server Integration Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Example demonstrating how to register FolderOperations with a FastMCP instance and run the server.

```python
from fastmcp import FastMCP
from filesystem_operations_mcp.servers.multi_folder_operations import FolderOperations

mcp = FastMCP("FolderOperations")
folder_ops = FolderOperations()
folder_ops.register_all(mcp)
mcp.run()
```

--------------------------------

### delete() Example 2: Delete a folder and its contents

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Example demonstrating how to delete a folder and all its contents recursively.

```python
# Delete a folder and all its contents
result = await folder_ops.delete(ctx, "/folder/with/contents", recursive=True)
if result:
    print("Folder deleted successfully")
```

--------------------------------

### delete() Example 1: Delete an empty folder

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Example demonstrating how to delete an empty folder.

```python
# Delete an empty folder
result = await folder_ops.delete(ctx, "/empty/folder")
```

--------------------------------

### Disabled Operations Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Example demonstrating how to disable specific file operations.

```python
settings.disabled_file_tools = ["delete", "erase"]
# Result: FileOperations.delete() and FileOperations.erase() are removed
# Tools file.delete and file.erase become unavailable
```

--------------------------------

### Create Virtual Environment and Install Dependencies

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/README.md

Setting up a Python virtual environment and installing project dependencies.

```bash
uv venv
source .venv/bin/activate
uv sync --extra dev
```

--------------------------------

### Server Startup (CLI)

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Commands to start the filesystem-operations-mcp server.

```bash
filesystem-operations-mcp
```

```bash
python -m filesystem_operations_mcp.server
```

--------------------------------

### call_tool_bulk() Example: Create multiple files

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

Example demonstrating how to create multiple files using call_tool_bulk.

```python
# Create multiple files in one request
results = await bulk_caller.call_tool_bulk(
    ctx,
    "file.create",
    [
        {"file_path": "/tmp/file1.txt", "content": "Content 1"},
        {"file_path": "/tmp/file2.txt", "content": "Content 2"},
        {"file_path": "/tmp/file3.txt", "content": "Content 3"},
    ]
)

for result in results:
    print(f"Created: {result}")  # True for each
```

--------------------------------

### Read File Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Reads the content of a file at the specified path.

```python
content = await file_ops.read(ctx, "/path/to/file.txt")
print(content)
```

--------------------------------

### contents() Method Example - Immediate Children Listing

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Lists immediate children of a folder.

```python
# List immediate children
files = await folder_ops.contents(
    ctx,
    "/project",
    include=["*"],
    exclude=[],
    recurse=False
)
```

--------------------------------

### FileReadError Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/types.md

Example usage of the FileReadError class.

```python
error = FileReadError(
    file_path="src/broken.py",
    error="UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80"
)
```

--------------------------------

### call_tools_bulk() Example: Mixed operations

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

Example demonstrating mixed operations (create folders, read files, delete files) using call_tools_bulk.

```python
# Mixed operations: create folders, read files, delete old files
results = await bulk_caller.call_tools_bulk(
    ctx,
    [
        {
            "tool_name": "folder.create",
            "tool_arguments": {"folder_path": "/data/input"}
        },
        {
            "tool_name": "folder.create",
            "tool_arguments": {"folder_path": "/data/output"}
        },
        {
            "tool_name": "file.create",
            "tool_arguments": {
                "file_path": "/data/input/data.txt",
                "content": "Initial data"
            }
        },
        {
            "tool_name": "file.read",
            "tool_arguments": {"file_path": "/data/input/data.txt"}
        },
        {
            "tool_name": "file.delete",
            "tool_arguments": {"file_path": "/data/old.txt"}
        },
    ]
)

print(f"Created folder 1: {results[0]}")       # True
print(f"Created folder 2: {results[1]}")       # True
print(f"Created file: {results[2]}")           # True
print(f"Read content: {results[3]}")           # "Initial data"
print(f"Deleted file: {results[4]}")           # True
```

--------------------------------

### call_tool_bulk() Example: Read multiple files

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

Example demonstrating how to read multiple files using call_tool_bulk.

```python
# Read three files in one request
results = await bulk_caller.call_tool_bulk(
    ctx,
    "file.read",
    [
        {"file_path": "/path/to/file1.txt"},
        {"file_path": "/path/to/file2.txt"},
        {"file_path": "/path/to/file3.txt"},
    ]
)

for i, content in enumerate(results, 1):
    print(f"File {i} content: {content[:50]}...")
```

--------------------------------

### Append to File Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Appends content to an existing file.

```python
result = await file_ops.append(ctx, "/path/to/file.txt", "\nAdditional line")
if result:
    print("Content appended successfully")
```

--------------------------------

### Constructor Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Initializes the FileOperations class and disables any operations specified in `denied_operations` by removing them as attributes from the class.

```python
from filesystem_operations_mcp.servers.multi_file_operations import FileOperations
from fastmcp import FastMCP

file_ops = FileOperations(denied_operations=["delete"])
mcp = FastMCP("FileOps")
file_ops.register_all(mcp)
```

--------------------------------

### Glob Pattern Matching Examples

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Provides examples of fnmatch-style glob patterns used for file and folder operations.

```python
# Pattern examples for recursive listing
"*.txt"         # Match text files in current directory
"**/*.py"       # Match Python files at any depth
"src/**/*.ts"   # Match TypeScript files under src/
"**/test_*.py"  # Match test files anywhere
```

--------------------------------

### call_tool_bulk() Example: Delete multiple files

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

Example demonstrating how to delete multiple files using call_tool_bulk.

```python
# Delete multiple files in one request
results = await bulk_caller.call_tool_bulk(
    ctx,
    "file.delete",
    [
        {"file_path": "/tmp/file1.txt"},
        {"file_path": "/tmp/file2.txt"},
        {"file_path": "/tmp/file3.txt"},
    ]
)
```

--------------------------------

### FolderOperations Constructor Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Initializes the FolderOperations class with denied operations and exclusion patterns.

```python
from filesystem_operations_mcp.servers.multi_folder_operations import FolderOperations

folder_ops = FolderOperations(
    denied_operations=["delete"],
    list_folder_exclusions=["**/.git/**", "**/__pycache__/**"],
    read_file_exclusions=["*.pyc", "*.pyo"]
)
```

--------------------------------

### Catching Specific Errors

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Example demonstrating how to catch specific file operation errors.

```python
from filesystem_operations_mcp.models.errors import (
    MCPFileNotFoundError,
    MCPFileOperationError,
    MCPFileSystemOperationError
)

try:
    content = await file_ops.read(ctx, path)
except MCPFileNotFoundError:
    print(f"File does not exist: {path}")
except MCPFileOperationError as e:
    print(f"Cannot read file {e.file_path}: {e}")
except MCPFileSystemOperationError:
    print("Unexpected filesystem operation error")
```

--------------------------------

### Catching MCPFileSystemOperationError

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Example of how to catch the base filesystem operation error.

```python
try:
    await file_ops.read(ctx, path)
except MCPFileSystemOperationError as e:
    print(f"Filesystem operation failed: {e}")
```

--------------------------------

### Exception Handling Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Illustrates how to catch specific exceptions related to file and folder operations.

```python
from filesystem_operations_mcp.models.errors import (
    MCPFileNotFoundError,
    MCPFileOperationError,
    MCPFolderOperationError,
)

try:
    content = await file_ops.read(ctx, path)
except MCPFileNotFoundError as e:
    print(f"File not found: {e.file_path}")
except MCPFileOperationError as e:
    print(f"Cannot read file {e.file_path}: {e}")
except MCPFolderOperationError as e:
    print(f"Folder error at {e.folder_path}: {e}")
```

--------------------------------

### Catching MCPFolderOperationError

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Example of how to catch MCPFolderOperationError during a folder delete operation.

```python
try:
    result = await folder_ops.delete(ctx, "/non/empty/folder")
except MCPFolderOperationError as e:
    print(f"Cannot delete folder: {e.folder_path}")
    print(f"Error: {e}")
```

--------------------------------

### Catching MCPFileNotFoundError

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Example of how to catch a file not found error and access the file path.

```python
try:
    content = await file_ops.read(ctx, "/missing/file.txt")
except MCPFileNotFoundError as e:
    print(f"File not found: {e.file_path}")
```

--------------------------------

### Create a file with content

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Example of creating a new file and writing content to it using the file_ops.create method.

```python
success = await file_ops.create(ctx, "/path/to/new.txt", "Hello, world!")
```

--------------------------------

### stdio Transport Mode

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Example of running the MCP server using the stdio transport mode.

```python
root_mcp.run(transport="stdio")
```

--------------------------------

### Environment Variable for LIST_FOLDER_EXCLUSIONS

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Example of setting the LIST_FOLDER_EXCLUSIONS environment variable to exclude specific directories from listing operations.

```bash
export LIST_FOLDER_EXCLUSIONS='["**/.git/**", "**/__pycache__/**", "**/node_modules/**"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### contents() Method Example - Recursive Listing

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Lists all Python files recursively, excluding test files.

```python
# List all Python files recursively, excluding test files
files = await folder_ops.contents(
    ctx, 
    "/project",
    include=["**/*.py"],
    exclude=["**/test*.py"],
    recurse=True
)
print(f"Found {len(files)} Python files")
```

--------------------------------

### Differentiating File and Folder Errors

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Example showing how to differentiate between file and folder operation errors.

```python
try:
    await file_ops.read(ctx, path)
except MCPFileOperationError as e:
    print(f"File error at: {e.file_path}")
except MCPFolderOperationError as e:
    print(f"Folder error at: {e.folder_path}")
```

--------------------------------

### Erase File Content Example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Erases all content from a file, leaving it empty.

```python
result = await file_ops.erase(ctx, "/path/to/file.txt")
if result:
    print("File content erased")
```

--------------------------------

### Batch copy operation example

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

This code snippet demonstrates a batch operation to read multiple files from a source and then create them in a destination with their content.

```python
results = await bulk_caller.call_tools_bulk(
    ctx,
    [
        {"tool_name": "file.read", "tool_arguments": {"file_path": "/src/file1.txt"}},
        {"tool_name": "file.read", "tool_arguments": {"file_path": "/src/file2.txt"}},
        {"tool_name": "file.read", "tool_arguments": {"file_path": "/src/file3.txt"}},
    ]
)

# Then create in destination
create_calls = [
    {
        "tool_name": "file.create",
        "tool_arguments": {
            "file_path": f"/dst/file{i}.txt",
            "content": results[i-1]
        }
    }
    for i in range(1, 4)
]

create_results = await bulk_caller.call_tools_bulk(ctx, create_calls)
print(f"Copied {sum(create_results)} files")  # 3
```

--------------------------------

### Catching MCPFileOperationError

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Example of how to catch a file operation error and access the file path.

```python
try:
    result = await file_ops.create(ctx, "/protected/file.txt", "content")
except MCPFileOperationError as e:
    print(f"Cannot write to file: {e.file_path}")
    print(f"Error: {e}")
```

--------------------------------

### sse Transport Mode

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Example of running the MCP server using the sse (Server-Sent Events) transport mode.

```python
root_mcp.run(transport="sse")
```

--------------------------------

### Transport Modes

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Commands to start the server with different transport modes.

```bash
MCP_TRANSPORT=stdio filesystem-operations-mcp
```

```bash
MCP_TRANSPORT=sse filesystem-operations-mcp
```

--------------------------------

### Read all Python files in a directory

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Example of reading all Python files within a directory, with options for inclusion, exclusion, and recursion, using the folder_ops.read_all method.

```python
result = await folder_ops.read_all(
    ctx,
    "/src",
    include=["**/*.py"],
    exclude=["**/test_*.py"],
    recurse=True
)

for file_result in result.results:
    print(f"{file_result.file_path}: {len(file_result.content)} bytes")
```

--------------------------------

### Read a single file

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Example of reading the content of a single file using the file_ops.read method.

```python
content = await file_ops.read(ctx, "/path/to/file.txt")
```

--------------------------------

### Import Paths for Application Initialization

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Import paths for application initialization.

```python
from filesystem_operations_mcp.server import main
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings
```

--------------------------------

### Programmatic Configuration

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Demonstrates how to load settings from the environment and configure Filesystem Operations MCP servers programmatically in Python, including disabling operations and setting exclusion patterns.

```python
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings
from filesystem_operations_mcp.servers.multi_file_operations import FileOperations
from filesystem_operations_mcp.servers.multi_folder_operations import FolderOperations
from fastmcp import FastMCP

# Load configuration from environment
settings = FilesystemOperationsMCPSettings()

# Create MCP servers
root_mcp = FastMCP("FilesystemOperationsMCP")
file_mcp = FastMCP("FileOperations")
folder_mcp = FastMCP("FolderOperations")

# Initialize with disabled operations
file_operations = FileOperations(denied_operations=settings.disabled_file_tools)
file_operations.register_all(file_mcp)

folder_operations = FolderOperations(
    denied_operations=settings.disabled_folder_tools,
    read_file_exclusions=settings.read_file_exclusions,
    list_folder_exclusions=settings.list_folder_exclusions
)
folder_operations.register_all(folder_mcp)

# Mount and run
root_mcp.mount("file", file_mcp)
root_mcp.mount("folder", folder_mcp)
root_mcp.run(transport=settings.mcp_transport)
```

--------------------------------

### Programmatic Usage of LIST_FOLDER_EXCLUSIONS

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Demonstrates how to programmatically set list_folder_exclusions when initializing FolderOperations.

```python
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings

settings = FilesystemOperationsMCPSettings()
folder_ops = FolderOperations(list_folder_exclusions=settings.list_folder_exclusions)

# Now contents() will exclude folders matching these patterns
files = await folder_ops.contents(
    ctx,
    "/project",
    include=["**/*.py"],
    exclude=[],
    recurse=True
)
# .git, __pycache__, and node_modules folders are automatically excluded
```

--------------------------------

### FilesystemOperationsMCPSettings usage

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Pydantic Settings model for loading configuration from environment variables.

```python
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings

settings = FilesystemOperationsMCPSettings()
print(settings.mcp_transport)           # "stdio"
print(settings.disabled_file_tools)     # []
```

--------------------------------

### Entry Point Function

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

The main function serves as the entry point for the Bulk Filesystem Operations MCP server.

```python
def main():
    """
    Entry point for running the Bulk Filesystem Operations MCP server.
    """
```

--------------------------------

### Programmatic usage of DISABLED_FOLDER_TOOLS

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Python code demonstrating how to load and use DISABLED_FOLDER_TOOLS programmatically.

```python
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings

settings = FilesystemOperationsMCPSettings()
print(settings.disabled_folder_tools)  # ['delete']

folder_ops = FolderOperations(denied_operations=settings.disabled_folder_tools)
```

--------------------------------

### Programmatic usage of DISABLED_FILE_TOOLS

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Python code demonstrating how to load and use DISABLED_FILE_TOOLS programmatically.

```python
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings

settings = FilesystemOperationsMCPSettings()
print(settings.disabled_file_tools)  # ['delete', 'erase']

file_ops = FileOperations(denied_operations=settings.disabled_file_tools)
```

--------------------------------

### Import Paths for Utilities

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Import paths for utilities.

```python
from filesystem_operations_mcp.utils.exception_handling import (
    handle_file_errors,
    handle_folder_errors,
)
```

--------------------------------

### Programmatic usage of READ_FILE_EXCLUSIONS

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Python code demonstrating how to load and use READ_FILE_EXCLUSIONS programmatically for folder operations.

```python
from filesystem_operations_mcp.models.settings import FilesystemOperationsMCPSettings

settings = FilesystemOperationsMCPSettings()
folder_ops = FolderOperations(read_file_exclusions=settings.read_file_exclusions)

# Now read_all() will exclude files matching these patterns
result = await folder_ops.read_all(
    ctx,
    "/src",
    include=["**/*.py"],
    exclude=[],
    recurse=True
)
# .pyc and .bak files are automatically excluded
```

--------------------------------

### FileOperations Initialization

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Initializes the FileOperations sub-server, potentially disabling specific tools based on settings.

```python
file_operations = FileOperations(denied_operations=settings.disabled_file_tools)
file_operations.register_all(file_mcp)
```

--------------------------------

### FolderOperations Initialization

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Initializes the FolderOperations sub-server, handling disabled operations and exclusion patterns.

```python
folder_operations = FolderOperations(
    denied_operations=settings.disabled_folder_tools,
    read_file_exclusions=settings.read_file_exclusions,
    list_folder_exclusions=settings.list_folder_exclusions
)
folder_operations.register_all(folder_mcp)
```

--------------------------------

### Usage Pattern for File Error Handler

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

Demonstrates how to use the `handle_file_errors` context manager in a file reading operation.

```python
async def read(self, ctx: Context, file_path: str) -> str:
    async with handle_file_errors(file_path):
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()
        await ctx.info(f"File read successfully from {file_path}")
        return content
```

--------------------------------

### Default Folders excluded from contents() and read_all()

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

A Python list of default folder patterns excluded from contents() and read_all() operations.

```python
DEFAULT_SKIP_LIST = [
    "**/.?*/**",      # Hidden folders and their contents
    ".?*/**",          # Hidden folders in root
    "**/.?*",         # Hidden files anywhere
    "**/.git/**",     # Git repositories
    ".git/*",         # Git in root
    "**/.svn/**",     # SVN repositories
    ".svn/*",         # SVN in root
    "**/.mypy_cache/**",    # MyPy cache
    ".mypy_cache/*",
    "**/.pytest_cache/**",  # Pytest cache
    "*.pytest_cache/*",
    "**/__pycache__/**",    # Python bytecode cache
    "*__pycache__/*",
    "**/.venv/**",    # Python virtual environments
    ".venv/*",
]
```

--------------------------------

### MCPFolderOperationError constructor

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Exception for folder operation errors. Includes the folder path that caused the error.

```python
class MCPFolderOperationError(MCPFileSystemOperationError):
    folder_path: str
    def __init__(self, message: str, folder_path: str) -> None
```

--------------------------------

### FilesystemOperationsMCPSettings Class Definition

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Definition of the Pydantic settings class for Filesystem Operations MCP.

```python
from pydantic_settings import BaseSettings, SettingsConfigDict

class FilesystemOperationsMCPSettings(BaseSettings):
    model_config = SettingsConfigDict()
    
    mcp_transport: Literal["stdio", "sse"] = Field(
        default="stdio",
        description="The transport protocol for the MCP server"
    )
    disabled_file_tools: list[str] = Field(
        default_factory=list,
        description="List of disabled file tools"
    )
    disabled_folder_tools: list[str] = Field(
        default_factory=list,
        description="List of disabled folder tools"
    )
    read_file_exclusions: list[str] = Field(
        default_factory=lambda: DEFAULT_SKIP_READ,
        description="List of file patterns to exclude from all multi-read operations"
    )
    list_folder_exclusions: list[str] = Field(
        default_factory=lambda: DEFAULT_SKIP_LIST,
        description="List of folder patterns to exclude from listing operations"
    )
```

--------------------------------

### Dependency Graph

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Visual representation of the dependency graph.

```text
filesystem_operations_mcp.server (entry point)
├── fastmcp.FastMCP
├── fastmcp.contrib.BulkToolCaller
└── filesystem_operations_mcp.models.settings.FilesystemOperationsMCPSettings
├── filesystem_operations_mcp.servers.multi_file_operations.FileOperations
│   ├── fastmcp.MCPMixin
│   └── filesystem_operations_mcp.utils.exception_handling.handle_file_errors
└── filesystem_operations_mcp.servers.multi_folder_operations.FolderOperations
    ├── fastmcp.MCPMixin
    ├── filesystem_operations_mcp.utils.exception_handling.handle_folder_errors
    ├── filesystem_operations_mcp.servers.multi_folder_operations.FileReadSummary
    ├── filesystem_operations_mcp.servers.multi_folder_operations.FileReadError
    └── filesystem_operations_mcp.servers.multi_folder_operations.FileReadSuccess
```

--------------------------------

### MCPFileOperationError constructor

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Exception for file operation errors. Includes the file path that caused the error.

```python
class MCPFileOperationError(MCPFileSystemOperationError):
    file_path: str
    def __init__(self, message: str, file_path: str) -> None
```

--------------------------------

### Default Files excluded from read_all()

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

A Python list of default file patterns excluded from read_all() operations.

```python
DEFAULT_SKIP_READ = [
    "*.pyc",
    "*.pyo",
    "*.pyd",
    "*.hg",
    "*.tox",
    "*.com",
    "*.class",
    "*.dll",
    "*.exe",
    "*.o",
    "*.so",
    "*.7z",
    "*.dmg",
    "*.gz",
    "*.iso",
    "*.jar",
    "*.rar",
    "*.tar",
    "*.zip",
    "*.msi",
    "*.sqlite",
    "*.DS_Store",
    "*.DS_Store?",
    "*._*",
    "*.Spotlight-V100",
    "*.Trashes",
    "*ehthumbs.db",
    "*Thumbs.db",
    "*desktop.ini",
    "*.bak",
    "*.swp",
    "*.swo",
    "*~",
    "*#",
]
```

--------------------------------

### FolderOperations Class

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Provides MCP tools for folder manipulation. Inherits from MCPMixin and includes methods for creating, reading, moving, and deleting folders and their contents.

```python
class FolderOperations(MCPMixin):
    read_file_exclusions: list[str]
    list_folder_exclusions: list[str]
    
    def __init__(
        self,
        denied_operations: list[str] | None = None,
        list_folder_exclusions: list[str] | None = None,
        read_file_exclusions: list[str] | None = None,
    ) -> None
    
    def _matches_globs(self, path: str, include: list[str], exclude: list[str]) -> bool
    
    async def create(self, ctx: Context, folder_path: str) -> bool
    async def contents(
        self,
        ctx: Context,
        folder_path: str,
        include: list[str],
        exclude: list[str],
        recurse: bool,
        bypass_default_exclusions: bool = False,
    ) -> list
    async def read_all(
        self,
        ctx: Context,
        folder_path: str,
        include: list[str],
        exclude: list[str],
        recurse: bool,
        head: int = 0,
        tail: int = 0,
        bypass_default_exclusions: bool = False,
    ) -> FileReadSummary
    async def move(self, ctx: Context, source_path: str, destination_path: str) -> bool
    async def delete(self, ctx: Context, folder_path: str, recursive: bool = False) -> bool
```

--------------------------------

### Custom exclusion patterns

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Sets environment variables for custom exclusion patterns for file reads and folder listings, allowing fine-grained control over which files and folders are excluded from operations.

```bash
export READ_FILE_EXCLUSIONS='["*.log", "*.tmp", "*.cache"]'
export LIST_FOLDER_EXCLUSIONS='["**/.git/**", "**/__pycache__/**", "**/node_modules/**"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### Import Paths for Folder Operations

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Import paths for folder operations.

```python
from filesystem_operations_mcp.servers.multi_folder_operations import FolderOperations
from filesystem_operations_mcp.servers.multi_folder_operations import (
    FileReadError,
    FileReadSuccess,
    FileReadSummary,
)
```

--------------------------------

### Point uvx to a Branch

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/README.md

Configuring the uvx command to point to a specific branch of the repository.

```string
"git+https://github.com/strawgate/filesystem-operations-mcp@branch-name"
```

--------------------------------

### Batch create multiple files

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Demonstrates how to create multiple files with specified content in a batch operation.

```python
results = await bulk_caller.call_tool_bulk(
    ctx,
    "file.create",
    [
        {"file_path": "/tmp/file1.txt", "content": "Content 1"},
        {"file_path": "/tmp/file2.txt", "content": "Content 2"},
    ]
)
```

--------------------------------

### Folder Operations Error Handler

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

An asynchronous context manager for handling folder-related exceptions and raising project-specific errors.

```python
from contextlib import asynccontextmanager

@asynccontextmanager
async def handle_folder_errors(path: str):
    try:
        yield
    except FileNotFoundError:
        raise MCPFolderNotFoundError(path)
    except PermissionError as e:
        raise MCPFolderOperationError(f"Permission denied: {e}", path)
    except Exception as e:
        raise MCPFolderOperationError(f"An unexpected error occurred: {e}", path)
```

--------------------------------

### move() function signature

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Asynchronous function signature for moving a file.

```python
async def move(self, ctx: Context, source_path: str, destination_path: str) -> bool
```

--------------------------------

### MCPFileNotFoundError constructor

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Exception raised when a file is not found. Subclass of `MCPFileOperationError`.

```python
class MCPFileNotFoundError(MCPFileOperationError):
    def __init__(self, file_path: str) -> None
```

--------------------------------

### Import Paths for Error Handling

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Import paths for error handling.

```python
from filesystem_operations_mcp.models.errors import (
    MCPFileSystemOperationError,
    MCPFileOperationError,
    MCPFolderOperationError,
    MCPFileNotFoundError,
    MCPFolderNotFoundError,
)
```

--------------------------------

### Import Paths for File Operations

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Import paths for file operations.

```python
from filesystem_operations_mcp.servers.multi_file_operations import FileOperations
```

--------------------------------

### handle_folder_errors() Usage

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Async context manager for handling folder operation exceptions. Same pattern as handle_file_errors() but for folder operations.

```python
from filesystem_operations_mcp.utils.exception_handling import handle_folder_errors

async with handle_folder_errors(folder_path):
    os.makedirs(folder_path, exist_ok=True)
```

--------------------------------

### SSE transport with security

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Configures the server to use HTTP-based SSE transport and disables delete operations for both files and folders, enhancing security.

```bash
export MCP_TRANSPORT=sse
export DISABLED_FILE_TOOLS='["delete"]'
export DISABLED_FOLDER_TOOLS='["delete"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### External Dependencies: FastMCP

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Imports for FastMCP library.

```python
from fastmcp import FastMCP, Context
from fastmcp.contrib.mcp_mixin import MCPMixin, mcp_tool
from fastmcp.contrib.bulk_tool_caller import BulkToolCaller
```

--------------------------------

### File Operations Error Handler

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/server-architecture.md

An asynchronous context manager to handle file-related exceptions and raise project-specific errors.

```python
from contextlib import asynccontextmanager

@asynccontextmanager
async def handle_file_errors(path: str):
    try:
        yield
    except FileNotFoundError:
        raise MCPFileNotFoundError(path)
    except PermissionError as e:
        raise MCPFileOperationError(f"Permission denied: {e}", path)
    except Exception as e:
        raise MCPFileOperationError(f"An unexpected error occurred: {e}", path)
```

--------------------------------

### Run Server Locally

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/README.md

Running the Filesystem Operations MCP Server locally for testing.

```bash
python -m filesystem-operations-mcp.server
# or using the installed script
filesystem-operations-mcp
```

--------------------------------

### FileOperations Class

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Provides MCP tools for file manipulation. Inherits from MCPMixin and all methods are asynchronous and decorated with @mcp_tool().

```python
class FileOperations(MCPMixin):
    def __init__(self, denied_operations: list[str] | None = None) -> None
    
    async def read(self, ctx: Context, file_path: str) -> str
    async def create(self, ctx: Context, file_path: str, content: str) -> bool
    async def append(self, ctx: Context, file_path: str, content: str) -> bool
    async def erase(self, ctx: Context, file_path: str) -> bool
    async def move(self, ctx: Context, source_path: str, destination_path: str) -> bool
    async def delete(self, ctx: Context, file_path: str) -> bool
```

--------------------------------

### MCPFileNotFoundError

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Exception raised when a file is not found.

```python
class MCPFileNotFoundError(MCPFileOperationError):
    def __init__(self, file_path):
        super().__init__("File not found", file_path)
```

--------------------------------

### Read-only mode

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/configuration.md

Sets environment variables to disable all write operations, making the filesystem read-only. Only read operations like file.read and folder.contents are available.

```bash
export DISABLED_FILE_TOOLS='["create", "append", "erase", "move", "delete"]'
export DISABLED_FOLDER_TOOLS='["create", "move", "delete"]'
python -m filesystem_operations_mcp.server
```

--------------------------------

### External Dependencies: Pydantic

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Imports for Pydantic library.

```python
from pydantic import BaseModel, Field
from pydantic_settings import BaseSettings, SettingsConfigDict
```

--------------------------------

### Local MCP Client Configuration

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/README.md

MCP server configuration to point an MCP Client to a local server instance.

```json
"filesystem_operations_mcp": {
  "url": "http://localhost:8000/sse",
  "disabled": true,
  "autoApprove": [],
  "timeout": 30,
  "alwaysAllow": []
}
```

--------------------------------

### read_all() function signature

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

The function signature for read_all, detailing its parameters and return type.

```python
async def read_all(
    self,
    ctx: Context,
    folder_path: str,
    include: list[str],
    exclude: list[str],
    recurse: bool,
    head: int = 0,
    tail: int = 0,
    bypass_default_exclusions: bool = False
) -> FileReadSummary
```

--------------------------------

### handle_file_errors() Usage

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Async context manager for handling file operation exceptions. Wraps file operations and converts standard Python exceptions to project-specific exceptions.

```python
from filesystem_operations_mcp.utils.exception_handling import handle_file_errors

async with handle_file_errors(file_path):
    with open(file_path, "r") as f:
        content = f.read()
```

--------------------------------

### Clone Repository

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/README.md

Cloning the filesystem-operations-mcp repository.

```bash
# Replace with the actual repository URL
git clone https://github.com/strawgate/filesystem-operations-mcp.git
cd filesystem-operations-mcp
```

--------------------------------

### Error Handling Pattern for Folder Operations

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Using the handle_folder_errors context manager for folder operations.

```python
from filesystem_operations_mcp.utils.exception_handling import handle_folder_errors

async with handle_folder_errors(folder_path):
    # Folder operation code
    os.makedirs(folder_path, exist_ok=True)
```

--------------------------------

### MCPFolderNotFoundError Exception

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Defines the MCPFolderNotFoundError exception, raised when a folder is not found. It is a subclass of MCPFolderOperationError.

```python
class MCPFolderNotFoundError(MCPFolderOperationError):
    def __init__(self, folder_path: str) -> None
```

--------------------------------

### call_tools_bulk() Signature

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

Signature for the call_tools_bulk method, which allows calling multiple different tools with different arguments in one request.

```python
async def call_tools_bulk(
    self,
    ctx: Context,
    tool_calls: list[dict]
) -> list
```

--------------------------------

### FileReadSummary Model

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Summary of results from reading all files in a folder, including counts of total files, skipped files, errors, and successful read results.

```python
class FileReadSummary(BaseModel):
    total_files: int = Field(default=0)
    skipped_files: int = Field(default=0)
    errors: list[FileReadError] = Field(default_factory=list)
    results: list[FileReadSuccess] = Field(default_factory=list)
```

--------------------------------

### delete() function signature

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-fileoperations.md

Asynchronous function signature for deleting a file.

```python
async def delete(self, ctx: Context, file_path: str) -> bool
```

--------------------------------

### call_tool_bulk() Signature

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-bulk-tools.md

Signature for the call_tool_bulk method, which allows calling a single tool multiple times with different arguments in one request.

```python
async def call_tool_bulk(
    self,
    ctx: Context,
    tool_name: str,
    tool_arguments: list[dict]
) -> list
```

--------------------------------

### Error Handling Pattern for File Operations

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Using the handle_file_errors context manager for file operations.

```python
from filesystem_operations_mcp.utils.exception_handling import handle_file_errors

async with handle_file_errors(file_path):
    # File operation code
    with open(file_path, "r") as f:
        content = f.read())
```

--------------------------------

### VS Code McpServer Configuration

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/README.md

Configuration for the Filesystem Operations MCP Server in VS Code's user settings.

```json
{
    "mcp": {
        "servers": {
            "Filesystem Operations": {
                "command": "uvx",
                "args": [
                    "https://github.com/strawgate/mcp-many-files.git"
                ]
            }
        }
    }
}
```

--------------------------------

### MCPFileSystemOperationError Base Exception

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Base exception for all bulk filesystem operations errors.

```python
class MCPFileSystemOperationError(Exception):
    """Base exception for bulk filesystem operations."""
    pass
```

--------------------------------

### _matches_globs() method signature

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

Signature for the helper method to check if a path matches include and exclude glob patterns.

```python
def _matches_globs(self, path: str, include: list[str], exclude: list[str]) -> bool
```

--------------------------------

### Delete a folder recursively

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/README.md

Shows how to delete a folder and all its contents recursively.

```python
success = await folder_ops.delete(ctx, "/path/to/folder", recursive=True)
```

--------------------------------

### Accessing Error Attributes

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

This snippet demonstrates how to catch a specific MCPFileOperationError and access its attributes like `file_path` and the full error message.

```python
try:
    await file_ops.delete(ctx, "/protected/file")
except MCPFileOperationError as e:
    # Access the file path that caused the error
    failed_path = e.file_path
    # Access the full error message
    error_msg = str(e)
```

--------------------------------

### delete() function signature

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/api-reference-folderoperations.md

The function signature for delete, detailing its parameters and return type.

```python
async def delete(self, ctx: Context, folder_path: str, recursive: bool = False) -> bool
```

--------------------------------

### MCPFileOperationError

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Exception raised for errors during file operations.

```python
class MCPFileOperationError(MCPFileSystemOperationError):
    def __init__(self, message, file_path):
        self.file_path = file_path
        super().__init__(f"Error performing operation on file {file_path}: {message}")
```

--------------------------------

### MCPFolderNotFoundError Definition

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Python class definition for MCPFolderNotFoundError, inheriting from MCPFolderOperationError.

```python
class MCPFolderNotFoundError(MCPFolderOperationError):
    def __init__(self, folder_path):
        super().__init__("Folder not found", folder_path)
```

--------------------------------

### Roo Code / Cline McpServer Configuration

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/README.md

Configuration for the Filesystem Operations MCP Server in Roo Code / Cline McpServer.

```json
    "Filesystem Operations": {
      "command": "uvx",
      "args": [
        "https://github.com/strawgate/mcp-many-files.git"
      ],
      "alwaysAllow": [
        "file_read",
        "file_create",
        "file_append",
        "file_erase",
        "file_move",
        "file_delete",
        "folder_create",
        "folder_contents",
        "folder_move",
        "folder_delete",
        "folder_empty",
        "call_tool_bulk",
        "call_tools_bulk"
      ]
    },
```

--------------------------------

### FileReadSuccess Class Definition

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/types.md

Represents a successful file read operation.

```python
class FileReadSuccess(BaseModel):
    file_path: str
    content: str
```

--------------------------------

### FileReadSummary Class Definition

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/types.md

Summary of the results from reading all files in a folder.

```python
class FileReadSummary(BaseModel):
    total_files: int = Field(default=0, description="Total number of files processed")
    skipped_files: int = Field(default=0, description="Number of files skipped due to exclusions")
    errors: list[FileReadError] = Field(default_factory=list, description="List of errors encountered while reading files")
    results: list[FileReadSuccess] = Field(default_factory=list, description="List of successfully read files with their content")
```

--------------------------------

### BaseMultiFileReadResult Class Definition

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/types.md

Base model for file read results (parent class for FileReadError).

```python
class BaseMultiFileReadResult(BaseModel):
    file_path: str
```

--------------------------------

### FileReadError Model

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/modules.md

Represents an error that occurred while reading a file, inheriting from BaseMultiFileReadResult and including an error message.

```python
class FileReadError(BaseMultiFileReadResult):
    error: str
```

--------------------------------

### MCPFolderOperationError Definition

Source: https://github.com/strawgate/filesystem-operations-mcp/blob/main/_autodocs/errors.md

Python class definition for MCPFolderOperationError, inheriting from MCPFileSystemOperationError.

```python
class MCPFolderOperationError(MCPFileSystemOperationError):
    def __init__(self, message, folder_path):
        self.folder_path = folder_path
        super().__init__(f"Error performing operation on folder {folder_path}: {message}")
```
Tokens:
Raw