jlink-mcp
jlink-mcp lets AI assistants debug embedded ARM Cortex-M devices through J-Link, OpenOCD, or Black Magic Probe backends via MCP.
Discover connected probes, check setup, search/select target devices, and configure SVD/RTT settings at runtime.
Start/stop debug sessions and GDB servers, halt/resume/reset/step the CPU, and capture full device snapshots.
Read/write memory, read CPU registers, set/clear breakpoints, flash firmware, and erase target flash.
Diagnose ARM Cortex-M crashes by decoding fault registers and exception stack frames automatically.
Inspect peripherals and decode register bit fields using CMSIS-SVD files.
Stream, read, search, clear, and send RTT logs, including distinguishing quiet firmware from a stopped probe.
Attach GDB for source-level debugging: backtraces, variables, conditional breakpoints, line stepping, and ELF symbol loading.
Relay RTT data through a telnet proxy for external decoders, run raw probe commands, and inspect current configuration.
Provides debugging for ARM Cortex-M microcontrollers, including register and memory access, flashing firmware, crash fault decoding, RTT logging, breakpoint control, and GDB server integration.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@jlink-mcp read memory at 0x20000000"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
See it work
Your firmware just crashed. One tool call:
> diagnose_crash
## Crash Diagnosis
### CPU State
Core: PC=0x000000B8 SP=0x2003FFA8 R0=0x0000000A R1=0x000007FF R2=0x00000001 ...
Status: XPSR=0x21000003 CONTROL=0x00000000 PRIMASK=0x00000000 ...
Stack: MSP=0x2003FFA8 PSP=0x00000000
⚠ CPU is in exception handler (IPSR=0x00000003)
### Fault Registers
CFSR=0x01000000 HFSR=0x40000000 DFSR=0x00000000 MMFAR=0xe000edf8 BFAR=0xe000edf8
### Decoded Faults
## UsageFault (UFSR):
- UNALIGNED: Unaligned memory access
## HardFault (HFSR):
- FORCED: Forced HardFault (escalated from configurable fault)
### Exception Stack Frame
R0 = 0x0000000A R1 = 0x000007FF
R12 = 0x00000000 LR = 0x000001F5
PC = 0x00000254 xPSR = 0x21000000
→ Faulting instruction at PC=0x00000254
### Recent Errors/Warnings from RTT
[WRN] sensor_drv: sample out of range, clamping seq=2Fault decoded, exception frame unwound, faulting instruction named, and the device's own log correlated — from one call, without a human reading a datasheet to find out what bit 24 of CFSR means.
And it knows what the silicon is
Point it at your target's CMSIS-SVD file and peripheral registers stop being hex:
> read_peripheral FICR
FICR @ 0x10000000
INFO.PART @ 0x10000100 = 0x00052840 (read-only)
[31:0] PART 0x52840 → N52840
INFO.RAM @ 0x1000010C = 0x00000100 (read-only)
[31:0] RAM 0x100 → K256
INFO.FLASH @ 0x10000110 = 0x00000400 (read-only)
[31:0] FLASH 0x400 → K10240x400 means 1024 KB of flash — but only if you know that, and an LLM guessing
at bit layouts is exactly the failure this avoids. The addresses come from the
vendor's own description, and the meanings from its enumerations.
Both transcripts are verbatim output from an nRF52840-DK in this project's hardware test suite.
Related MCP server: jlink-mcp
What is this?
jlink-mcp connects AI assistants (Claude, Copilot, etc.) to your embedded hardware via SEGGER J-Link debug probes using the Model Context Protocol.
Instead of manually typing J-Link commands, your AI assistant can:
Read registers and memory to understand device state
Flash firmware and reset devices
Stream RTT logs and search them by level/module/regex
Diagnose crashes by auto-decoding ARM Cortex-M fault registers
Control execution — halt, step, resume, breakpoints
Start GDB servers for full debugging sessions
Also supports OpenOCD (ST-Link, CMSIS-DAP, FTDI) and Black Magic Probe backends.
Installing
You need the SEGGER J-Link software
— that is what this server drives — a probe connected to an ARM Cortex-M
target, and Node 18+. For the other backends, OpenOCD or arm-none-eabi-gdb
instead.
Claude Code — from the plugin marketplace. This brings the
embedded-debugging skill along with the server, which is what stops an
assistant guessing at your hardware:
/plugin marketplace add Klievan/jlink-mcp
/plugin install jlink-mcpAny other agent — point it at this repository and ask it to set itself up:
Install the MCP server at https://github.com/Klievan/jlink-mcp and configure it for my board.
It will find what it needs here. If you would rather do it by hand, the server
is on npm and needs no build step: npx -y jlink-mcp, with JLINK_DEVICE set
to your target. mcp-config.json is a config you can paste.
VS Code — install the extension. It registers the server for Copilot Chat, Claude, and any MCP-aware client, so there is nothing to configure.
Nix / NixOS — run directly from the flake without installing:
# Run standalone MCP server
nix run github:Klievan/jlink-mcp
# Or in an MCP client configuration (e.g. Claude Desktop / Claude Code)
# "command": "nix", "args": ["run", "github:Klievan/jlink-mcp", "--"]Or add jlink-mcp and jlink-mcp-skills to your system configuration or flake:
# flake.nix inputs
inputs.jlink-mcp.url = "github:Klievan/jlink-mcp";
# In your packages:
inputs.jlink-mcp.packages.''${system}.jlink-mcp
inputs.jlink-mcp.packages.''${system}.jlink-mcp-skillsNote for NixOS users: Add your preferred probe tools (
segger-jlink/segger-jlink-headless,openocd, orgdb) toenvironment.systemPackagesor yourdevShell.segger-jlinkrequiresnixpkgs.config.allowUnfree = true;andservices.udev.packages = [ pkgs.segger-jlink ];for probe USB permissions.
Then check it
Ask for check_setup. One call, and it says what is missing and what to do:
Not ready to debug yet.
OK probe software — J-Link software found at /Applications/SEGGER/JLink
BLOCK probe — none detected (Connecting to J-Link via USB...FAILED). Check the USB cable.
BLOCK target device — not set. Find the exact name with search_devices, then set_device.
note SVD — not loaded, so peripheral reads stay raw hex. Set SVD_PATH to a CMSIS-SVD file.You do not need your device's exact part number up front. search_devices
searches all 9800 that J-Link supports, by part number, manufacturer, or core.
Tools (48)
Workflow Tools (start here)
Tool | Description |
| One-call setup. Starts GDB server + connects RTT + returns boot log. |
| Captures full device state: registers, fault status, stack dump, RTT output. |
| Auto-reads and decodes ARM Cortex-M fault registers (CFSR, HFSR, MMFAR, BFAR) with exception stack frame. |
Device Setup
Tool | Description |
| Scan for connected probes and show the configured target |
| Change the target device at runtime — no restart needed |
| Change the probe serial number at runtime (for multi-probe setups) |
| Current probe, target device, and GDB server state |
Device Control
Tool | Description |
| Probe type, target CPU, compact register summary |
| Halt CPU |
| Resume CPU |
| Reset device. |
| Single-step one instruction |
Peripherals (CMSIS-SVD)
Set jlinkMcp.svdPath to your target's SVD — the same file Cortex-Debug takes
as svdFile. Vendors publish one per part.
Tool | Description |
| Every peripheral and base address on the chip |
| Read a peripheral's registers and decode each one's bit fields by name |
| Decode one register — read from the device, or interpret a value you already have |
Memory & Registers
Tool | Description |
| Read memory at address (clean hex dump output) |
| Write 32-bit value to address |
| All CPU registers in compact format |
| Read specific register (PC, SP, R0-R12, etc.) |
Flash
Tool | Description |
| Flash .hex/.bin/.elf firmware to device |
| Erase entire flash |
Breakpoints
Tool | Description |
| Set hardware breakpoint at address |
| Clear all breakpoints |
GDB Server
Tool | Description |
| Start probe's GDB server |
| Stop GDB server + disconnect RTT |
| GDB server, RTT, and proxy status |
Source-Level Debugging
Attach a real GDB client for symbol-aware work — backtraces, variable inspection, and stepping by source line rather than by instruction.
Tool | Description |
| Attach a GDB client (auto-starts the server; optional ELF for symbols) |
| Load an ELF for debug symbols, optionally flashing it too |
| Call stack, optionally with locals in each frame |
| Run any GDB command — |
| Wait for the target to stop (after a continue or a breakpoint) |
| Detach the client, clearing breakpoints and debug hardware |
RTT (Real-Time Transfer)
Tool | Description |
| Connect to RTT telnet port |
| Disconnect from RTT |
| Read recent log lines (ANSI stripped, Zephyr format parsed) |
| Filter logs by level ( |
| Send data to device via RTT down-channel |
| Clear RTT buffer |
Telnet Proxy (Trice / Pigweed)
Tool | Description |
| Start TCP proxy that tees RTT for external detokenizers |
| Stop proxy |
| Proxy connection status |
| Read raw proxy buffer |
Advanced
Tool | Description |
| Execute raw probe commands |
| Current probe and server configuration |
The status bar knows who has the probe
A J-Link serves one client at a time, so a GDB server left running blocks everything else — and the usual way that happens is an assistant starting one through MCP and nobody noticing. The extension cannot detect that by remembering what it did: the MCP server runs in a separate process, so an LLM-started server is invisible to it.
So it watches the GDB port instead, which is true whoever is responsible. When something is listening the status bar turns amber and reads J-Link · MCP · 47m — who started it, and how long ago. Those are the two facts that turn "something has the probe" into "the assistant has had it since before lunch". Clicking offers to stop it.
The tooltip carries the rest: device, ports, whether RTT is up, and why it matters. And it never claims an uptime it did not watch — a server that was already running when the window opened is reported as known about for that long, not up for it.
It will not kill a process it cannot identify as a J-Link GDB server. A listening port proves something is there, not that it is ours.
The skill
The tools tell a model what it can do. They do not tell it what is worth doing, and two things go wrong constantly without that: models never think to load the ELF, so every backtrace is bare addresses; and they reason about what the hardware should be doing instead of spending one call asking it.
skills/embedded-debugging/SKILL.md is a Claude Code skill that covers both —
the two files that change everything (ELF for names, SVD for meanings), the
halt/read/resume rule, workflows for crashes, hangs, peripherals and silent
devices, and a table of beliefs paired with the tool call that actually checks
each one.
Claude Code picks it up if you install this repo as a plugin
(.claude-plugin/plugin.json), or you can copy the directory into
.claude/skills/ in your firmware project. MCP itself has no notion of skills
— its portable equivalent is prompts, and this server ships four.
Its claims are tested. test/hil/s04-symbols.test.ts proves on real silicon
that a backtrace without symbols has no function names, that loading the ELF
gives them, and that a symbols-only load does not reprogram the device.
Multi-Probe Support
jlink-mcp supports multiple debug probe backends through a common ProbeBackend abstraction:
Backend | Probe Hardware | Status | RTT Support |
J-Link | SEGGER J-Link, J-Link OB, J-Link EDU | Production | Yes |
OpenOCD | ST-Link, CMSIS-DAP, FTDI, J-Link (via OpenOCD) | Beta | No |
Black Magic Probe | BMP (built-in GDB server on serial) | Beta | No |
probe-rs | All probe-rs supported probes | Planned | Planned |
Selecting a Backend
# J-Link (default)
PROBE_TYPE=jlink JLINK_DEVICE=nRF52840_XXAA node out/mcp/standalone.js
# OpenOCD with ST-Link
PROBE_TYPE=openocd \
OPENOCD_INTERFACE=interface/stlink.cfg \
OPENOCD_TARGET=target/stm32f4x.cfg \
node out/mcp/standalone.js
# Black Magic Probe
PROBE_TYPE=blackmagic \
BMP_SERIAL_PORT=/dev/ttyACM0 \
node out/mcp/standalone.jsArchitecture
┌─────────────────────────────────────────────────────┐
│ MCP Client │
│ (Claude, Copilot, any MCP client) │
└──────────────────────┬──────────────────────────────┘
│ JSON-RPC over stdio
┌──────────────────────▼──────────────────────────────┐
│ jlink-mcp │
│ │
│ ┌──────────┐ ┌──────────┐ ┌───────────────────┐ │
│ │ 31 Tools │ │4 Resources│ │ 4 Prompts │ │
│ └────┬─────┘ └────┬─────┘ └───────┬───────────┘ │
│ │ │ │ │
│ ┌────▼──────────────▼────────────────▼───────────┐ │
│ │ ProbeBackend │ │
│ │ ┌─────────┐ ┌─────────┐ ┌──────────────────┐ │ │
│ │ │ J-Link │ │ OpenOCD │ │ Black Magic Probe│ │ │
│ │ └────┬────┘ └────┬────┘ └────────┬─────────┘ │ │
│ └───────┼───────────┼───────────────┼─────────────┘ │
│ │ │ │ │
│ ┌───────▼───┐ ┌─────▼────┐ ┌───────▼──────────┐ │
│ │ RTTClient │ │TelnetProxy│ │ ProcessManager │ │
│ └───────────┘ └──────────┘ └──────────────────┘ │
└─────────────────────────────────────────────────────┘
│
┌────────────▼────────────┐
│ Debug Probe (USB) │
│ → Target MCU (SWD/JTAG)│
└─────────────────────────┘Source Layout
src/
├── probe/
│ ├── backend.ts # ProbeBackend abstract class + shared utilities
│ ├── jlink.ts # SEGGER J-Link implementation
│ ├── openocd.ts # OpenOCD implementation
│ ├── blackmagic.ts # Black Magic Probe implementation
│ └── factory.ts # Probe creation from config
├── mcp/
│ ├── server.ts # MCP server (45 tools, 4 resources, 4 prompts)
│ └── standalone.ts # Standalone entry (stdio transport)
├── rtt/
│ └── rtt-client.ts # RTT client with ANSI stripping + Zephyr log parsing
├── telnet/
│ └── telnet-proxy.ts # TCP proxy for Trice/Pigweed detokenizer
├── utils/
│ ├── config.ts # VSCode settings / env var config
│ ├── logger.ts # Logging
│ └── process-manager.ts # Child process lifecycle
└── extension.ts # VSCode extension + MCP provider registrationDesign Decisions (LLM-Optimized)
This server was built by having an AI use it against real hardware, then fixing every friction point.
What read_registers would give you
Raw JLinkExe output for halt; regs — 77 lines, of which about six carry
information. Every token here costs context, and the register values are buried
in the middle:
SEGGER J-Link Commander V9.70 (Compiled Aug 19 2026 12:16:13)
DLL version V9.70, compiled Aug 19 2026 12:15:25
Connecting to J-Link ...O.K.
Firmware: J-Link OB-nRF5340-NordicSemi compiled Jun 11 2026 13:12:28
Hardware version: V1.00
J-Link uptime (since boot): 0d 00h 34m 29s
S/N: 1050298247
License(s): RDI, FlashBP, FlashDL, JFlash, GDB
...30 more lines of connect banner...
PC = 00000044, CycleCnt = 00EB67E5
R0 = 20000000, R1 = 9D56C547, R2 = 00000000, R3 = 00000000
...
FPS0 = 00000000, FPS1 = 00000000, FPS2 = 00000000, FPS3 = 00000000
...28 more lines of zeroed FP registers...What it actually gives you
Three lines. Same information, grouped by what you would ask for:
Core: PC=0x00000046 SP=0x20010000 R0=0x20000000 R1=0x01D43416 R2=0x00000000 ...
Status: XPSR=0x01000000 CONTROL=0x00000000 PRIMASK=0x00000000 BASEPRI=0x00000000
Stack: MSP=0x20010000 PSP=0x00000000Both captured from the same board. The rest of the design follows the same rule — return what was asked for, and nothing else:
Output parsing strips the connection banner. Only data comes back.
Registers are compact and grouped (core / status / stack).
FP registers only shown if non-zero (they're usually all zeros).
RTT output has ANSI escape codes stripped and Zephyr log format parsed into structured fields.
Composite tools (
start_debug_session,snapshot,diagnose_crash) replace multi-step workflows with single calls.Fault decoding is automatic — reads CFSR/HFSR/MMFAR/BFAR and explains each bit.
rtt_searchlets you find errors without reading the entire log.Peripheral registers decode through the vendor's own CMSIS-SVD, so the model reads
RAM = K256rather than guessing what0x100means in that field of that register.Failures say what to do. "Target is running; use halt" beats "could not read memory", and a fault-register read that did not happen reports itself rather than decoding zeroes into "no faults detected".
Verified on real hardware
Most of what can go wrong between an LLM and a debug probe fails quietly: a tool returns success with an empty payload, a parser drops half a line, a session dies and the next command reports something plausible instead. None of that is visible from reading the code, and a test suite that asserts "the call did not error" passes on all of it.
So this project runs a hardware tier: 58 tests against a real nRF52840-DK on a self-hosted runner, driving the actual MCP server over stdio exactly as a client would. It covers probe discovery, flash and verify, halt/step/resume under a live GDB session, memory and peripheral reads, RTT streaming and filtering, and crash diagnosis against faults injected on demand.
It has caught bugs that had been shipping green, including:
diagnose_crashreporting "No faults detected" during real crashes — the memory-dump parser was dropping half of every lineevery GDB-routed tool returning empty output while the server reported itself healthy
sessions leaving the target unbootable, with breakpoint comparators still armed that no reset clears
resetreporting success while doing nothing at all — the GDB server is a synchronous remote and refuses commands while the target runs, so every command of the reset sequence was rejected in turn and the failure discardedthe session teardown that disarms debug hardware being refused in its entirety for the same reason, and reporting "debug hardware disarmed" regardless — the fix above is what made this one visible
a GDB server reported running when it had already exited, because startup returned on the spawn without waiting to see whether it got the probe
RTT going silent after a reset or a flash — the target was still logging and the probe had stopped collecting, which reads exactly like a quiet device. Caught by reading the control block from both ends: 490 bytes written by the firmware, none collected
an assignment that was silently discarded, taking RTT out for the rest of the session — the flag guarding it asked whether a state enum read
GDB_RUNNING, when the question it meant to ask was whether the GDB server was running
Every one of those reported success. That is the point of the hardware tier, and the reason the suites assert on parsed content rather than on the call having returned without error — a suite that checked for errors would have passed on all of them.
Raw probe output captured during those runs is committed as golden transcripts, so a fast unit tier replays real device bytes in seconds on any machine — no probe required to catch a format regression.
npm test # ~257 tests, seconds, no hardware
npm run test:hil # hardware tier; needs HIL=1 and a probeEnvironment Variables
J-Link
Variable | Default | Description |
|
| Probe backend: |
|
| Target device (e.g., |
| Auto-detect | Path to SEGGER J-Link installation |
|
| Debug interface: |
|
| Connection speed in kHz |
| J-Link serial number (multi-probe) | |
|
| GDB server port |
|
| RTT telnet port |
| Auto | Address of the RTT control block (your |
OpenOCD
Variable | Default | Description |
|
| Path to openocd binary |
|
| Interface config file |
|
| Target config file |
|
| GDB server port |
|
| Telnet command port |
Black Magic Probe
Variable | Default | Description |
|
| Path to GDB binary |
|
| BMP serial port |
|
| Target index after scan |
Contributing
Adding a new probe backend:
Create
src/probe/yourprobe.tsimplementingProbeBackendAdd a case to
src/probe/factory.tsThat's it — all 31 MCP tools work automatically
License
MIT - see LICENSE
Available Tools
48 toolscheck_setupA
Check that everything needed to debug is in place: the probe software, a connected probe, a target device name, and the optional files that make output readable. Run this first when anything fails, or when starting on a machine for the first time.
Inputs: no named parameters.
clear_breakpointsA
Clear all breakpoints, including any left armed in the debug hardware by an earlier session
Inputs: no named parameters.
decode_registerA
Decode a value into named bit fields using the target's SVD. Reads from the device unless a value is supplied — useful for interpreting a number you already have.
Inputs: register (required), peripheral (required), value.
device_infoA
Halt the target and read its registers via SEGGER J-Link. Returns the probe name and a compact register summary. Leaves the target HALTED — call resume when you are done.
Inputs: no named parameters.
diagnose_crashA
Auto-read and decode ARM Cortex-M fault registers (CFSR, HFSR, MMFAR, BFAR), exception stack frame, and recent errors.
Inputs: no named parameters.
eraseB
Erase target flash memory
Inputs: no named parameters.
flashC
Flash firmware to the target device
Inputs: filePath (required), baseAddress.
gdb_backtraceB
Get a stack backtrace. With debug symbols loaded, shows function names, file paths, and line numbers.
Inputs: full.
gdb_commandA
Send any GDB command and get the response. For execution commands (continue, step, next, finish, until), blocks until the target stops or times out. If the target doesn't stop, use gdb_wait to poll. Examples: 'bt' (backtrace), 'info threads', 'print myVar', 'break main', 'continue', 'next', 'step', 'finish', 'info registers', 'x/10xw 0x20000000'
Inputs: command (required), timeout.
gdb_connectA
Connect a GDB client to the running GDB server. Enables source-level debugging: backtraces, variable inspection, conditional breakpoints, stepping by source line. Optionally load an ELF file for symbol info.
Inputs: host, port, elfFile.
gdb_disconnectA
Disconnect the GDB client (does not stop the GDB server)
Inputs: no named parameters.
gdb_loadA
Load an ELF file into GDB. By default loads symbols only (for source-level debugging: backtraces with file:line, variable names). Set flash=true to also program it onto the target.
Inputs: elfFile (required), flash.
gdb_server_startA
Start SEGGER J-Link GDB server
Inputs: no named parameters.
gdb_server_statusB
Get GDB server, RTT, and telnet proxy status
Inputs: no named parameters.
gdb_server_stopA
Stop SEGGER J-Link GDB server and disconnect RTT
Inputs: no named parameters.
gdb_waitA
Poll for target stop after a continue/step that timed out. Returns the stop reason (breakpoint hit, signal, finished stepping, etc.) when the target halts.
Inputs: timeout.
get_configC
Get current probe and server configuration
Inputs: no named parameters.
haltA
Halt the target CPU
Inputs: no named parameters.
list_devicesA
Scan for connected PROBES — the debuggers plugged into this machine, not target chips. Despite the name it does not list target devices; use search_devices for those. Shows probe serial numbers and whether one is reachable.
Inputs: no named parameters.
list_peripheralsA
List the target's peripherals and base addresses, from its CMSIS-SVD description. Requires an SVD file to be configured.
Inputs: filter.
probe_commandC
Execute raw SEGGER J-Link commands
Inputs: commands (required).
read_memoryB
Read memory from the target. Returns clean hex dump.
Inputs: length (required), address (required).
read_peripheralA
Read every register of a peripheral from the target and decode each one's bit fields by name. This is read_memory plus the meaning of what was read.
Inputs: peripheral (required), registers.
read_registerA
Read a specific CPU register by name
Inputs: register (required).
read_registersA
Read all CPU registers (compact format, FP only if non-zero).
Inputs: no named parameters.
resetA
Reset the target device. Halting leaves the core stopped at the reset vector, which is where you want it before flashing, or to watch startup run.
Inputs: halt, strategy.
resumeC
Resume the target CPU
Inputs: no named parameters.
rtt_clearB
Clear RTT buffer
Inputs: no named parameters.
rtt_connectB
Connect to RTT
Inputs: no named parameters.
rtt_disconnectC
Disconnect from RTT
Inputs: no named parameters.
rtt_readA
Read RTT log lines (clean, parsed Zephyr format). Non-destructive — reading does not consume the buffer. Returns the NEWEST lines by default; oldest:true returns the start of the buffer. Note the buffer spans reflashes: its oldest lines may be from firmware you have since replaced. rtt_clear drops them.
Inputs: count, oldest.
rtt_searchA
Search/filter RTT logs by level, module, or regex
Inputs: count, level, module, pattern.
rtt_sendC
Send data to device via RTT down-channel
Inputs: data (required).
rtt_statusA
Read SEGGER's RTT control block on the target: is it initialised, how much has the firmware written, and how much has the probe collected. Use this when RTT is silent — it separates a quiet device from a probe that stopped collecting, which look identical from rtt_read.
Inputs: address.
search_devicesA
Search the device names this J-Link installation accepts, by part number, manufacturer, or core. Use this before set_device instead of guessing a part number — the name must match exactly, and a wrong one fails in a way that looks like broken hardware.
Inputs: query (required), limit.
set_breakpointC
Set a hardware breakpoint
Inputs: address (required).
set_deviceA
Set the target device name at runtime. Required before any debugging commands will work. The name must match J-Link's exactly — use search_devices to find it rather than guessing a part number. Examples: 'nRF52840_XXAA', 'nRF5340_xxAA_APP', 'STM32F407VG', 'STM32L476RG'.
Inputs: device (required).
set_rtt_addressA
Tell the server where the firmware's RTT control block is (its _SEGGER_RTT symbol), at runtime. Without it RTT cannot be recovered after a reset or flash, and a stopped stream is indistinguishable from a quiet device. Mirrors set_device.
Inputs: address (required).
set_serial_numberA
Set the debug probe serial number at runtime. Required when multiple probes are connected to select which one to communicate with. Run list_devices to see connected serial numbers.
Inputs: serialNumber (required).
set_svd_pathA
Point the server at a CMSIS-SVD file for the target at runtime, so peripheral reads come back with named fields and decoded values instead of raw hex. Mirrors set_device — you do not have to restart with SVD_PATH set.
Inputs: path (required).
snapshotA
Capture complete device state: CPU registers (compact), fault status, recent RTT output, and stack dump.
Inputs: rttLines.
start_debug_sessionA
One-call setup: starts GDB server via SEGGER J-Link, connects RTT (if supported), waits for initial output. This is the recommended first tool to call. If no device is configured, use list_devices and set_device first.
Inputs: no named parameters.
stepA
Step one CPU instruction
Inputs: no named parameters.
telnet_proxy_readC
Read raw data from telnet proxy buffer
Inputs: lines.
telnet_proxy_startA
Start a TCP relay that re-serves the RTT stream on another port, so an external decoder (Trice, Pigweed, or your own) can consume it alongside this server. It relays bytes; it does not decode them.
Inputs: no named parameters.
telnet_proxy_statusA
Get telnet proxy status
Inputs: no named parameters.
telnet_proxy_stopB
Stop telnet proxy
Inputs: no named parameters.
write_memoryB
Write a 32-bit value to memory
Inputs: value (required), address (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 48 tools
There is substantial overlap between direct probe controls, GDB client wrappers, and catch-all tools: halt/resume/step vs. gdb_command continue/step, device_info vs. read_registers, and snapshot/diagnose_crash/check_setup all touch related state. Descriptions explicitly warn about several pitfalls and distinguish some boundaries, but an agent still faces multiple valid-seeming paths for common debug operations.
Most names are snake_case and many use consistent resource prefixes such as gdb_, rtt_, and telnet_proxy_. There are minor deviations: bare verbs like halt, resume, step, and snapshot mix with verb_noun tools, and device-related names like list_devices, search_devices, and device_info are not perfectly parallel.
The 48-tool surface is far beyond the typical well-scoped range, even for a rich embedded-debug domain. Much of the count comes from layered APIs plus start/stop/status triples and many small configuration setters, which could be consolidated.
The server covers probe discovery/configuration, GDB server and client control, flashing/reset, memory and register access, breakpoints, SVD-based peripheral decoding, RTT, telnet proxy, and crash diagnostics. Minor gaps exist, such as clearing/listing individual breakpoints and varied memory write widths, but catch-all gdb_command and probe_command mitigate many dead ends.
Maintenance
Related MCP Connectors
Design circuits, simulate and verify embedded firmware, and lay out PCBs with AI agents.
Run, build, and validate firmware on virtual hardware from your AI agent. Hardware knowledge corpus.
- DNS-DATA RemoteDeprecatedcom.dns-data
Connect AI assistants to authorized Windows and macOS devices for files, commands, and management.
Flutter in-app bug tracking, visual pin annotations, and device logs directly into your AI IDE.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI to directly control SEGGER J-Link embedded debug probes via the Model Context Protocol for debugging and firmware management. Users can perform tasks like reading registers, analyzing memory, flashing firmware, and tracking RTT logs using natural language commands.211MIT
- AlicenseAqualityDmaintenanceEnables AI assistants like Claude to directly debug microcontrollers via JLink, supporting breakpoints, single-step, memory/register access, variable inspection, RTT logging, and firmware flashing.257MIT
- AlicenseAqualityDmaintenanceEnables LLMs to interact with embedded devices by reading and writing Segger RTT data through a J-Link debugger.91MIT
- AlicenseAqualityDmaintenanceEnables AI assistants to interact with STM32 development boards via J-Link debugger using RTT communication, supporting connection, logging, memory operations, and firmware flashing through natural language.121MIT