MCP Git

🚀 mcp-server-git: A git MCP server

A Model Context Protocol server for Git repository interaction and automation, enabling reading, searching, and manipulation of Git repositories via Large Language Models.

🚀 Quick Start

This mcp-server-git is a Model Context Protocol server designed for interacting with and automating Git repositories. It offers a suite of tools to perform various Git operations using Large Language Models.

Please note that mcp-server-git is currently in its early development phase. The functionality and available tools are subject to change and expansion as we continue to enhance the server.

✨ Features

Tools

1. git_status

   • Displays the working tree status.
   • Input:
     • repo_path (string): Path to the Git repository.
   • Returns: The current status of the working directory as text output.

2. git_diff_unstaged

   • Shows changes in the working directory that are not yet staged.
   • Input:
     • repo_path (string): Path to the Git repository.
   • Returns: Diff output of the unstaged changes.

3. git_diff_staged

   • Displays changes that are staged for commit.
   • Input:
     • repo_path (string): Path to the Git repository.
   • Returns: Diff output of the staged changes.

4. git_diff

   • Shows differences between branches or commits.
   • Inputs:
     • repo_path (string): Path to the Git repository.
     • target (string): Target branch or commit to compare with.
   • Returns: Diff output comparing the current state with the target.

5. git_commit

   • Records changes to the repository.
   • Inputs:
     • repo_path (string): Path to the Git repository.
     • message (string): Commit message.
   • Returns: Confirmation with the new commit hash.

6. git_add

   • Adds file contents to the staging area.
   • Inputs:
     • repo_path (string): Path to the Git repository.
     • files (string[]): Array of file paths to stage.
   • Returns: Confirmation of the staged files.

7. git_reset

   • Unstages all staged changes.
   • Input:
     • repo_path (string): Path to the Git repository.
   • Returns: Confirmation of the reset operation.

8. git_log

   • Shows the commit logs.
   • Inputs:
     • repo_path (string): Path to the Git repository.
     • max_count (number, optional): Maximum number of commits to show (default: 10).
   • Returns: Array of commit entries with hash, author, date, and message.

9. git_create_branch

   • Creates a new branch.
   • Inputs:
     • repo_path (string): Path to the Git repository.
     • branch_name (string): Name of the new branch.
     • start_point (string, optional): Starting point for the new branch.
   • Returns: Confirmation of the branch creation.

10. git_checkout

    • Switches branches.
    • Inputs:
      • repo_path (string): Path to the Git repository.
      • branch_name (string): Name of the branch to checkout.
    • Returns: Confirmation of the branch switch.

11. git_show

    • Shows the contents of a commit.
    • Inputs:
      • repo_path (string): Path to the Git repository.
      • revision (string): The revision (commit hash, branch name, tag) to show.
    • Returns: Contents of the specified commit.

12. git_init

    • Initializes a Git repository.
    • Inputs:
      • repo_path (string): Path to the directory to initialize the Git repo.
    • Returns: Confirmation of the repository initialization.

📦 Installation

Using uv (recommended)

When using uv, no specific installation is required. We will use uvx to directly run mcp-server-git.

Using PIP

Alternatively, you can install mcp-server-git via pip:

pip install mcp-server-git

After installation, you can run it as a script using:

python -m mcp_server_git

📚 Documentation

Configuration

Environment Variables

The server supports loading environment variables from .env files with the following precedence order:

1. Project-specific .env file - .env file in the current working directory.
2. Repository-specific .env file - .env file in the repository directory (when using the --repository argument).
3. ClaudeCode working directory .env file - .env file in the ClaudeCode workspace root (automatically detected).
4. System environment variables - Standard environment variables.

Example .env file

Create a .env file in your project directory or ClaudeCode workspace:

# GitHub API Token for GitHub integration features
# Get your token from: https://github.com/settings/tokens
GITHUB_TOKEN=your_github_token_here

# Optional: Custom GitHub API base URL (for GitHub Enterprise)
# GITHUB_API_BASE_URL=https://api.github.com

# Optional: Log level for debugging
# LOG_LEVEL=INFO

Note: The .env file is loaded automatically when the server starts. The server intelligently detects ClaudeCode workspace directories by traversing up from both the current working directory and the repository path (if provided via the --repository argument). If no .env files are found, the server will use system environment variables.

For ClaudeCode users: If you have your .env file in your ClaudeCode workspace root (e.g., /home/memento/ClaudeCode/.env), it will be automatically detected and loaded when running the MCP server from any subdirectory within that workspace.

Usage with Claude Desktop

Add this to your claude_desktop_config.json:

Usage with VS Code

For quick installation, use one of the one-click install buttons below:

For manual installation, add the following JSON block to your User Settings (JSON) file in VS Code. You can do this by pressing Ctrl + Shift + P and typing Preferences: Open Settings (JSON). Optionally, you can add it to a file called .vscode/mcp.json in your workspace. This will allow you to share the configuration with others.

Note that the mcp key is not needed in the .vscode/mcp.json file.

{
  "mcp": {
    "servers": {
      "git": {
        "command": "uvx",
        "args": ["mcp-server-git"]
      }
    }
  }
}

For Docker installation:

{
  "mcp": {
    "servers": {
      "git": {
        "command": "docker",
        "args": [
          "run",
          "--rm",
          "-i",
          "--mount", "type=bind,src=${workspaceFolder},dst=/workspace",
          "mcp/git"
        ]
      }
    }
  }
}

Usage with Zed

Add to your Zed settings.json:

Debugging

You can use the MCP inspector to debug the server. For uvx installations:

npx @modelcontextprotocol/inspector uvx mcp-server-git

Or if you've installed the package in a specific directory or are developing on it:

cd path/to/servers/src/git
npx @modelcontextprotocol/inspector uv run mcp-server-git

Running tail -n 20 -f ~/Library/Logs/Claude/mcp*.log will show the logs from the server and may help you debug any issues.

Development

If you are doing local development, there are two ways to test your changes:

1. Run the MCP inspector to test your changes. See Debugging for run instructions.
2. Test using the Claude desktop app. Add the following to your claude_desktop_config.json:

Docker

{
  "mcpServers": {
    "git": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--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/git"
      ]
    }
  }
}

UVX

{
  "mcpServers": {
    "git": {
      "command": "uv",
      "args": [
        "--directory",
        "/<path to mcp-servers>/mcp-servers/src/git",
        "run",
        "mcp-server-git"
      ]
    }
  }
}

Build

Docker build:

cd src/git
docker build -t mcp/git .

📄 License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.