What is the difference between the Git MCP and the GitHub MCP?

Git MCP drives the local `git` binary — status, diff, log, stage, commit. It never talks to a remote. GitHub MCP uses the GitHub REST API for remote-only things: PRs, issues, code search. Pair them when you want the agent to do both: stage a commit locally, then open the PR.

Can it create commits?

Yes. It can stage specific files, run `git commit` with a supplied message, and report back the resulting SHA. It deliberately does not run `git push` — pushing is left to a separate step so the agent cannot mutate remote state by accident.

Does it handle merge conflicts?

It surfaces conflict state via `git_status` and can read the conflicted file contents, but it does not auto-resolve. The agent is expected to read the markers, decide, and run subsequent edits through the Filesystem MCP.

Do I have to pass `--repository` up front?

Yes — the server pins itself to one repo per process. If you work across several repos, declare multiple entries in your MCP config (one per repo) or pass a workspace-root variable that expands at launch.

Why use `uvx` instead of `npx`?

This MCP is written in Python and distributed on PyPI. `uvx` runs it without polluting a global Python install, the same way `npx` does for Node packages. If you do not have `uv` yet: `curl -LsSf https://astral.sh/uv/install.sh | sh`.

Git

Name: Top MCPs — curated MCP directory
Creator: Top MCPs
License: https://creativecommons.org/licenses/by/4.0/

Official

Local Git operations: commit, diff, log, branch, and more.

Score 93(?)Anthropic (modelcontextprotocol)MIT 84kVerified May 31, 2026Top MCPs for Git & Repo Workflows →

Install View on GitHub

Quick answer

What it does

Executes Git operations on local repositories: status, diff, log, commit, branch, checkout, merge, and more.

Best for

Commit message generation
Diff summarization
Branch management
Merge conflict help

Not for

GitHub API operations
Remote repository management

Setup recipe

Pick your client, then follow the three steps.

Install

claude_desktop_config.jsonjson

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

Paste under mcpServers. Fully quit and reopen Claude after editing.

CLI or .mcp.jsonshell

claude mcp add git -- uvx mcp-server-git --repository /path/to/repo

Run from your repo. Commit .mcp.json to share with your team.

.cursor/mcp.jsonjson

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

Global path: ~/.cursor/mcp.json. Reload window after editing.

.vscode/mcp.jsonjsonc

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

VS Code uses the "servers" key (not "mcpServers").

~/.codeium/windsurf/mcp_config.jsonjson

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

Open via Cascade → hammer icon → Configure.

cline_mcp_settings.jsonjson

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

Open via the Cline sidebar → MCP Servers → Edit.

~/.continue/config.jsonjson

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "mcp-server-git",
            "--repository",
            "/path/to/repo"
          ]
        }
      }
    ]
  }
}

Continue uses modelContextProtocolServers with a transport block.

~/.codex/config.tomlshell

# ~/.codex/config.toml
[mcp_servers.git]
command = "uvx"
args = [
  "mcp-server-git",
  "--repository",
  "/path/to/repo",
]

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

~/.config/zed/settings.jsonjsonc

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

Zed calls them "context_servers". Settings live-reload on save.

ChatGPT → Apps directorynone

Git doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

2
Set required secrets
No credentials required — this MCP runs over stdio without authentication.
3
Try a minimum working prompt
Review, stage, and commit changes in a repo
In the repo at ~/code/project-a, show me git status and a diff of unstaged changes. If everything looks safe, stage them and create a single conventional-commit commit like `feat: …` summarising the change in under 72 characters.
Tested with: Claude Desktop, Cursor.

Tools & permissions

Tool	Description	Args	Side effects
`git_status`	Show the working tree status.	repo_path: string	Read
`git_diff_unstaged`	Diff unstaged changes.	repo_path: string	Read
`git_diff_staged`	Diff staged changes.	repo_path: string	Read
`git_add`	Stage files.	repo_path: string, files: string[]	Write
`git_commit`	Create a commit with the staged changes.	repo_path: string, message: string	Write
`git_reset`	Unstage files.	repo_path: string	Write
`git_log`	Show commit history.	repo_path: string, max_count?: number	Read
`git_create_branch`	Create a new branch.	repo_path: string, branch_name: string	Write
`git_checkout`	Switch branches.	repo_path: string, branch_name: string	Write
`git_show`	Show details of a commit.	repo_path: string, revision: string	Read

Security & scope

Access scope: Read + write
Sandbox: Runs local `git` CLI commands scoped to the repository path passed at launch. No implicit network access unless the agent invokes a push or fetch tool.
Gotchas: `git push` uses whatever credentials are configured in the local git config — if a credential helper is unlocked, the agent has push access.
No signing by default; commits authored by the agent carry the local user config.

Agent prompt pack

— copy into Claude, Cursor, or ChatGPT.

Paste into Claude, Cursor, or ChatGPT. Edit the [brackets] before sending.

Recommend the best MCP servers for [task: e.g. git & repo workflows work] in [client: Claude].

Constraints:
- Prefer tools that are [official | open-source | read-only] — pick what matters for my use case.
- Exclude MCPs that require [e.g. a paid plan, OAuth-only flows, remote-only transport].
- Return at most 3 picks, ranked.

For each pick include:
1. One-sentence rationale.
2. The ready-to-paste install snippet for my client.
3. Any required secrets I need to create before installing.

Cross-check the top-mcps.com listing: https://top-mcps.com/top-mcps-for-git-repo-workflows

Compare Git against a real alternative. Swap the second MCP in [brackets] if you want a different match.

Compare Git MCP vs [GitHub MCP] for the following job: [describe the job, e.g. "let an agent create GitHub issues on bug triage"].

Judge them on:
- Setup time and complexity (what a new user hits first).
- Auth model (none / API key / OAuth 2.1) and credential risk.
- Transport (stdio / Streamable HTTP / SSE) and where the server runs.
- Required secrets and the blast radius if they leak.
- Operational risk in an unattended agent loop.
- Which one is "good enough" for a weekend prototype vs. production.

End with one sentence: which should I pick for my scenario, which is: [my scenario].

References:
- https://top-mcps.com/mcp/git
- top-mcps.com listing for GitHub

Asks the agent to install and verify. Works inside Claude Code, Cursor Agent, Codex CLI.

Install the Git MCP server for my [client: Claude] at the default config path for that client.

Use the exact install snippet published at https://top-mcps.com/mcp/git (fetch https://top-mcps.com/mcp/git.json for the canonical server.json if you can read URLs).

Before finishing:
1. Create the required secrets (no secrets) and put them in the appropriate env block — do not hard-code them.
2. Restart or reload the client so it picks up the new server.
3. Verify the server is connected (green / running state) and at least one tool is listed.
4. If anything fails, read the client's MCP logs and report the exact error — do not silently retry.

Confirm when done and list the tools the server now exposes.

Frequently asked questions

What changed

— 2 updates tracked.

May 31, 2026
Refreshed install snippets and fact sheet; verified for 2026.
Nov 25, 2024
Initial directory listing.

More Git & Repo Workflows MCPs

Other tools in the same category worth evaluating.

GitHub

Official

Full GitHub API access: repos, PRs, issues, and code search.

gitgithubreposprs

5 minLow

GitLab

Full GitLab API access: repos, MRs, issues, pipelines, and registries.

gitgitlabreposmrs

5 minLow

Linear

Manage Linear issues, projects, and cycles from AI context.

linearproject-managementissuesproductivity

5 minMedium

Compared with Git

Side-by-side breakdowns for the choices people most often weigh against this MCP.

GitvsGitHub GitvsFilesystem GitvsGitLab GitvsSourcegraph

Exploring Top MCPs for Git & Repo Workflows? See all Git & Repo Workflows MCPs →