Log inSubmit server
J Link MCP logo

J Link MCP

Debug ARM Cortex-M hardware through SEGGER J-Link with MCP tools for flashing, registers, memory, RTT, GDB, and crash diagnosis.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install J Link MCP

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "j-link-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "jlink-mcp"
      ],
      "env": {
        "JLINK_DEVICE": "YOUR_VALUE_HERE",
        "SVD_PATH": "YOUR_VALUE_HERE"
      }
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Values are written into the snippet above so you can paste it as is. They never leave your browser.

Install not yet sandbox-tested— the server itself is confirmed live (we called its tools/list endpoint). The stdio install command is a separate, ongoing check.

Overview

J-Link MCP MCP server connects MCP-compatible AI clients to ARM Cortex-M targets through SEGGER J-Link probes. It can discover and configure probes and target part names, start debug sessions, flash or erase firmware, inspect registers and memory, control execution, and retrieve RTT output. CMSIS-SVD files add named peripherals and decoded register fields, while crash tools interpret Cortex-M fault registers and exception frames. Reach for it when an agent needs to investigate firmware on physical embedded hardware rather than only inspect source code.

Use cases

  • Debug a HardFault on a connected Cortex-M board
  • Flash firmware and reset a development target
  • Inspect peripheral registers using a CMSIS-SVD file
  • Capture RTT output alongside CPU and fault state
  • Run source-level GDB debugging through an AI client

Key features

  • SEGGER J-Link probe and ARM Cortex-M debugging
  • Firmware flashing and target flash erasure
  • CPU register, memory, breakpoint, and execution control
  • Cortex-M fault decoding with exception stack analysis
  • RTT connection and recent log capture
  • CMSIS-SVD peripheral and bit-field decoding

Tools47

What J Link MCP lets your agent do. Expand a tool for its parameters.

Verified live~3.5k tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 2d ago

Recent health check succeeded.

9/9 checks healthy over the last 47d

What it can do

From the 47 tools this server returned when we ran it.

Runs commands · 1Read-only tools · 46
Network at startup3 connections
Files written at startupNone
Install scriptsNone
npm provenanceNot published
Package age204 days
Maintainers1

Observed 2026-10-25 in an isolated sandbox. A description of reach, not a security audit.

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 7d ago via OSV.dev · jlink-mcp (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars39Stargazers on the source repository.
npm downloads191Package downloads in the last 30 days.
Last commit3d agoMost recent push to the default branch.
Tools exposed47Callable tools this server registers over MCP.

How J Link MCP works

What J-Link MCP does

J-Link MCP exposes embedded debugging operations through the Model Context Protocol. It connects an MCP client to an ARM Cortex-M target using a SEGGER J-Link probe and provides operations for setup, firmware deployment, CPU control, memory inspection, register access, RTT output, and GDB-based debugging.

The workflow is suitable for boards connected to the host machine. It can identify attached probes, search the J-Link installation's supported target names, select an exact device name, and run a setup check before debugging. The server can also switch the selected target at runtime without restarting.

How it works

A typical session begins with check_setup or start_debug_session. The setup check reports whether the J-Link software, probe, target selection, and optional readability files are available. start_debug_session starts the J-Link GDB server, connects RTT when supported, and waits for initial output.

Once connected, the agent can halt, resume, reset, or single-step the CPU. It can read all registers or a named register, inspect memory, write a 32-bit value, set hardware breakpoints, clear breakpoints, flash firmware, and erase target flash. device_info leaves the target halted, so the agent should call resume when continued execution is intended.

The GDB tools provide a second debugging path. gdb_connect attaches a GDB client to the running server and can load an ELF file for symbols. gdb_command accepts arbitrary GDB commands, including backtraces, variable inspection, source-level stepping, register inspection, and execution commands. Long-running execution commands can be followed with gdb_wait when needed.

Setup and configuration

Install the SEGGER J-Link software, connect a J-Link probe to an ARM Cortex-M target, and use Node.js 18 or newer. The npm package can be launched without a build step:

Terminal
npx -y jlink-mcp

Set JLINK_DEVICE to the target's exact J-Link device name when configuring the server manually. If the part name is unknown, call search_devices by part number, manufacturer, or core before calling set_device.

A CMSIS-SVD file can be supplied through SVD_PATH or selected later with set_svd_path. The RTT control-block address can likewise be configured at runtime with set_rtt_address. VS Code provides an extension that registers the server for MCP-aware chat clients, and Claude Code provides a plugin installation path.

Tools and capabilities

  • Capture combined CPU, fault, stack, and recent RTT state with snapshot.
  • Decode Cortex-M fault registers and exception frames with diagnose_crash.
  • List SVD-defined peripherals and read registers with named bit fields.
  • Start, stop, and inspect the J-Link GDB server and RTT connection.
  • Read and write target memory, flash firmware, erase flash, and control breakpoints.

Limitations and notes

The target name must match the J-Link installation exactly; guessing a part number can produce an error that resembles a hardware failure. list_devices reports connected probes, not target chips. Peripheral names and decoded fields require a configured CMSIS-SVD file. RTT recovery after reset or flashing requires the RTT control-block address; without it, a stopped stream can look like a quiet device. The server operates on real connected hardware, so commands such as erase, flash, reset, halt, and memory writes affect the target.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about J Link MCP

J-Link MCP is an MCP server that connects AI clients to ARM Cortex-M hardware through SEGGER J-Link probes. Its main tools configure targets, start debug sessions, flash firmware, inspect registers and memory, control execution, capture RTT output, run GDB commands, and diagnose Cortex-M faults from real devices.

Install the SEGGER J-Link software, connect a probe and ARM Cortex-M target, then run `npx -y jlink-mcp`. Configure `JLINK_DEVICE` with the exact target name, or use `search_devices` followed by `set_device` to find and select it.

Use `search_devices` before `set_device`. It searches the device names accepted by the installed J-Link software by part number, manufacturer, or core, and the selected name must match J-Link's spelling exactly.

Call `diagnose_crash` after connecting to the target. It reads and decodes CFSR, HFSR, MMFAR, and BFAR, examines the exception stack frame, and includes recent RTT errors when available. `snapshot` provides a broader combined state capture.

Configure a CMSIS-SVD file with `SVD_PATH` or call `set_svd_path`, then use `list_peripherals`, `read_peripheral`, or `decode_register`. These tools use the SVD descriptions to show peripheral names, register fields, and decoded values instead of only raw hexadecimal data.

Related MCP servers

All in Embedded System All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewJ Link MCP AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/j-link-mcp?style=directory)](https://allmcps.com/mcp/j-link-mcp)
HTML Embed
<a href="https://allmcps.com/mcp/j-link-mcp"><img src="https://allmcps.com/api/badge/j-link-mcp?style=directory" alt="J Link MCP on AllMCPs" /></a>