home / mcp / fastfs mcp server

FastFS MCP Server

faster filesystem and git operations in a single MCP server - Docker -

Installation

Add the following to your MCP client configuration file.

Configuration

{
  "mcpServers": {
    "aj-geddes-fastfs-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "C:\\\\Users\\\\username:/mnt/workspace:rw",
        "fastfs-mcp"
      ],
      "env": {
        "GITHUB_APP_ID": "your_app_id",
        "GITHUB_APP_PRIVATE_KEY": "-----BEGIN RSA PRIVATE KEY-----\\n...\\n-----END RSA PRIVATE KEY-----",
        "GITHUB_APP_INSTALLATION_ID": "your_installation_id",
        "GITHUB_APP_PRIVATE_KEY_PATH": "/mnt/workspace/github-app-key.pem",
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

FastFS-MCP lets you talk to a FastFS-based server from an MCP client to perform ultra-fast filesystem operations, Git repository actions, and interactive prompts. It runs in a container and exposes a simple, structured interface that Claude and other AI tools can use to read, write, and manage your local files and Git workspaces securely.

How to use

To use FastFS-MCP, start the server in a container and connect with an MCP client that can send command requests and receive structured results. The common workflow is to launch the server with your local workspace mounted, then point your MCP client to that running container. You can perform filesystem tasks, manage Git repositories, and drive interactive prompts from the same channel.

How to install

Prerequisites you need before installing: Docker, a local workspace you want Claude to access, and optionally GitHub credentials if you plan to operate on GitHub-hosted repositories.

# Build the Docker image
docker build -t fastfs-mcp .

# Run with your local filesystem mounted
docker run -i --rm \
  -v C:\Users\username:/mnt/workspace:rw \
  fastfs-mcp

# On Unix/macOS, replace the volume mount path with your home directory
# Example: -v $HOME:/mnt/workspace:rw

Additional configuration and security considerations

If you plan to authenticate with GitHub, you can provide credentials in the container environment. For example, you can pass a GitHub Personal Access Token or GitHub App credentials when you start the container, and you can additionally supply an environment block with the token or private key. Use only the credentials you need and prefer private-key-based GitHub Apps for stronger security.

The recommended way to run with a prepared environment is to expose your workspace and pass credentials via environment variables when launching the container. Keep sensitive values out of command history and consider mounting private keys from your workspace rather than embedding them in the container environment.

Server connection and environment details

The MCP connection example shown uses a stdio configuration that runs a Docker container locally and exposes the filesystem via a mounted workspace. This is the primary method for connecting your MCP client to the server when you want to operate directly against your machine.

{
  "mcpServers": {
    "filesystem": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "C:\\Users\\username:/mnt/workspace:rw",
        "fastfs-mcp"
      ]
    }
  }
}

Troubleshooting notes

If you encounter permission errors when mounting the workspace, ensure the host directory has appropriate read/write permissions and that Docker is allowed to access the path. On Windows, ensure the Docker daemon is configured to access the C:\

Notes

FastFS-MCP is intended for AI-enhanced workflows that combine filesystem access, Git operations, and interactive prompts in a single conversational interface. Start with a minimal workspace to verify connectivity, then gradually mount additional directories as your needs grow.

Security considerations

Limit the directories exposed to Claude to what is strictly required for your tasks. Use separate credentials for GitHub operations and prefer GitHub Apps over Personal Access Tokens when possible. Regularly review logs and commands executed by the server to detect unusual activity.

Tools and capabilities overview

This MCP server provides broad file-system operations, Git tooling, and interactive prompts. Tools include common filesystem commands (ls, cd, read, write), a full suite of Git commands (clone, commit, push, pull, log, diff, etc.), and templates plus interactive prompts to guide user input during project setup or file operations.

Available tools

ls

List files and directories in a path

cd

Change the current working directory

pwd

Print the current working directory

read

Read and display file contents

write

Create or modify files in the filesystem

grep

Search file contents efficiently using ripgrep

which

Locate executables in the PATH

tree

Display directory structure in a tree view

find

Find files by pattern across directories

cp

Copy files or directories that match patterns or paths

mv

Move or rename files or directories

rm

Remove files or directories

mkdir

Create new directories

stat

Display file metadata and attributes

chmod

Change file permissions

du

Show disk usage for directories/files

df

Show disk space usage across filesystems

touch

Create a new file or update timestamps

sed

Stream editor for text transformation

gawk

Text processing with AWK syntax for complex patterns

head

Show the first lines of a file

tail

Show the last lines of a file

wc

Count lines, words, and bytes in files

cut

Select columns from text data

sort

Sort lines in text files

uniq

Filter repeated lines and unique occurrences

nl

Number lines in a file

split

Split a file into parts based on size or lines

readlink

Print resolved path of a symbolic link

realpath

Print the resolved absolute path of a file

tar

Create or extract tar archives

gzip

Compress or decompress gzip files

zip

Create or extract zip archives

clone

Clone a Git repository (via Git commands)