WinDbg MCP

Un serveur MCP (Model Context Protocol) qui expose chaque fonction de débogueur Windows pybag en tant qu'outil MCP natif. Il donne à tout client compatible MCP (Claude Desktop, Claude Code, Cowork, OpenAI Codex CLI, Cursor et agents personnalisés) un contrôle total sur les processus en mode utilisateur, les sessions noyau et l'analyse des fichiers de vidage sur incident — le tout via des appels d'outils typés avec des réponses JSON structurées.

---

Configuration requise

• Windows uniquement — pybag nécessite Microsoft Debugging Tools for Windows
• Python 3.10+
• Microsoft Debugging Tools for Windows (partie du SDK Windows)

---

Installation

1. Cloner le dépôt```bat

git clone https://github.com/your-username/windbg-mcp.git cd windbg-mcp

### 2. Installer les dépendances Python```bat
pip install pybag mcp

3. Installer les outils de débogage Microsoft

Téléchargez le SDK Windows et sélectionnez Outils de débogage pour Windows lors de l'installation : https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/

---

Connexion aux IDE LLM et aux clients

Le serveur s'exécute en tant que processus stdio local. Tous les clients ci-dessous le lancent de la même manière — python <path-to>/windbg_mcp.py — mais chacun a son propre format de configuration.

---

Claude Desktop

Modifiez le fichier de configuration de Claude Desktop et ajoutez l'entrée windbg-mcp :

Emplacement du fichier de configuration :

• Windows: %APPDATA%\Claude\claude_desktop_config.json
• macOS: `~/Library/Application Support/Claude/claude_desktop_config.json````json { "mcpServers": { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } } }

Redémarrez Claude Desktop. Les 55 outils de débogage apparaîtront automatiquement.

---

### Claude Code (CLI)

Exécutez la commande suivante une fois pour enregistrer le serveur. Claude Code stocke l'entrée dans sa propre configuration MCP et rend les outils disponibles dans chaque session suivante.```bash
claude mcp add windbg-mcp python C:\path\to\windbg-mcp\windbg_mcp.py

Pour vérifier que le serveur a été enregistré :```bash claude mcp list

Pour le supprimer plus tard :```bash
claude mcp remove windbg-mcp

---

Claude Cowork

Il y a deux façons d'ajouter WinDbg MCP à Cowork : via une configuration JSON (rapide) ou en l'installant comme un bundle de plugin .mcpb (portable, partageable).

Option A — Configuration JSON

1. Ouvrez l'application de bureau Claude et allez dans Settings → MCP Servers.
2. Cliquez sur Add Server et collez ce qui suit :```json { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } }

3. Enregistrez et redémarrez Cowork. Les outils seront disponibles dans votre prochaine session.

#### Option B — Installer en tant que bundle de plugin `.mcpb`

Un fichier `.mcpb` est une archive zip du répertoire du plugin que Cowork peut installer directement. Cette approche est recommandée lorsque l'on partage le serveur avec une équipe ou entre machines.

**Étape 1 — Construire le fichier `.mcpb`**

Depuis la racine du dépôt cloné, exécutez :```bat
powershell -Command "Compress-Archive -Path '.\*' -DestinationPath 'windbg-mcp.zip'; Rename-Item 'windbg-mcp.zip' 'windbg-mcp.mcpb'"

Cela crée windbg-mcp.mcpb dans le répertoire courant, regroupant windbg_mcp.py, manifest.json et tous les autres fichiers du projet.

Étape 2 — Installation dans Cowork

1. Ouvrez l'application de bureau Claude.
2. Allez dans Paramètres → Plugins (ou Extensions).
3. Cliquez sur Installer le plugin et sélectionnez windbg-mcp.mcpb.
4. Cowork lit manifest.json du bundle, enregistre le serveur MCP et rend tous les outils immédiatement disponibles — aucune configuration manuelle de chemin requise.

Le manifest.json inclus dans ce dépôt est déjà correctement configuré :```json { "manifest_version": "0.2", "name": "windbg-mcp", "version": "1.0.0", "description": "WinDbg MCP — full Windows debugger control via MCP tools", "server": { "type": "python", "entry_point": "windbg_mcp.py", "mcp_config": { "command": "python", "args": ["${__dirname}/windbg_mcp.py"] } } }

`${__dirname}` est résolu lors de l'installation dans le répertoire où Cowork a décompressé le bundle, vous n'avez donc pas besoin de coder en dur des chemins.

---

### OpenAI Codex CLI

Ajoutez le serveur à votre fichier de configuration Codex CLI. Le fichier se trouve généralement à l'emplacement
`~/.codex/config.json` (Linux/macOS) ou `%USERPROFILE%\.codex\config.json` (Windows).```json
{
  "mcpServers": {
    "windbg-mcp": {
      "command": "python",
      "args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
    }
  }
}

Une fois enregistré, démarrez une nouvelle session Codex. Les outils WinDbg seront disponibles pour que le modèle puisse les appeler.

---

Cursor

1. Ouvrez Cursor → Préférences → Paramètres de Cursor.
2. Accédez à l’onglet MCP.
3. Cliquez sur Ajouter un nouveau serveur MCP global et utilisez cette configuration :```json { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } }

4. Enregistrez. Cursor se connectera au serveur lors de sa prochaine session Composer.

---

### Continue.dev

Ajoutez ce qui suit à votre `~/.continue/config.json` (ou au `.continue/config.json` au niveau de l'espace de travail) :```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "python",
          "args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
        }
      }
    ]
  }
}

Reload the Continue extension. Les 55 outils de débogage apparaîtront dans la liste des outils.

---

Agents personnalisés et le SDK MCP

Si vous construisez votre propre agent ou pipeline d'automatisation, connectez-vous à WinDbg MCP via le transport standard MCP stdio. Le serveur parle JSON-RPC 2.0 via stdin/stdout.

Python (utilisant le mcp SDK)```python

import asyncio from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client

server_params = StdioServerParameters( command="python", args=[r"C:\path\to\windbg-mcp\windbg_mcp.py"], )

async def main(): async with stdio_client(server_params) as (read, write): async with ClientSession(read, write) as session: await session.initialize()

        # List all available tools
        tools = await session.list_tools()
        print([t.name for t in tools.tools])

        # Load a crash dump
        result = await session.call_tool(
            "load_dump",
            arguments={"path": r"C:\crashes\crash.dmp"},
        )
        print(result.content)

        # Read 64 bytes at RSP
        result = await session.call_tool(
            "read_mem",
            arguments={"addr": "0x00000000001FF000", "size": 64},
        )
        print(result.content)

asyncio.run(main())

#### TypeScript / Node.js (utilisant le `@modelcontextprotocol/sdk` package)```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "python",
  args: ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"],
});

const client = new Client({ name: "my-agent", version: "1.0.0" }, {});
await client.connect(transport);

// Call a tool
const result = await client.callTool({
  name: "load_dump",
  arguments: { path: "C:\\crashes\\crash.dmp" },
});
console.log(result.content);