December 7, 2024

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

In this 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. It provides 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 comprehensive 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 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 benefits, the protocol has faced scrutiny over privacy and data security concerns.

The Model Context Protocol (MCP) consists of three core components that work together seamlessly. As described in IKANGAI’s overview, 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 use them to solve user problems. The system operates through a secure protocol layer that handles 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 checkout Setting up Claude with Brave Search and Setting up Claude Filesystem MCP. In this article, I will also cover some of the challenges of using MCP and some common workarounds.

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 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:```bash

Configuration path

~/Library/Application Support/Claude/claude_desktop_config.json

**For Windows:**bash

Configuration path

%APPDATA%\Claude\claude_desktop_config.json



### 2. Configure MCP Git Server

Add the following configuration to your `claude_desktop_config.json`:

```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

1.Server Not Starting- Verify uv installation: uv --version - Check Git installation: git --version - Ensure repository path exists and is accessible 2.Permission Errors- Verify repository permissions - Check that the configured path is correct - Ensure you have read access to the repository 3.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"
      ]
    }
  }
}

Other MCP Git configuration options

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.

Category	Subcategory	Prompt
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?
Code Analysis and Understanding	Author Contributions	Who are the main contributors to the authentication module and what has each person focused on?
Code Analysis and Understanding	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?
Development Insights	Feature Development Tracking	Can you show me how the user authentication feature evolved from its initial implementation to now?
Development Insights	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?
Repository Management	Merge History	Can you show me the merge history of the main branch for the last month and identify any problematic merges?
Repository Management	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?
Documentation and Knowledge Management	Change Documentation	Can you help me understand the context behind the recent changes to the payment processing module?
Documentation and Knowledge Management	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?
Advanced Search and Analysis	Pattern Recognition	Can you identify similar code patterns across different modules in our codebase?
Advanced Search and Analysis	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?
Team Collaboration Insights	Code Review Insights	Can you analyze our merge commit messages to identify common patterns in our code review process?
Team Collaboration Insights	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 fastest?
Project Health Metrics	Refactoring Impact	Can you analyze the impact of our recent refactoring efforts by showing before and after metrics?
Project Health Metrics	Test Coverage Evolution	Can you show how our test coverage has evolved over the past six months?

Practical Tips for Advanced Usage

1.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. 2.Performance Optimization- Limit analysis depth for faster responses - Use specific file paths when analyzing large repositories 3.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:

"Please analyze the commit history in my git-project1 repository"
"Show me recent changes in git-project2"

You can also use descriptive names that make sense for your projects:

{
  "mcpServers": {
    "frontend-repo": { ... },
    "backend-repo": { ... },
    "docs-repo": { ... }
  }
}

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:

```
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log
```

I found tailing the log super helpful.

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:

Git