# MCP Dev Servers

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/dagonet/mcp-dev-servers)

> **Give Claude Code 87 tools that turn natural-language asks into real `git`, `gh`, `dotnet`, `cargo`, `uv`, and Ollama operations.** Six MCP servers, one `pip install`, opt in per project — so "what changed since main?" becomes a structured diff and "are any NuGet packages vulnerable?" becomes a real audit.

```
You: what changed since main?
Claude calls: git_diff_summary(base="main")
Returns:      { "files_changed": 3, "insertions": 47, "deletions": 12, ... }
Claude:       "You changed 3 files since main: src/auth.py (+40 −5), tests/...
```

✅ **For:** [Claude Code](https://docs.anthropic.com/en/docs/claude-code) users on Windows / macOS / Linux working in git-backed projects (any language; .NET, Rust, and Ollama get bonus tooling).

Built with [FastMCP](https://github.com/jlowin/fastmcp) and the [Model Context Protocol](https://modelcontextprotocol.io/).

## Servers

| Server | Console script | Module | Tools | Description |
|--------|----------------|--------|-------|-------------|
| **git-tools** | `mcp-git-tools` | `mcp_dev_servers.git_mcp` | 34 | Git operations (status, diff, commit, tag, branch, push, fetch, reset, rebase, worktree, etc.) |
| **github-tools** | `mcp-github-tools` | `mcp_dev_servers.github_mcp` | 17 | GitHub utilities not in the official GitHub MCP (releases, workflow dispatch/management, PR labels/auto-merge, branch protection) |
| **dotnet-tools** | `mcp-dotnet-tools` | `mcp_dev_servers.dotnet_mcp` | 19 | .NET build, test, NuGet, EF migrations, code quality, coverage |
| **ollama-tools** | `mcp-ollama-tools` | `mcp_dev_servers.ollama_mcp` | 6 | Local Ollama LLM operations (health, warmup, compression, JSON extraction) |
| **rust-tools** | `mcp-rust-tools` | `mcp_dev_servers.rust_mcp` | 4 | Cargo build, test, clippy with structured diagnostics |
| **python-tools** | `mcp-python-tools` | `mcp_dev_servers.python_tools_mcp` | 7 | Python dev workflows (wheel/sdist inspect, smoke install, pytest, ruff, uv build, coverage) |

## Prerequisites

Each server has its own external dependencies:

| Server | Requires |
|--------|----------|
| **git-tools** | [Git](https://git-scm.com/) installed and in PATH |
| **github-tools** | Git + [GitHub CLI](https://cli.github.com/) (`gh`) installed and authenticated |
| **dotnet-tools** | [.NET SDK](https://dotnet.microsoft.com/) 8.0+ |
| **ollama-tools** | [Ollama](https://ollama.com/) running locally |
| **rust-tools** | [Rust toolchain](https://rustup.rs/) (cargo, rustc) |
| **python-tools** | Python 3.11+, `uv`, `pytest`, `ruff`, `coverage` (in project environment) |

All servers require Python 3.11+.

## Quick Start

Install directly from the GitHub repo (PyPI publishing is planned but not yet done — see [Roadmap](#roadmap)):

```bash
pip install "mcp-dev-servers[ollama] @ git+https://github.com/dagonet/mcp-dev-servers.git"
```

Once this package is on PyPI, the shorter form will also work:

```bash
pip install "mcp-dev-servers[ollama]"   # future — not yet published
```

**Available extras:** `ollama` (pulls `httpx`), `git`, `github`, `dotnet`, `rust`, `python-tools`, `dev` (for running tests). The non-`ollama` extras pull no Python packages today — they exist as documentation for which external tool each server expects (see [Prerequisites](#prerequisites)).

The package installs 6 console scripts (`mcp-git-tools`, `mcp-github-tools`, `mcp-dotnet-tools`, `mcp-ollama-tools`, `mcp-rust-tools`, `mcp-python-tools`). Register them with `claude mcp add`:

```bash
# git-tools (user-level — works in every git repo)
claude mcp add --scope user --transport stdio git-tools -- mcp-git-tools

# github-tools (user-level)
claude mcp add --scope user --transport stdio github-tools \
  -e GH_PROMPT_DISABLED=1 \
  -- mcp-github-tools

# ollama-tools (user-level — if running Ollama)
claude mcp add --scope user --transport stdio ollama-tools \
  -e OLLAMA_URL=http://127.0.0.1:11434 \
  -e OLLAMA_MODEL_FIRST_PASS=mistral:7b-instruct-q4_K_M \
  -e OLLAMA_MODEL_EXTRACT_JSON=qwen2.5:7b-instruct-q4_K_M \
  -- mcp-ollama-tools

# rust-tools (user-level — works in every Rust project)
claude mcp add --scope user --transport stdio rust-tools -- mcp-rust-tools

# dotnet-tools (project-level — only in .NET projects)
claude mcp add --scope project --transport stdio dotnet-tools -- mcp-dotnet-tools


# python-tools (user-level — works in every Python project)
claude mcp add --scope user --transport stdio python-tools -- mcp-python-tools
```

> If `mcp-git-tools` isn't found on your PATH, install with [`pipx`](https://pipx.pypa.io/) so the scripts land in a PATH-resolvable location:
>
> ```bash
> pipx install "mcp-dev-servers[ollama] @ git+https://github.com/dagonet/mcp-dev-servers.git"
> ```
>
> Alternatively, pass the absolute path to each console script in your `claude mcp add` commands.

Then grant tool permissions in your `settings.json` (user or project level):

```json
{
  "permissions": {
    "allow": [
      "mcp__git-tools__*",
      "mcp__github-tools__*",
      "mcp__dotnet-tools__*",
      "mcp__ollama-tools__*",
      "mcp__rust-tools__*",
      "mcp__python-tools__*"
    ]
  }
}
```

## Registration Strategy

| Server | Scope | Rationale |
|--------|-------|-----------|
| git-tools | User | Every git repo benefits from these tools |
| github-tools | User | Every GitHub repo benefits from these tools |
| ollama-tools | User | Cross-project if running Ollama |
| rust-tools | User | Every Rust project benefits from these tools |
| dotnet-tools | Project | Only relevant in .NET projects |
| python-tools | User | Every Python project benefits from these tools |

## Environment Variables

| Variable | Server | Default |
|----------|--------|---------|
| `OLLAMA_URL` | ollama-tools | `http://127.0.0.1:11434` |
| `OLLAMA_MODEL_FIRST_PASS` | ollama-tools | `mistral:7b-instruct-q4_K_M` |
| `OLLAMA_MODEL_EXTRACT_JSON` | ollama-tools | `qwen2.5:7b-instruct-q4_K_M` |
| `GH_EXE` | github-tools | Auto-detected |

## Tool Reference

### git-tools (34 tools)

| Tool | Description |
|------|-------------|
| `git_env_info` | Diagnostic info about git installation |
| `git_status` | Fast porcelain git status |
| `git_add` | Stage specific files |
| `git_rm` | Remove files from tracking |
| `git_commit` | Create a commit |
| `git_diff_summary` | Compact diffstat summary |
| `git_diff` | Full diff output |
| `git_log` | Recent commit history |
| `git_branch_list` | List branches |
| `git_branch_create` | Create a branch without checking it out |
| `git_branch_delete` | Delete a local branch (safe against current branch) |
| `git_checkout` | Checkout branch/tag/commit |
| `git_pull` | Pull from remote |
| `git_push` | Push to remote (branches + optional `--tags`) |
| `git_fetch` | Fetch from remote without merging |
| `git_reset` | Reset HEAD to ref (soft/mixed/hard) |
| `git_stash` | Stash operations (push/pop/list/drop/clear) |
| `git_remote_list` | List configured remotes |
| `git_tag_list` | List tags |
| `git_tag_create` | Create an annotated or lightweight tag |
| `git_tag_delete` | Delete a local tag |
| `git_describe` | Derive a human-readable version string from a commit |
| `git_revert` | Create a revert commit (merge-safe recovery) |
| `git_rebase` | Rebase current branch onto another ref (non-interactive only) |
| `git_archive` | Produce a tarball or zip of a tree at a given ref |
| `git_config_get` | Read a single git config key |
| `git_config_set` | Set a single git config key (allowlisted keys only) |
| `git_restore` | Revert working-tree changes for files |
| `git_clean_dry_run` | List files `git clean -fd` would remove (read-only) |
| `git_reflog` | Read reflog entries for HEAD or a specific ref |
| `git_show` | Show commit details |
| `git_worktree_list` | List worktrees with parsed branch / detached / locked / prunable flags |
| `git_worktree_add` | Add a worktree on a new or existing branch |
| `git_worktree_remove` | Remove a worktree; returns the freed branch name for optional cleanup |

### github-tools (17 tools)

| Tool | Description |
|------|-------------|
| `gh_repo_from_origin` | Get OWNER/REPO from local git remote |
| `gh_workflow_list` | List GitHub Actions workflow runs |
| `github_release_create` | Create a GitHub release (defaults to draft mode) |
| `github_release_edit` | Edit an existing release (use `draft=false` to publish) |
| `github_release_delete` | Delete a release (requires exact `tag_name` match) |
| `github_release_upload_asset` | Upload a single asset to an existing release |
| `github_release_delete_asset` | Remove an asset from a release (requires exact `asset_name` match) |
| `github_workflow_dispatch` | Trigger a `workflow_dispatch`-enabled workflow |
| `github_workflow_run_wait` | Block until a workflow run reaches a terminal state |
| `github_workflow_run_rerun` | Re-run a failed or cancelled workflow run |
| `github_workflow_run_cancel` | Cancel an in-progress workflow run |
| `github_check_runs_for_sha` | List check runs for an arbitrary commit SHA |
| `github_branch_protection_get` | Read branch protection rules for a branch |
| `github_pr_label_add` | Add labels to a pull request |
| `github_pr_label_remove` | Remove labels from a pull request |
| `github_pr_request_review` | Request review from users or teams on a PR |
| `github_pr_auto_merge` | Toggle auto-merge on a pull request |

### dotnet-tools (19 tools)

| Tool | Description |
|------|-------------|
| `build_and_extract_errors` | Build and extract structured errors/warnings |
| `run_tests_summary` | Run tests and parse TRX results |
| `analyze_namespace_conflicts` | Find duplicate type definitions |
| `nuget_list_outdated` | List outdated NuGet packages |
| `nuget_check_vulnerabilities` | Check for NuGet security vulnerabilities |
| `nuget_dependency_tree` | Full NuGet dependency tree |
| `parse_csproj` | Parse .csproj file structure |
| `analyze_project_references` | Analyze inter-project dependencies |
| `check_framework_compatibility` | Check target framework mismatches |
| `ef_migrations_status` | List EF Core migrations status |
| `ef_pending_migrations` | Check for pending EF migrations |
| `ef_dbcontext_info` | Get DbContext provider/connection info |
| `analyze_method_complexity` | Estimate cyclomatic complexity |
| `find_large_files` | Find files exceeding line count threshold |
| `find_god_classes` | Find classes with too many members |
| `parse_stack_trace` | Parse .NET stack traces |
| `parse_coverage_report` | Parse Cobertura coverage XML |
| `run_coverage` | Run tests with coverage collection |
| `map_dotnet_structure` | Map .NET project file structure |

### ollama-tools (6 tools)

| Tool | Description |
|------|-------------|
| `ollama_health` | Check Ollama server status |
| `ollama_list_models` | List available Ollama models |
| `warm_models` | Pre-load models for faster inference |
| `local_first_pass` | Compress text via local LLM |
| `extract_json` | Extract structured JSON from text |
| `map_project_structure` | Map directory structure |

### python-tools (7 tools)

| Tool | Description |
|------|-------------|
| `wheel_inspect` | Read METADATA, version, and entry points from a wheel |
| `sdist_inspect` | Read PKG-INFO and file manifest from a source distribution |
| `python_smoke_install` | Create throwaway venv, install wheel, run commands (cross-platform) |
| `uv_build` | Build Python distributions with uv (clean+build+collect) |
| `pytest_run` | Run pytest with structured output (typed counts + failure details) |
| `ruff` | Run ruff linter (`mode="check"`) or formatter (`mode="format"`) |
| `coverage` | Run tests under coverage and return typed coverage summary |

### rust-tools (4 tools)

| Tool | Description |
|------|-------------|
| `cargo_env_info` | Diagnostic info about Rust/Cargo installation |
| `cargo_build` | Build with structured error/warning diagnostics |
| `cargo_test` | Run tests and return results |
| `cargo_clippy` | Lint with structured clippy diagnostics |


## JSON Configuration

As an alternative to `claude mcp add`, you can configure servers directly in `~/.claude.json` (user-level) or `.claude/mcp.json` (project-level):

```json
{
  "mcpServers": {
    "git-tools": {
      "command": "mcp-git-tools"
    },
    "github-tools": {
      "command": "mcp-github-tools",
      "env": {
        "GH_PROMPT_DISABLED": "1"
      }
    },
    "dotnet-tools": {
      "command": "mcp-dotnet-tools"
    },
    "rust-tools": {
      "command": "mcp-rust-tools"
    },
    "ollama-tools": {
      "command": "mcp-ollama-tools",
      "env": {
        "OLLAMA_URL": "http://127.0.0.1:11434"
      }
    },
    "python-tools": {
      "command": "mcp-python-tools"
    }
  }
}
```

If `mcp-*` scripts aren't on your PATH, use the absolute path to the script (e.g. `"command": "/full/path/to/venv/bin/mcp-git-tools"`) or switch to [`pipx`](https://pipx.pypa.io/) which installs scripts in a PATH-resolvable location.

## Design Decisions

- **stdio transport**: All servers use stdio for Claude Code compatibility
- **Cross-platform**: Windows `CREATE_NO_WINDOW` flag prevents console popups; Unix process group handling for clean timeouts
- **No bash git**: `git_mcp.py` resolves `git.exe` directly to avoid `.cmd` wrapper issues on Windows
- **English locale**: dotnet-tools forces `DOTNET_CLI_UI_LANGUAGE=en` for consistent output parsing
- **Output limits**: Large outputs (diffs, logs) are truncated to prevent context overflow

## Roadmap

- **PyPI publishing.** The package is fully PyPI-ready (pyproject.toml, hatchling build, console scripts, smoke tests) but not yet uploaded. Once published, `pip install "mcp-dev-servers[ollama]"` will work without the git URL.
- **GitHub Actions.** Automated test runs on PRs and Trusted-Publishing-based releases on tag push are planned.

## Development

To contribute or run from source:

```bash
git clone https://github.com/dagonet/mcp-dev-servers.git
cd mcp-dev-servers
python -m venv .venv
.venv/Scripts/activate      # Windows
# source .venv/bin/activate  # Linux/macOS
pip install -e ".[ollama,dev]"
pytest tests/
```

`pip install -e` installs the package in editable mode, so the console scripts (`mcp-git-tools`, etc.) pick up your local edits immediately. `pytest tests/` runs the smoke tests that verify each server imports cleanly and registers the expected number of tools.

## Related Projects

Part of an ecosystem for AI-assisted development with Claude Code:

> **Looking for `template-sync-tools`?** It moved to `claude-code-toolkit` in that
> project's **v4.0.0** and ships from its `server/` directory — the templates, the sync
> skill and the server now version together. It was removed here in **0.4.0**; the last
> release of this package that carries it is **0.3.9**, which is also the rollback target.

- [claude-code-toolkit](https://github.com/dagonet/claude-code-toolkit) -- Template system for bootstrapping projects with Claude Code configuration, MCP server setup, and cross-platform setup scripts
- [open-brain](https://github.com/dagonet/open-brain) -- A personal AI memory system with a CLI, MCP server, and web dashboard; as of v0.3.0 it also compiles topic-level wiki pages with provenance and runs a contradiction-audit pass over your captured notes

Open Brain's MCP server runs alongside the servers here in the same Claude Code session -- its `thoughts_*`, `wiki_*`, and `contradictions_*` tools surface decisions, insights, and topic summaries that complement the `git_*`, `gh_*`, `dotnet_*`, `cargo_*`, `ollama_*`, and `template_*` tools above.