WinDbg MCP

Un server MCP (Model Context Protocol) che espone ogni funzione del debugger Windows pybag come strumento MCP nativo. Offre a qualsiasi client compatibile con MCP (Claude Desktop, Claude Code, Cowork, OpenAI Codex CLI, Cursor e agenti personalizzati) il pieno controllo su processi in modalità utente, sessioni kernel e analisi di crash dump — il tutto tramite chiamate di strumenti tipizzate con risposte JSON strutturate.

---

Requisiti

• Solo Windows — pybag richiede Microsoft Debugging Tools for Windows
• Python 3.10+
• Microsoft Debugging Tools for Windows (parte del Windows SDK)

---

Installazione

1. Clona il repository```bat

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

### 2. Installa le dipendenze Python```bat
pip install pybag mcp

3. Installare gli strumenti di debug di Microsoft

Scarica Windows SDK e seleziona Debugging Tools for Windows durante l'installazione: https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/

---

Connessione a IDE e client LLM

Il server viene eseguito come processo stdio locale. Tutti i client di seguito lo avviano allo stesso modo — python <path-to>/windbg_mcp.py — ma ognuno ha il proprio formato di configurazione.

---

Claude Desktop

Modifica il file di configurazione di Claude Desktop e aggiungi la voce windbg-mcp:

Posizione del file di configurazione:

• 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"] } } }

Riavvia Claude Desktop. Tutti i 55 strumenti di debug appariranno automaticamente.

---

### Claude Code (CLI)

Esegui il seguente comando una volta per registrare il server. Claude Code memorizza l'entry
nella propria configurazione MCP e rende gli strumenti disponibili in ogni sessione successiva.```bash
claude mcp add windbg-mcp python C:\path\to\windbg-mcp\windbg_mcp.py

Per verificare che il server sia stato registrato:```bash claude mcp list

Per rimuoverlo in seguito:```bash
claude mcp remove windbg-mcp

---

Claude Cowork

Ci sono due modi per aggiungere WinDbg MCP a Cowork: tramite configurazione JSON (rapida) o installandolo come bundle plugin .mcpb (portatile, condivisibile).

Opzione A — Configurazione JSON

1. Apri l'app desktop di Claude e vai su Impostazioni → MCP Servers.
2. Clicca Aggiungi Server e incolla quanto segue:```json { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } }

3. Salva e riavvia Cowork. Gli strumenti saranno disponibili nella tua prossima sessione.

#### Opzione B — Installazione come bundle di plugin `.mcpb`

Un file `.mcpb` è un archivio zip della directory del plugin che Cowork può installare
direttamente. Questo è l'approccio consigliato quando si condivide il server con un team o
tra macchine diverse.

**Passo 1 — Costruisci il file `.mcpb`**

Dalla radice del repository clonato, esegui:```bat
powershell -Command "Compress-Archive -Path '.\*' -DestinationPath 'windbg-mcp.zip'; Rename-Item 'windbg-mcp.zip' 'windbg-mcp.mcpb'"

Questo crea windbg-mcp.mcpb nella directory corrente, raggruppando windbg_mcp.py, manifest.json e qualsiasi altro file del progetto.

Passaggio 2 — Installazione in Cowork

1. Apri l'app desktop di Claude.
2. Vai su Impostazioni → Plugin (o Estensioni).
3. Clicca Installa Plugin e seleziona windbg-mcp.mcpb.
4. Cowork legge manifest.json dal bundle, registra il server MCP e rende tutti gli strumenti immediatamente disponibili — nessuna configurazione manuale del percorso necessaria.

Il manifest.json incluso in questo repository è già configurato correttamente:```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}` viene risolto al momento dell'installazione nella directory in cui Cowork ha decompresso il bundle, quindi non è necessario codificare alcun percorso.

---

### OpenAI Codex CLI

Aggiungi il server al file di configurazione di Codex CLI. Il file si trova solitamente in `~/.codex/config.json` (Linux/macOS) o `%USERPROFILE%\.codex\config.json` (Windows).```json
{
  "mcpServers": {
    "windbg-mcp": {
      "command": "python",
      "args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
    }
  }
}

Una volta salvato, avvia una nuova sessione di Codex. Gli strumenti WinDbg saranno disponibili per essere chiamati dal modello.

---

Cursor

1. Apri Cursor → Preferenze → Impostazioni di Cursor.
2. Vai alla scheda MCP.
3. Clicca su Aggiungi nuovo server MCP globale e usa questa configurazione:```json { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } }

4. Salva. Cursor si connetterà al server nella sua prossima sessione Composer.

---

### Continue.dev

Aggiungi quanto segue al tuo `~/.continue/config.json` (o al
`.continue/config.json` a livello di workspace):```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "python",
          "args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
        }
      }
    ]
  }
}

Ricarica l'estensione Continue. I 55 strumenti di debug appariranno nell'elenco degli strumenti.

---

Agenti personalizzati e MCP SDK

Se stai creando un tuo agente o pipeline di automazione, connettiti a WinDbg MCP tramite il trasporto stdio MCP standard. Il server parla JSON-RPC 2.0 su stdin/stdout.

Python (usando l'SDK mcp)```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 (utilizzando il pacchetto `@modelcontextprotocol/sdk`)```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);

await client.close();

LangChain / LangGraph```python

from langchain_mcp_adapters.tools import load_mcp_tools 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"], )