Anthropic’s MCP: Set up Git MCP Agentic Tooling with Claude Desktop

In this quick guide, I'll walk you through setting up and using Model Context Protocol (MCP) Git integration with Claude Desktop. This powerful tooling enables Claude to analyze and interact with your Git repositories directly, providing advanced code analysis and version control capabilities. We'll cover everything from basic setup to advanced use cases, troubleshooting, and best practices. Let's start by understanding what MCP is and why it's important.

Here's what we'll cover in this quick guide:

Background and Introduction What is Model Context Protocol (MCP) Core components and architecture Roles of host and client applications
Setup and Installation Prerequisites and system requirements Installing uvx and dependencies Configuration file setup Git MCP server installation
Features and Capabilities Available Git operations Security considerations Advanced configuration options
Use Cases and Applications Code analysis and understanding Development insights Repository management Documentation and knowledge management Advanced search and analysis Team collaboration insights Project health metrics
Advanced Topics Working with multiple repositories Performance optimization Best practices
Troubleshooting and Debugging Common issues and solutions Debug steps and procedures Configuration validation

Background Information on MCP - Anthropic’s Agentic Tooling

Anthropic recently introduced the Model Context Protocol (MCP), an open-source standard that aims to revolutionize how AI assistants interact with data sources. This innovative protocol provides a unified framework, replacing previously fragmented systems. With Anthropic’s MCP, developers can efficiently expose data through servers or create AI applications that connect to these servers, significantly enhancing AI models’ ability to generate contextually relevant responses. While offering substantial benefits, the protocol has encountered scrutiny over privacy and data security concerns.

The Model Context Protocol (MCP) consists of three core components that work together seamlessly. As IKANGAI's overview describes, servers function as data gateways, exposing resources, tools, and prompts from various sources like databases and code repositories. Clients, typically AI-powered tools, communicate with these servers to access the exposed data and functionalities. According to the MCP Quickstart guide, hosts are applications that initiate server connections, discover their capabilities, and strategically utilize them to solve user problems. The system operates through a secure protocol layer that facilitates message exchanges using JSON-RPC 2.0, as detailed in Anthropic's introduction to MCP.

In the Model Context Protocol (MCP), the host and client serve distinct roles. According to the MCP Quickstart guide, the host application (like Claude Desktop) initiates connections to servers and discovers their capabilities to address user needs. The client operates within the host application, managing server connections and ensuring seamless access to data and functionalities (Metadocs' overview,). Put simply, while the host orchestrates the interactions, the client handles the technical execution.

This is the 3rd article in this series. Be sure to check out Setting up Claude with Brave Search and Setting up Claude Filesystem MCP. In this guide, I will also cover some of the challenges of using MCP and some common workarounds.

Check out this article on my site for better formatting.

Setting Up MCP Agentic Tooling - Git Integration

Now that we have some background on MCP is and how it works, let's walk through the process of setting up Git integration with Claude Desktop. This setup will allow Claude to analyze and interact with your Git repositories directly, providing powerful code analysis and version control capabilities. We'll cover everything from basic requirements to advanced configurations.

Prerequisites

Claude Desktop installed
Git installed (git --version to verify)
Python's uv package manager installed (recommended over pip)
Terminal/Command Prompt access

Installing uvx

% brew search uvx
% brew install uv
% uvx --version 

uv-tool-uvx 0.5.5 (Homebrew 2024-11-27)

To install and use uvx, you first need to install the uv package manager. The steps are:

Install uv using Homebrew (on macOS) or your system's package manager
Verify uv installation with uv --version
Verify uvx installation with uvx --version

Note that uvx is a tool built on top of uv, so having uv properly installed first is essential. The uv package manager is recommended over pip for its improved performance and dependency resolution.

If you encounter any issues during installation, make sure:

Your system's package manager is up to date
You have the necessary permissions to install packages
Python is properly installed on your system

💡 What is uv?

uv is a modern Python package and project management tool, written in Rust, designed to streamline Python development. It serves as a fast and unified alternative to various existing Python tools such as pip, pipx, pyenv, poetry, and others. One of its key features is uvx, which functions similarly to pipx.

What is uvx? uvx is a command provided by uv for running Python tools or scripts without requiring explicit installation. It creates temporary, isolated virtual environments for the execution of these tools, ensuring minimal setup and cleanup after execution. This makes it particularly useful for one-off tool usage.

Why use uv and uvx? The broader appeal of uv lies in its ability to unify multiple aspects of Python development: • Dependency Management: Handles dependencies efficiently using a fast resolver • Python Installation: Automatically installs required Python versions • Virtual Environments: Simplifies creation and management of virtual environments • Tool Management: Provides a centralized way to manage command-line tools via uv tool install or ephemeral execution via uvx

In summary, uvx is an efficient, user-friendly alternative to tools like pipx, offering speed, flexibility, and seamless integration with the broader capabilities of the uv ecosystem. We use in this article because the Anthropic’s tools are built with it.

Installation Steps

1. Create/Edit Configuration File

First, we need to locate or create the Claude Desktop configuration file:

For macOS:

# Configuration path
~/Library/Application Support/Claude/claude_desktop_config.json

For Windows:

# Configuration path
%APPDATA%\\Claude\\claude_desktop_config.json

2. Configure MCP Git Server

Add the following configuration to your claude_desktop_config.json:

{
  "mcpServers": {
    "git": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository",
        "/path/to/your/git/repo"
      ]
    }
  }
}

Replace /path/to/your/git/repo with the actual path to the Git repository you want to analyze.

3. Install the Git MCP Server

Open your terminal and run:

# Using uv (recommended)
uv tool install mcp-server-git
uv tool update-shell

4. Verify Installation

Close and restart Claude Desktop
Test the connection with a simple query:

Could you show me the recent commits in my repository?

Features Available

The Git MCP server provides several capabilities:

View commit history
Analyze code changes
Search through repository content
Read file contents from specific commits
Compare different versions of files
View branch information

Troubleshooting

Common Issues and Solutions

Server Not Starting Verify uv installation: uv --version Check Git installation: git --version Ensure the repository path exists and is accessible
Permission Errors Verify repository permissions Check that the configured path is correct Ensure you have read access to the repository
Configuration Not Loading Verify JSON syntax in configuration file Confirm configuration file location Restart Claude Desktop after changes

Debug Steps

Check if Git is properly installed:

git --version

Verify repository access:

cd /path/to/your/git/repo
git status

Test MCP server directly:

uvx mcp-server-git --repository /path/to/your/git/repo

Additional Configuration Options

For more advanced setups, you can add additional parameters to the configuration:

{
  "mcpServers": {
    "git": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository", "/path/to/your/git/repo",
        "--branch", "main",
        "--depth", "100"
      ]
    }
  }
}

Use Cases

I'll walk through some powerful capabilities of the Git MCP integration with practical examples. Later we will cover some actual sessions and I can tell you where there are some pitfalls.

Code Analysis and Understanding

Code History Analysis

Can you analyze the evolution of the src/main.py file over the last 5 commits and explain what major changes were made?

Author Contributions

Who are the main contributors to the authentication module and what has each person focused on?

Impact Analysis

What files were most frequently changed in the last month? Can you identify potential hotspots in the codebase?

Development Insights

Bug Pattern Detection

Can you look through the commit history and identify patterns in bug fixes, particularly in the API endpoints?

Feature Development Tracking

Can you show me how the user authentication feature evolved from its initial implementation to now?

Code Quality Analysis

Looking at the commit history, can you identify areas where we've accumulated technical debt?

Repository Management

Branch Analysis

Can you analyze the current active branches and summarize what features are being worked on?

Merge History

Can you show me the merge history of the main branch for the last month and identify any problematic merges?

Release Analysis

Can you analyze our tagged releases and summarize the major changes between versions?

Documentation and Knowledge Management

Documentation Updates

Can you show me how our API documentation has evolved over time?

Change Documentation

Can you help me understand the context behind the recent changes to the payment processing module?

Best Practices Analysis

Can you analyze our commit messages and suggest improvements for our documentation practices?

Advanced Search and Analysis

Complex Code Search

Can you find all instances where we've modified our database schema across all branches?

Pattern Recognition

Can you identify similar code patterns across different modules in our codebase?

Security Analysis

Can you look through our commit history and identify any accidentally committed sensitive data?

Team Collaboration Insights

Work Patterns

Can you analyze commit patterns to show when our team is most active and productive?

Code Review Insights

Can you analyze our merge commit messages to identify common patterns in our code review process?

Knowledge Distribution

Can you show which team members have expertise in different parts of the codebase based on commit history?

Project Health Metrics

Codebase Growth

Can you show me how our codebase size has evolved over time and in which areas we're growing the fastest?

Refactoring Impact

Can you analyze the impact of our recent refactoring efforts by showing before and after metrics?

Test Coverage Evolution

Can you show how our test coverage has evolved over the past six months?

Practical Tips for Advanced Usage

Combining with Other MCP Servers Use with the Filesystem MCP to analyze both code and related files Combine with GitHub MCP for comprehensive repository analysis, there are currently some pitfalls with this.
Performance Optimization Limit analysis depth for faster responses Use specific file paths when analyzing large repositories
Best Practices Regular repository cleanup for better performance Structured commit messages for better analysis Tag important milestones for easier historical analysis

Working with multiple git repos

Let me explain how MCP handles multiple Git repositories through configuration.

When setting up multiple Git repositories, you need to give each repository a unique identifier in your configuration. Here's how it works:

{
  "mcpServers": {
    "git-project1": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository", "/path/to/first/repo"
      ]
    },
    "git-project2": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository", "/path/to/second/repo"
      ]
    },
    "git-project3": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository", "/path/to/third/repo"
      ]
    }
  }
}

Key Points:

The identifiers (e.g., "git-project1", "git-project2") serve as unique names for each repository
When interacting with Claude Desktop, you can specify which repository you want to work with:
You can also use descriptive names that make sense for your projects:

Example Working Configuration:

{
  "mcpServers": {
    "main-app": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository", "/Users/me/projects/main-application",
        "--branch", "main"
      ]
    },
    "api-service": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository", "/Users/me/projects/api-service",
        "--branch", "develop"
      ]
    },
    "documentation": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository", "/Users/me/projects/docs",
        "--branch", "main"
      ]
    }
  }
}

Then in your interactions with Claude Desktop, you can be specific:

"Show me the recent commits in the api-service repository"
"What changes were made to the documentation repository last week?"
"Compare the test coverage between main-app and api-service"

This can get confusing if you have too many MCP server tools installed at once. I had a really hard time getting Claude to select the correct Git repo, as it would get confused between the GitHub tool, the filesystem tools, and the Git tools. You have to be fairly specific in your prompts to get it to work when multiple tools are installed. I assume this will get better over time, or I will get better at it. But it is not all roses and rainbows.

Debugging

When debugging issues with Claude MCP (Model Context Protocol) servers, particularly when they fail to use installed MCP servers, follow these systematic troubleshooting steps:

1. Verify Configuration

Configuration File: Check your claude_desktop_config.json file configuration. As detailed in the MCP-Windows guide, this file should contain correct paths to MCP server executables and environment variables, using double backslashes on Windows systems.
Server Command: According to the Windows setup guide, ensure proper server startup commands, especially for Node.js-based servers by specifying the full path to node.exe and the server's dist/index.js file.

2. Check Server Logs

Enable Logging: As recommended in the official debugging documentation, implement structured logging to track server operations, connection attempts, and errors.
View Logs: Monitor real-time logs on macOS using:

3. Use Debugging Tools

MCP Inspector: As described in developer first impressions, use the MCP Inspector for interactive debugging and resource inspection.
Claude Desktop Developer Tools: Enable Chrome DevTools through developer_settings.json to examine client-side errors and network activity.

4. Common Issues and Solutions

Connection Errors: For "Could not connect to MCP server" errors, verify system paths and ensure global package installation via npm install -g.
Windows-Specific Issues: Run Claude Desktop as administrator, enable developer mode, and verify Node.js and Python PATH variables.
NPM/NVM Issues: As documented in the GitHub issue tracker, consider using direct node commands instead of npx on Windows systems.

5. Restart and Test

After configuration changes, restart Claude Desktop. For quick server code reloading on macOS, use Command-R as noted in the MCP troubleshooting guide.

If you continue experiencing issues after following these steps, reach out through official support channels or community forums for additional assistance.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "--allow-write",
        "/Users/richardhightower/src",
        "/Users/richardhightower/clients"
      ]
    },
    "brave-search": {
      "command": "npx",
      "args": [
          "-y",
          "@modelcontextprotocol/server-brave-search"
      ],
      "env": {
          "BRAVE_API_KEY": "MY_ACTUAL_KEY"
      }
    },
    "git-markdown": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository",
        "/Users/richardhightower/src/project-markdown-creator"
      ]
    },
    "git-meeting-buddy": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository",
        "/Users/richardhightower/src/meeting_buddy/pythonProject"
      ]
    }
  }
}

Claude Desktop

Once you install and restart the Claude Desktop, you should see the following tools: