# STM32 GDB Debugger (pypi · stm32-gdb-mcp)

Debug STM32 firmware on real hardware via GDB + OpenOCD/ST-Link/J-Link with decoded results.

- Trust score: 65/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-22

## Components

- pypi · `stm32-gdb-mcp`: 65/100 (this document), [markdown](https://verifymcp.io/servers/zeraissh-stm32-gdb-mcp/stm32-gdb-mcp.md), [page](https://verifymcp.io/servers/zeraissh-stm32-gdb-mcp/stm32-gdb-mcp)

## Channel facts

- Registry: `pypi`
- Package: `stm32-gdb-mcp`
- Version: `0.15.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-22.

- **Supply Chain Security**: 49/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 2 of 31 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Zeraissh/stm32-gdb-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 4 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 64/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 7563 tokens (~199/item across 38 items; 38 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 10/100
  - Stability observed for 3 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 98/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 94% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 38 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 39 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the STM32 GDB Debugger MCP server?

STM32 GDB Debugger runs locally as a PyPI package, launched with uvx stm32-gdb-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add zeraissh-stm32-gdb-mcp -- uvx stm32-gdb-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "zeraissh-stm32-gdb-mcp": {
      "command": "uvx",
      "args": [
        "stm32-gdb-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "zeraissh-stm32-gdb-mcp": {
      "command": "uvx",
      "args": [
        "stm32-gdb-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add zeraissh-stm32-gdb-mcp -- uvx stm32-gdb-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "zeraissh-stm32-gdb-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "stm32-gdb-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add zeraissh-stm32-gdb-mcp --command uvx --arg stm32-gdb-mcp
```

### Hermes

```yaml
mcp_servers:
  zeraissh-stm32-gdb-mcp:
    command: "uvx"
    args: ["stm32-gdb-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "zeraissh-stm32-gdb-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "stm32-gdb-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add zeraissh-stm32-gdb-mcp -t stdio -c uvx -a stm32-gdb-mcp
```

### Other

```json
{
  "mcpServers": {
    "zeraissh-stm32-gdb-mcp": {
      "command": "uvx",
      "args": [
        "stm32-gdb-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-21 (score 65, −14)

- [security regression] Malware scan: pass → unverified

### 2026-10-19 (score 79)

First indexed and scored.

## MCP tools (38)

### `start_debug_session` (~390 tokens)

Starts the specified GDB Server (openocd, stlink, jlink) and connects the GDB Client to it. openocd REQUIRES server_args naming the probe and target, e.g. ['-f','interface/stlink.cfg','-f','target/stm32l4x.cfg'] — without them OpenOCD cannot find a config or adapter. Omitted values come from the active debug profile.

Input parameters:

- `hub_channel` (integer): Take the probe on this hub channel, using the usb_location recorded for it in the profile's hub.map. Falls back to hub.channel, then to the map entry whose label matches this session's name.
- `probe` (string): Optional OpenOCD probe type: stlink, jlink, or cmsis-dap. Falls back to the profile, then a unique detected probe.
- `serial` (string): Probe/ST-Link serial to select a specific board (for concurrent multi-target). Auto-added as 'adapter serial <serial>'.
- `server_args` (array): Optional args for the server e.g. ['-f', 'interface/stlink.cfg', '-f', 'target/stm32f4x.cfg']
- `server_type` (string): Type of debug server backend.
- `session` (string): Optional debug-session name. Omit for the default target.
- `speed_khz` (integer): OpenOCD adapter clock used when server_args are inferred (default 4000).
- `usb_location` (string): Select the probe by physical USB position, e.g. '1-1.4'. This is how to pick one of several probes that report NO serial number (most clone ST-Links), and unlike hub isolation it disconnects nobody -…

### `stop_debug_session` (~47 tokens)

Stops the GDB client/server, variable tracking, and all active RTT/SWO/UART readers.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `self_check` (~151 tokens)

Validates the link right after connecting: reads CPUID and DBGMCU IDCODE and checks byte order, that a real Cortex-M is present, and that the device matches the expected family (from the profile MCU or the 'expected_family' arg). Run this first to catch endianness/config faults before debugging. Halts the core first (identity reads are unreliable while running); pass halt=false to skip.

Input parameters:

- `expected_family` (string): Expected MCU/family, e.g. 'STM32L431'. Defaults to the profile MCU.
- `halt` (boolean): Halt the core before reading (default true).
- `session` (string): Optional debug-session name. Omit for the default target.

### `detect_probe` (~58 tokens)

Lists physical ST-Link, J-Link, and CMSIS-DAP probes currently connected over USB. Preserves serial numbers so multiple identical probes are never silently collapsed.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `suggest_server_args` (~192 tokens)

Returns the correct OpenOCD server_args for an MCU family + probe (e.g. STM32L431 + stlink -> ['-f','interface/stlink.cfg','-f','target/stm32l4x.cfg']) and validates the config files exist in OpenOCD's bundled scripts dir. Call this to get start_debug_session args — do NOT search the disk for .cfg files.

Input parameters:

- `mcu` (string, required): MCU or family, e.g. 'STM32L431' or 'STM32F4'.
- `probe` (string): Optional. Debug probe: stlink, jlink, or cmsis-dap. If omitted, uses debug profile probe.
- `session` (string): Optional debug-session name. Omit for the default target.
- `speed_khz` (integer): Adapter clock in kHz (default 4000; 0 keeps the config default).

### `batch` (~140 tokens)

Runs several tool calls in ONE round trip and returns ALL their full results — the fastest way to do a sequence of operations (e.g. read registers + backtrace + several variables) without per-call latency. ok is false if ANY step failed; data.succeeded/data.failed count the outcomes (count/total only count steps run vs requested). Pass session to run every step against a named debug session.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.
- `steps` (array, required): Ordered tool calls, each {tool, args}.
- `stop_on_error` (boolean): Stop at the first failing step (default false).

### `call` (~114 tokens)

Invoke ANY stm32-gdb-mcp tool by name — including one that is NOT in your current tool list (clients with tool-count limits may hide some). Use this to reach e.g. start_debug_session when it isn't directly listed: call(tool='start_debug_session', args={...}). Returns that tool's result.

Input parameters:

- `args` (object): Arguments for that tool.
- `session` (string): Optional debug-session name. Omit for the default target.
- `tool` (string, required): Name of the tool to invoke.

### `call_read` (~167 tokens)

Like call, but restricted to tools that only READ state — so it needs no approval prompt where call, which can reach anything, does. Prefer it for hidden read-only tools: call_read(tool='read_core_registers', args={}). The gate is per-ACTION, not per-tool: a family's reading action goes through even though the family also writes, so call_read(tool='debug_profile', args={'action':'get'}) works while action='set' does not. A refusal names the actions it would accept. Refuses anything that writes; use call for those.

Input parameters:

- `args` (object): Arguments for that tool.
- `session` (string): Optional debug-session name. Omit for the default target.
- `tool` (string, required): Name of the read-only tool to invoke.

### `tool_help` (~68 tokens)

Returns descriptions and complete schemas for full-surface tools, including tools hidden in compact mode.

Input parameters:

- `name` (string): Exact tool name.
- `query` (string): Case-insensitive name/description search.
- `session` (string): Optional debug-session name. Omit for the default target.

### `mcp_info` (~121 tokens)

Identifies THIS running stm32-gdb-mcp server: release version, git commit, the package directory the code was imported from (plus the install root the git probe used), whether compact mode is hiding tools, and how many tools this build advertises versus how many exist. Needs NO debug session, NO probe and NO target — call it the moment a tool you expect is missing or behaves like an older build, instead of guessing which checkout the client actually launched.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `recover_session` (~187 tokens)

Recovers a dropped or wedged session: cleanly tears down the GDB client and server, then restarts the server (with retry/backoff for a busy probe) using the last start_debug_session arguments and reconnects. Use after a probe_unavailable or connection_lost error. When a programmable USB hub is configured (debug_profile hub.channel), a retry that cannot fix the probe escalates to toggling its USB data lines and then power-cycling the port -- the only in-band cure for a wedged endpoint. Any hub action taken is reported in recovery_steps.

Input parameters:

- `deep` (boolean): Add a long (2 s) power-off rung to drain bulk capacitance.
- `escalate` (boolean): Allow hub data-line/power escalation when a plain retry fails (default true).
- `session` (string): Optional debug-session name. Omit for the default target.

### `build_firmware` (~273 tokens)

Builds firmware with Keil uVision (UV4), CMake, make, or a custom command, so the AI can rebuild after a fix. Keil emits a .axf (ELF/DWARF) that the debug tools load like any .elf. Returns the exit code, success flag, and build log tail.

Input parameters:

- `build_dir` (string): cmake: the configured build directory.
- `command` (array): custom: full argv to run.
- `config` (string): cmake: build config, e.g. Debug/Release.
- `cwd` (string): Working directory for the build.
- `directory` (string): make: directory containing the Makefile.
- `kind` (string, required): Toolchain to build with.
- `project` (string): keil: path to the .uvprojx/.uvproj project.
- `rebuild` (boolean): keil: rebuild all (-r) instead of incremental (-b).
- `session` (string): Optional debug-session name. Omit for the default target.
- `target` (string): Keil/CMake/make build target.
- `timeout_sec` (number): Max build seconds (default 600).
- `uv4_path` (string): keil: path to UV4.exe (auto-detected if omitted).

### `load_symbols` (~108 tokens)

Loads symbols from an ELF/AXF into the current GDB session WITHOUT flashing. Symbols are per-session, so after a fresh connect or recover_session you need this (or flash_firmware) before symbol breakpoints resolve. Falls back to the debug profile's elf_path if elf_path is omitted.

Input parameters:

- `elf_path` (string): Path to the ELF/AXF. Defaults to the profile elf_path.
- `session` (string): Optional debug-session name. Omit for the default target.

### `flash_firmware` (~178 tokens)

Flashes a compiled firmware binary to the target. Accepts GCC .elf or Keil .axf. By default it then resets and RUNS the firmware (Keil-style 'Load + Run'). Pass reset_run=false to flash only (e.g. to set breakpoints before the firmware starts). Refuses (elf_layout_unsupported) an image GDB would flash incompletely, such as a Keil ARMCC5 AXF whose RW initializer lies outside its segment; flash its fromelf BIN instead.

Input parameters:

- `file_path` (string, required): Absolute path to the compiled firmware file (e.g. .elf/.axf).
- `reset_run` (boolean): Reset and run after flashing (default true). False = flash only, leave halted.
- `session` (string): Optional debug-session name. Omit for the default target.

### `reset_target` (~288 tokens)

Resets the target device. Can optionally halt immediately after reset. strategy="cold" removes target power through a configured programmable USB hub before resetting, which is the only strategy that produces a true power-on reset (RCC_CSR POR flag, cleared .noinit, drained RAM); it fails rather than silently doing a warm reset when no hub channel is mapped. It needs no confirm argument -- asking for a cold reset by name IS the confirmation the hub guard wants -- and it stops the GDB session before the cut, then re-establishes it.

Input parameters:

- `command` (string): Optional custom GDB monitor reset command.
- `halt` (boolean, required): If true, halts the CPU immediately after reset.
- `session` (string): Optional debug-session name. Omit for the default target.
- `strategy` (string): Optional reset strategy: default, under_reset, software, or cold (hub power cycle). "software" issues soft_reset_halt, which resets through the debug unit WITHOUT asserting SYSRESETREQ -- so RCC_CSR…

### `continue_execution` (~68 tokens)

Resumes execution of the target device until the next breakpoint. Safe to call when the target is already running (reports already_running instead of erroring), so 'make sure it is running' is expressible.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `halt_execution` (~35 tokens)

Interrupts/halts the target device execution.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `run_and_wait` (~88 tokens)

Resumes the target and waits, returning a structured stop event (reason, symbolized frame, breakpoint id, signal) or a timeout. Use this instead of continue_execution + polling to close the debug loop.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.
- `timeout_sec` (number): Max seconds to wait for a stop (default 10).

### `debug_until` (~172 tokens)

One-call repro step: set an optional conditional/temporary breakpoint at a location, run, and return the stop event PLUS the decoded backtrace and innermost-frame locals. Collapses set_breakpoint + run + read frame/vars into a single round-trip.

Input parameters:

- `condition` (string): Optional C condition, e.g. 'g_divisor == 0'.
- `ignore_count` (integer): Hits to ignore before stopping.
- `location` (string, required): Where to break, e.g. 'trigger_divzero' or 'main.c:21'.
- `session` (string): Optional debug-session name. Omit for the default target.
- `temporary` (boolean): Auto-delete the breakpoint after the first hit (default true).
- `timeout_sec` (number): Max seconds to wait (default 10).

### `capture_state` (~66 tokens)

One-call 'where am I': decoded core registers + a PC/LR/SP summary, the decoded backtrace, and the innermost-frame locals. The fastest way to get full halted context.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `flash_and_run` (~267 tokens)

One-call bring-up: flash an ELF (loads symbols), reset-halt, set a temporary breakpoint at an entry point (default 'main'), run to it, and return the decoded stop context. With hub_channel (or usb_location) and no session running, it starts one pinned to that probe first -- so 'flash the firmware on channel 4' is this single call, on a bench with several probes, without disconnecting any of the others.

Input parameters:

- `file_path` (string, required): Path to the ELF to flash.
- `hub_channel` (integer): Start a session on the probe at this hub channel first, if none is running. Uses the usb_location recorded for it in the profile's hub.map. Ignored when a session is already live -- it flashes throug…
- `mcu` (string): Passed through when this call starts the session; falls back to the profile.
- `run_to` (string): Entry point to stop at (default 'main').
- `session` (string): Optional debug-session name. Omit for the default target.
- `timeout_sec` (number): Max seconds to wait (default 10).
- `usb_location` (string): Same, but naming the USB position directly, e.g. '1-1.4'.

### `run_for_duration` (~147 tokens)

Runs the target freely for a wall-clock duration, halts it, and returns one structured report with final frame/context and optional expression captures. Useful for counters, telemetry buffers, polling loops, and timing-sensitive bus diagnostics without breakpoint perturbation.

Input parameters:

- `capture` (object)
- `duration_sec` (number, required): Seconds to let the target run freely.
- `resume_after` (boolean): Resume execution after capture (default false).
- `sample` (object): Best-effort low-rate debugger polling while running; does not halt the target.
- `session` (string): Optional debug-session name. Omit for the default target.
- `then` (string): Action after duration (default halt).

### `read_variable` (~50 tokens)

Reads the value of a C variable currently in scope.

Input parameters:

- `name` (string, required): Name of the variable to read.
- `session` (string): Optional debug-session name. Omit for the default target.

### `read_memory` (~135 tokens)

Reads a block of memory from the target. Returns the raw bytes in memory order, plus value_le -- the same bytes as one little-endian value -- for a 1/2/4/8-byte read. Use value_le for a peripheral register: the raw string arrives least-significant-byte first, so reversing it by hand is where bit positions get misread.

Input parameters:

- `address` (string, required): Hex address to read from, e.g., '0x20000000'.
- `length` (integer, required): Number of bytes to read.
- `session` (string): Optional debug-session name. Omit for the default target.

### `write_memory` (~80 tokens)

Writes a value to a specific memory address.

Input parameters:

- `address` (string, required): Hex address to write to, e.g., '0x20000000'.
- `session` (string): Optional debug-session name. Omit for the default target.
- `value` (string, required): Value to write, e.g., '0xFF' or '1234'.

### `read_call_stack` (~84 tokens)

Reads the call stack as a decoded list of frames {level, func, file, line, addr} plus a one-line summary. Set include_raw=true to also get the raw GDB output.

Input parameters:

- `include_raw` (boolean): Include the raw GDB transcript (default false).
- `session` (string): Optional debug-session name. Omit for the default target.

### `analyze_stack` (~171 tokens)

Reports stack used/free bytes and a clear overflow verdict for the halted core. stack_top defaults to the initial MSP (first word of the vector table at vector_table_addr). Give stack_size or stack_limit for the overflow check (else only usage is reported). The key tool for diagnosing stack overflows.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.
- `stack_limit` (string): Lowest valid stack address (hex).
- `stack_size` (string): Stack size in bytes (used as stack_top - stack_size if stack_limit omitted).
- `stack_top` (string): Top-of-stack address (hex). Default: initial MSP from the vector table.
- `vector_table_addr` (string): Vector table base for the initial MSP (default '0x08000000').

### `reconstruct_fault_context` (~87 tokens)

Reconstructs the full crash site after a HardFault: decodes fault registers, unwinds the auto-stacked exception frame from MSP/PSP via EXC_RETURN to recover the true faulting PC, and resolves it to source file:line. Run this when halted in a fault handler.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `read_peripheral_register` (~73 tokens)

Reads a peripheral register using its name from the loaded SVD.

Input parameters:

- `peripheral` (string, required): Peripheral name (e.g., 'GPIOA').
- `register` (string, required): Register name (e.g., 'ODR').
- `session` (string): Optional debug-session name. Omit for the default target.

### `get_session` (~106 tokens)

Returns this session's record by view: 'journal' (every tool call with args/ok/summary/duration; supports limit), 'timeline' (compact human-readable replay), or 'metrics' (per-tool call counts, success/failure, durations).

Input parameters:

- `limit` (integer): journal: return only the most recent N entries.
- `session` (string): Optional debug-session name. Omit for the default target.
- `view` (string): Which view (default journal).

### `list_sessions` (~90 tokens)

Lists all debug target sessions (the 'default' one plus any named) with their liveness and port. To debug MULTIPLE boards at once, pass a 'session' argument (any string) to any tool — e.g. start_debug_session(session='rackA', ...) — and each gets fully isolated state.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.

### `close_session` (~63 tokens)

Closes a named debug session, tearing down its GDB client and server.

Input parameters:

- `session` (string): Optional debug-session name. Omit for the default target.
- `session_id` (string, required): Name of the session to close, e.g. 'rackA'.

### `report_issue` (~176 tokens)

Files a GitHub issue about an MCP problem from THIS session — auto-bundling the session journal, metrics, and MCP version into a structured report (via the gh CLI). Call this when a tool misbehaves or confuses you. Deduplicated per session so retries don't spam. Defaults to the stm32-gdb-mcp repo.

Input parameters:

- `description` (string, required): What you were doing and what went wrong.
- `env` (string): Agent/IDE + model, e.g. 'Cursor / deepseek-v4-pro'.
- `repo` (string): owner/repo to file under (default the MCP repo).
- `session` (string): Optional debug-session name. Omit for the default target.
- `title` (string, required): Short issue title, e.g. '[agent] start_debug_session ignores server_args'.

### `run_scenario` (~135 tokens)

Replays a declarative scenario — a list of {tool, args} steps — deterministically and returns a per-step pass/fail report. Provide inline 'steps' or a 'path' to a JSON scenario file. The minimal-step way to re-run a complex bug repro.

Input parameters:

- `path` (string): Path to a JSON scenario file (alternative to inline steps).
- `session` (string): Optional debug-session name. Omit for the default target.
- `steps` (array): Ordered steps, each {tool, args}.
- `stop_on_failure` (boolean): Stop at the first failing step (default true).

### `logging` (~280 tokens)

Firmware log capture over a channel. action=start(channel[,port,baudrate,command,args,file,timeout]) | stop(channel) | get(channel[,limit,since_index,clear]) | clear(channel). channel=rtt|swo|uart; uart takes port/baudrate, rtt/swo take command/args or file.

Input parameters:

- `action` (string, required): Which operation to perform.
- `args` (array): rtt/swo: command arguments.
- `baudrate` (integer): uart: baudrate (default 115200).
- `channel` (string): Log channel.
- `clear` (boolean): Clear returned entries after reading.
- `command` (string): rtt/swo: executable to launch (rtt defaults to JLinkRTTClient).
- `file` (string): swo: tail OpenOCD's ITM decode file (run setup_swo first) — no external decoder needed.
- `limit` (integer): Max recent entries to return.
- `port` (string): uart: serial port, e.g. COM3 or /dev/ttyUSB0.
- `session` (string): Optional debug-session name. Omit for the default target.
- `since_index` (integer): Only entries with index greater than this.
- `timeout` (number): uart: read timeout seconds (default 0.1).

### `breakpoint` (~209 tokens)

Breakpoint / watchpoint management. action=set(location[,condition,temporary,ignore_count]) | delete(breakpoint_id) | list | watch(location,access_type). access_type=r|w|a.

Input parameters:

- `access_type` (string): Read (r), Write (w), or Access (a).
- `action` (string, required): Which operation to perform.
- `breakpoint_id` (string): ID of the breakpoint to delete (e.g., '1').
- `condition` (string): Optional C expression; break only when it is non-zero, e.g. 'count > 5'.
- `ignore_count` (integer): Number of hits to ignore before stopping.
- `location` (string): Location to break at, e.g., 'main', 'main.c:42', or '*0x08001000'.
- `session` (string): Optional debug-session name. Omit for the default target.
- `temporary` (boolean): If true, the breakpoint is deleted after its first hit.

### `debug_profile` (~376 tokens)

Active debug profile (mcu/elf/svd/probe). action=get | set([mcu,elf_path,svd_path,board,probe,server_type,server_args,project_root,hub,notes,merge]). set merges at the TOP LEVEL ONLY: omitted fields keep their value, but a nested block you pass REPLACES the stored one whole — hub={map:{3:{label:TC}}} drops the rest of hub, including what hub(action=discover) wrote. merge=true deep-merges nested blocks instead; leave it off to DROP a stale entry, since replace is the only way to remove one. Returns the full resulting profile, which is in-memory only: empty again after the MCP server restarts.

Input parameters:

- `action` (string, required): Which operation to perform.
- `board` (string)
- `elf_path` (string)
- `hub` (object): Programmable USB hub binding: {port, serial, channel, map, power_cycle, guard}. channel is 1-based and selects which port this session's board sits on.
- `mcu` (string)
- `merge` (boolean): Deep-merge nested blocks (hub, rtt, uart, swo, reset, hil) into the stored ones instead of replacing them -- use it to add one key, e.g. a hub.map label, without dropping the identity hub(action=disc…
- `notes` (string)
- `probe` (string)
- `project_root` (string)
- `server_args` (array)
- `server_type` (string)
- `session` (string): Optional debug-session name. Omit for the default target.
- `svd_path` (string)

### `hub` (~453 tokens)

Programmable USB hub: per-port power, USB2 data lines, cold boot, and V/I sampling. action=describe | power(state[,channel,confirm]) | data(state[,channel,exclusive,confirm]) | cycle([channel,off_ms,settle_ms,confirm]) | measure([channel,duration_sec,interval_sec,all_channels]) | discover([apply,force,settle_sec]) | dashboard([state,port,interval_sec,open_browser]). dashboard serves a read-only live web page on 127.0.0.1 and returns its URL. state=on|off; channel is 1-based and defaults to the session's mapped hub channel. Removing port power cold-boots that board and un-enumerates its probe.

Input parameters:

- `action` (string, required): Which operation to perform.
- `all_channels` (boolean): Sample every channel instead of just one.
- `apply` (boolean): Write the discovered map into the debug profile.
- `channel` (integer): 1-based hub channel. Defaults to the session's mapped hub channel.
- `confirm` (boolean): Required to cut power/data when the guard is in confirm mode or a session is live.
- `duration_sec` (number): Sampling window; 0 (default) takes one snapshot.
- `exclusive` (boolean): With state=on, disconnect every other port's data line.
- `force` (boolean): Run even though a GDB server is alive on this session.
- `interval_sec` (number): Delay between samples (default 0.05).
- `off_ms` (integer): Milliseconds to hold power off (default 400).
- `open_browser` (boolean): Also open the page in the default browser.
- `port` (integer): HTTP port on 127.0.0.1 (default 8765).
- `session` (string): Optional debug-session name. Omit for the default target.
- `settle_ms` (integer): Milliseconds to wait after restoring power (default 1500).
- `settle_sec` (number): Seconds to wait for USB re-enumeration per toggle (default 1.0).
- `state` (string): Target state for the port.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/zeraissh-stm32-gdb-mcp/stm32-gdb-mcp#diagnostics

## Score history

- 2026-10-22: 65
- 2026-10-21: 65
- 2026-10-20: 79
- 2026-10-19: 79

## Common questions

### What is the STM32 GDB Debugger MCP server?

STM32 GDB Debugger is an MCP server listed in the public MCP registry as io.github.Zeraissh/stm32-gdb-mcp. Debug STM32 firmware on real hardware via GDB + OpenOCD/ST-Link/J-Link with decoded results. This page covers its PyPI package (stm32-gdb-mcp).

### Is the STM32 GDB Debugger MCP server safe to use?

STM32 GDB Debugger scores 65 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 22 October 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the STM32 GDB Debugger MCP server expose?

STM32 GDB Debugger exposes 38 tools: start_debug_session, stop_debug_session, self_check, detect_probe, suggest_server_args, and 33 more. Their descriptions and schemas cost roughly 5,893 tokens of context every time the server is loaded.

### Is the STM32 GDB Debugger MCP server still maintained?

STM32 GDB Debugger is still listed as active in the MCP registry. We last reached this channel on 22 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the STM32 GDB Debugger MCP server under?

STM32 GDB Debugger declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/stm32-gdb-mcp/
- Socket report: https://socket.dev/pypi/package/stm32-gdb-mcp
- Repository: https://github.com/Zeraissh/stm32-gdb-mcp
- Changelog RSS feed: https://verifymcp.io/servers/zeraissh-stm32-gdb-mcp/stm32-gdb-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/zeraissh-stm32-gdb-mcp/stm32-gdb-mcp.json
- HTML version of this page: https://verifymcp.io/servers/zeraissh-stm32-gdb-mcp/stm32-gdb-mcp