How do I use Keil5 MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Keil5 MCP Server Build the project and fix any compile errors it reports." 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.

de en es ja ko ru zh

Keil5 MCP Server

by ZMC1011

Overview Schema Source Related Servers Discussions Admin

Python

Local

Keil5 MCP Server

English | 中文

A Model Context Protocol (MCP) server that gives deepseek harness a edit code → flash → debug → read feedback → fix code closed loop for STM32 development with Keil MDK.

Instead of manually switching between the IDE, the programmer and the terminal, an agent can:

Build a Keil project and watch real-time compile progress
Get structured errors from UV4 logs (file / line / column / code / message)
Explain error codes with causes and suggested fixes
Edit source files safely (every edit is auto-backed up)
Flash firmware via the official UV4 channel or pyOCD
Debug on hardware through pyOCD: breakpoints, stepping, registers, memory, RTT logs
Run the official Keil debug channel (UV4 -d + .ini scripts)

Related MCP server: mcp-stm32cubeide-server

Features

27 MCP tools registered as mcp__<serverName>__<tool> (e.g. mcp__keil__build_project)
Real-time build progress: tail-based monitor with percent / current file / phase, capped at 95% until link finishes
Structured UV4 log parsing: compile errors (main.c(25:1): error C2065: ...), link errors (L6218E), Program Size, build time
Error-code knowledge base: built-in explanations and fixes for common armcc/armclang codes (C2065, L6218E, L6406E, ...)
Safe source editing: automatic .keil-mcp-backups/ before every edit, line-range replace, regex search
Official flash path: UV4 -f uses the project's configured Flash algorithm; pyOCD fallback accepts .axf directly
Hardware debug: pyOCD probe control (connect / halt / resume / step / breakpoint / registers / memory / RTT)
Probe lease: per-probe exclusive access (asyncio lock + file lock) so UV4 and pyOCD never fight over the debug port
Execution boundary: read-only tools run concurrently; mutating tools serialize on a session lock; cancellation-safe via asyncio.shield
Works without Keil installed: keil_doctor reports missing components clearly; the server still starts

Requirements

Component	Version / Notes
Python	3.10+ (tested on 3.12)
Keil MDK	`UV4.exe`
pyOCD	installed automatically via pip; needs a probe driver (ST-Link / J-Link / CMSIS-DAP)
Probe	ST-Link V2/V3, J-Link, CMSIS-DAP, Keil ULINKplus
Target pack	e.g. `pyocd pack install stm32f103c8` or reuse the Keil DFP

Installation

From PyPI

python -m venv .venv
.venv/Scripts/activate        # Windows
# source .venv/bin/activate   # Linux / macOS
pip install keil-mcp-server

Package is PyPI-ready (pyproject.toml + LICENSE + server.json included). If the package is not yet published, use the source install below.

From source (GitHub)

git clone https://github.com/ZMC1011/dsh-keil-mcp.git
cd ds-keil-mcp
python -m venv .venv
.venv/Scripts/activate                       # Windows
# source .venv/bin/activate                  # Linux / macOS
pip install -e ".[dev]"

Verify the install

# Environment self-check (UV4.exe, pyocd, connected probes)
python -m keil_mcp_server --check

# List all registered tools
python -m keil_mcp_server --tools

# Run the unit tests
pytest tests -q

Quick Start

# 1. Start the MCP server (stdio transport — the MCP client will spawn this)
python -m keil_mcp_server

# 2. In your MCP client, call e.g.:
#    keil_doctor
#    discover_keil_projects { directory: "D:/STM32Projects" }
#    configure_keil_project { project: "D:/STM32Projects/app/app.uvprojx" }
#    build_project { project: "...", target: "Target 1", stream_progress: true }
#    flash_firmware { project: "...", confirm: true }

MCP Client Configuration

DeepSeek Harness (DSH)

Per the official DSH MCP docs: one plugin instance = one MCP server, wired through the official bridge plugin @deepseek-ai/dsh-mcp-client. Add this to your profile's cordis.patch.yml (or cordis.yml):

- insert:
    - id: mcp-keil
      name: '@deepseek-ai/dsh-mcp-client'
      config:
        serverName: keil                 # tools appear as mcp__keil__build_project etc.
        transport: stdio
        command: D:/000_Environment/mcp-servers/ds-keil-mcp/.venv/Scripts/python.exe
        args: ['-m', 'keil_mcp_server']
        env:
          KEIL_UV4_PATH: D:/002_software/Keil5/UV4/UV4.exe
          KEIL_PROJECT_DIR: D:/STM32Projects
        # optional: toolCallTimeoutMs: 60000, failOnStartupError: false

Verify with:

dsh web --dump-config | grep -A3 mcp
# or check session logs for mcp__keil__* calls

Note: serverName must match [A-Za-z0-9_-]{1,32} and be unique among live instances.

Claude Desktop / other stdio MCP clients

Most MCP clients use the mcpServers JSON convention:

{
  "mcpServers": {
    "keil": {
      "command": "D:/000_Environment/mcp-servers/ds-keil-mcp/.venv/Scripts/python.exe",
      "args": ["-m", "keil_mcp_server"],
      "env": {
        "KEIL_UV4_PATH": "D:/002_software/Keil5/UV4/UV4.exe",
        "KEIL_PROJECT_DIR": "D:/STM32Projects"
      }
    }
  }
}

For a source checkout without a venv, uv also works:

{
  "mcpServers": {
    "keil": {
      "command": "uv",
      "args": ["--directory", "D:/path/to/ds-keil-mcp", "run", "keil_mcp_server"]
    }
  }
}

Tools

All 27 tools return structured JSON. Destructive operations (flash / erase) require confirm=True.

Build & Errors

Tool	Description	Key params → Result
`build_project`	Compile with UV4 `-b` (or `-r` rebuild / `-c` clean), realtime progress	`project`, `target?`, `timeout_seconds?`, `stream_progress?`, `clean?`, `rebuild?` → `{status, returncode, build_log, errors[], summary, progress?}`
`build_progress_status`	Query in-flight build progress	`build_id` → `{status, percent, current_file, phase}`
`build_cancel`	Request build cancellation	`build_id` → `{success}`
`parse_build_errors`	Parse UV4 log into structured errors	`log_path?` or `log_content?` → `{errors[], warnings[], summary}`
`explain_build_error`	Error code → explanation + causes + fixes	`error_code`, `message?`, `file?`, `line?` → `{explanation, common_causes[], suggested_fixes[]}`

Source Editing

Tool	Description	Key params → Result
`source_read`	Read source with line numbers	`file`, `start_line?`, `end_line?` → `{content, total_lines, ...}`
`source_edit`	Replace a line range; auto-backup first	`file`, `start_line`, `end_line`, `new_content` → `{success, lines_changed, backup_path}`
`source_search`	Search source files (text or regex)	`pattern`, `path?`, `files?`, `regex?` → `{matches[]}`

Official Debug Channel

Tool	Description	Key params → Result
`uv4_debug_session`	Run UV4 `-d` + generated `.ini` debug script (headless breakpoint/go/step)	`project`, `target?`, `ini_path?`, `breakpoint?`, `dump_vars?`, `timeout_seconds?` → `{success, returncode, output}`
`uv4_debug_dde`	Read session output by id	`session_id` → `{output}`

Project & Environment

Tool	Description	Key params → Result
`keil_doctor`	Environment check: UV4.exe, pyocd, packs, connected probes	— → `{uv4_exists, pyocd_installed, probes[], status}`
`discover_keil_projects`	Find `*.uvprojx` under a directory	`directory?`, `recursive?` → `{projects[]}`
`configure_keil_project`	Parse project: targets, device, pack, groups, source files	`project`, `target?` → `{targets[], device, pack_id, source_files[]}`

Flash

Tool	Description	Key params → Result
`flash_firmware`	Flash via UV4 `-f` (preferred) or pyOCD	`project?`, `image?`, `backend?`, `probe_id?`, `confirm` → `{success, log}`
`erase_flash`	Erase chip flash (pyOCD `erase -c`)	`confirm`, `probe_id?`, `chip?` → `{success, output}`
`verify_flash`	Verify chip against image (pyOCD `verify`)	`image`, `probe_id?` → `{success, output}`

Probe Debugging

Tool	Description
`probe_connect` / `probe_disconnect`	Connect / release a pyOCD probe (disconnect frees the port for UV4 `-f`)
`probe_halt` / `probe_resume` / `probe_step`	Core control
`set_breakpoint` / `continue_target`	Breakpoint by symbol or address, continue
`probe_read_registers`	Read r0-r15, sp, lr, pc, xpsr
`probe_read_memory`	Read memory at address (hex bytes)
`read_rtt_log`	Read SEGGER RTT output (if running)

Architecture

┌──────────────────────────────────────────────────────────────┐
│  MCP Client (DeepSeek Harness / Claude Desktop / ...)        │
│  → tools registered as mcp__keil__*                          │
└──────────────────────────────┬───────────────────────────────┘
                               │ stdio (JSON-RPC 2.0)
┌──────────────────────────────▼───────────────────────────────┐
│  keil-mcp-server (Python, FastMCP)                           │
│                                                              │
│  server.py   — tool registration + Execution Boundary        │
│                (read-only whitelist → concurrent;            │
│                 mutating tools → session lock +              │
│                 asyncio.to_thread + asyncio.shield)          │
│                                                              │
│  tools/      — MCP tool layer (27 tools)                     │
│                                                              │
│  core/       — deliverable layer                             │
│    uv4_runner.py      UV4 -b/-r/-c/-f/-d process runner      │
│    build_progress.py  realtime log tail monitor              │
│    error_parser.py    UV4 log → structured errors + KB       │
│    source_editor.py   read/edit/search + auto-backup         │
│    uv4_debug.py       UV4 -d + .ini script engine            │
│    probe_lease.py     per-probe exclusive lease              │
│    project_utils.py   .uvprojx parser (namespace-tolerant)   │
│                                                              │
│  models.py / config.py / config.yaml                         │
└───────────────┬──────────────────────────────┬───────────────┘
                │                              │
      ┌─────────▼─────────┐          ┌─────────▼─────────┐
      │ Keil MDK (UV4.exe)│          │ pyOCD + probe     │
      │ build/flash/debug │          │ ST-Link/J-Link/   │
      │                   │          │ CMSIS-DAP → chip  │
      └───────────────────┘          └───────────────────┘

Dependency direction: MCP layer → tools → core → Keil MDK / pyOCD → target chip.

Key design points:

Execution boundary (inspired by McuBuddy): read-only tools run concurrently; everything else serializes on a per-session asyncio.Lock, runs in a worker thread (asyncio.to_thread) and is cancellation-protected (asyncio.shield).
Probe lease: UV4 -f and pyOCD cannot share the debug port. ProbeLease (asyncio lock + filelock) serializes access; the flash flow disconnects pyOCD before UV4 takes over.
Realtime progress: a daemon thread tails the UV4 log, counting compiling lines against the source-file count parsed from .uvprojx (percent capped at 95% until the Build Time Elapsed marker).
Malformed-XML tolerance: older Keil projects contain mismatched tags (e.g. <b498tele498>...</bUseTDR>); the project parser repairs them before parsing.

Configuration

config.yaml (bundled) + environment variable overrides:

keil:
  uv4_path: "C:/Keil_v5/UV4/UV4.exe"        # or env KEIL_UV4_PATH
  default_project_dir: ""                   # or env KEIL_PROJECT_DIR
build:
  build_timeout: 300
  stream_progress: true
  tail_flush_wait: 3        # seconds to wait for UV4 log tail flush after exit
error:
  max_errors: 200
source:
  backup_dir: ".keil-mcp-backups"
probe_lease:
  lock_dir: ".keil-mcp-locks"
server:
  transport: "stdio"
  log_level: "INFO"

End-to-End Workflow Example

A typical agent session (tool names shown with DSH prefix mcp__keil__):

1. mcp__keil__keil_doctor                       # environment + probe OK?
2. mcp__keil__discover_keil_projects            # find .uvprojx files
3. mcp__keil__configure_keil_project            # parse targets/device/sources
4. mcp__keil__build_project (stream_progress)   # compile; on failure:
5. mcp__keil__parse_build_errors                # structured errors[]
6. mcp__keil__explain_build_error               # causes + fixes
7. mcp__keil__source_edit                       # fix code (auto-backup)
   → back to 4 until 0 errors
8. mcp__keil__flash_firmware (confirm=true)     # UV4 -f → "Verify OK"
9. mcp__keil__probe_connect + set_breakpoint    # attach debugger
10. mcp__keil__probe_read_registers / _memory   # observe chip state
11. mcp__keil__read_rtt_log                     # firmware logs
    → if logic bug found: source_edit → rebuild → reflash

Safety Rules

Level	Operations	Default
Read-only	chip match, register/memory/symbol reads, logs	no confirmation
Execute	halt / resume / step / reset	prompt
State write	memory/register writes, breakpoints, watchpoints	confirm
Persistent destructive	flash erase / programming	explicit confirm + recovery plan
Host process	Keil build, GDB server	prompt

Principles: gather evidence before acting; identify the target chip first; confirm target / range / image / recovery before flashing.

Testing

pytest tests -q        # 11 unit tests: log parsing, source editing, progress, project parsing

Manual smoke tests (in tests/):

python tests/raw_handshake.py    # bare JSON-RPC initialize + tools/list over stdio
python tests/func_test.py        # end-to-end tool calls through the MCP client SDK

Troubleshooting

Symptom	Cause / Fix
`Target DLL has been cancelled` on flash	pyOCD still owns the probe. Call `probe_disconnect` (or let the probe lease handle it) before `flash_firmware` with the UV4 backend.
`UV4.exe not found`	Set `KEIL_UV4_PATH` or `keil.uv4_path` in config; run `keil_doctor` to confirm.
`No module named keil_mcp_server`	The venv's editable install points at an old path — reinstall from the current checkout: `pip install -e .`
`No target connected`	Check probe wiring / driver; `keil_doctor` lists detected probes.
`pyocd pack install` needed	e.g. `pyocd pack install stm32f103c8` or point pyOCD at the Keil DFP folder.

Roadmap

Publish to PyPI and register in the MCP registry
MCUBUDDY_TOOLSETS-style domain toggles
ELF symbol resolution for set_breakpoint by name
RTOS task awareness (FreeRTOS)
GitHub Actions CI for unit tests
Linux/macOS support notes (Keil is Windows-only; pyOCD parts are cross-platform)

Contributing

Contributions are welcome! Please open an issue first to discuss changes, then submit a PR.

License

MIT — free to use, modify and distribute with attribution.

Available Tools

27 tools

build_cancelC

Request cancellation of a running build.

Inputs: build_id (required).

build_progress_statusB

Query the live progress of a running build.

Inputs: build_id (required).

build_projectA

Build a Keil project with UV4 -b (or -r rebuild / -c clean).

Args: project: path to .uvprojx (absolute or relative to default_project_dir) target: target name (default: first target in project) timeout_seconds: build timeout (default 120) stream_progress: tail the log for realtime progress (percent/phase) clean: run UV4 -c instead of -b rebuild: run UV4 -r (full rebuild) instead of -b Returns: {status: ok|error|canceled|not_found, returncode, build_log, errors[], summary, progress?}

Inputs: project (required), clean, target, rebuild, +2 more.

configure_keil_projectA

Parse a Keil project: targets, device, pack, groups, source files.

Use before building to pick the right target / confirm the device.

Inputs: project (required), target.

continue_targetB

Continue the target until the next breakpoint.

Inputs: probe_id.

discover_keil_projectsB

Discover *.uvprojx Keil projects under a directory.

Inputs: directory, recursive.

erase_flashA

Erase the target chip flash (pyocd erase -c). Requires confirm=True.

Inputs: chip, confirm, probe_id, timeout_seconds.

explain_build_errorB

Map a Keil/armclang error code to explanation, causes and fixes.

Inputs: error_code (required), file, line, message.

flash_firmwareA

Flash firmware to the target chip.

Preferred path: UV4 -f (Keil official flash download, uses the project's configured Flash algorithm). Fallback: pyocd load . Requires confirm=True (persistent destructive operation).

Args: project: .uvprojx path (for UV4 -f) — required unless image is given target: target name for UV4 -f image: firmware image (axf/hex/bin) for the pyocd path backend: "uv4" | "pyocd" | "auto" probe_id: pyOCD probe unique id (optional) confirm: MUST be True to actually flash

Inputs: project (required), image, target, backend, +3 more.

keil_doctorB

Check the Keil environment: UV4.exe, pyocd, packs, config.

Inputs: no named parameters.

keil_versionA

Return the keil5-mcp server version and available tool count.

Inputs: no named parameters.

parse_build_errorsA

Parse a UV4 build log into structured errors/warnings (blueprint §7.2).

Args: log_path: path to build log file, OR log_content: raw log text Returns: {errors[], warnings[], summary{success, errors, warnings, code_size, ...}}

Inputs: log_path, log_content.

probe_connectC

Connect to a debug probe via pyOCD (auto-detect or by unique id).

Inputs: chip, probe_id.

probe_disconnectA

Disconnect the probe (releases it for UV4 -f flash path).

Inputs: probe_id.

probe_haltC

Halt the target.

Inputs: probe_id.

probe_read_memoryC

Read memory at address (bytes).

Inputs: address (required), length, probe_id.

probe_read_registersB

Read core registers (r0-r15, xpsr, sp, lr, pc).

Inputs: probe_id.

probe_resumeC

Resume the target.

Inputs: probe_id.

probe_stepC

Single-step the target.

Inputs: probe_id.

read_rtt_logA

Read recent SEGGER RTT log output from the target (if RTT is running).

Inputs: probe_id, timeout_seconds.

set_breakpointC

Set a hardware breakpoint by symbol name or address.

Inputs: symbol, address, probe_id.

source_editA

Edit a source file; original is automatically backed up to .keil-mcp-backups/.

Args: file: path to source file start_line / end_line: 1-based inclusive line range to replace new_content: replacement text (can be multi-line)

Inputs: file (required), end_line (required), start_line (required), new_content (required).

source_readA

Read a source file with line numbers (auto backup not needed; read-only).

Inputs: file (required), end_line, start_line.

source_searchA

Search source files in the project directory.

Args: pattern: text or regex pattern path: directory to search (default: default_project_dir or cwd) files: optional explicit file list (relative to path) regex: treat pattern as a regular expression

Inputs: pattern (required), path, files, regex, +2 more.

uv4_debug_ddeC

Read the output of a UV4 -d debug session (session output channel).

Inputs: session_id (required).

uv4_debug_sessionA

Run an official Keil debug session via UV4 -d + a generated .ini script.

The debugger runs headless: sets a breakpoint, resets, runs, optionally steps, and prints variable values. Output is captured from the session log.

Args: project: path to .uvprojx target: target name (default first target) ini_path: custom .ini script path (overrides generated script) reset: reset target before running breakpoint: symbol/line to break at ("" = none) steps: extra single-step count after hitting the breakpoint dump_vars: variable names to print (e.g. ["i", "adc_value"]) timeout_seconds: session timeout

Inputs: project (required), reset, steps, target, +4 more.

verify_flashB

Verify firmware on chip against an image (pyocd verify).

Inputs: image (required), probe_id, timeout_seconds.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

TDQS

C2.9/5.0

Scored 2026-09-06 04:58 across 27 tools

Disambiguation4/5

Most tools target clearly distinct operations (build, source, flash, probe control), and the descriptions help separate them. Minor ambiguity exists between 'probe_resume' and 'continue_target' and between 'parse_build_errors' and 'explain_build_error', but these are usable with the provided docs.

Naming Consistency3/5

The majority follow a verb_noun pattern like 'build_project', 'source_edit', and 'probe_halt', but there are notable deviations such as 'uv4_debug_dde', 'keil_doctor', and 'build_progress_status'. Names are generally readable but the mixed styles prevent a higher score.

Tool Count2/5

With 27 tools, the server exceeds the 25+ threshold where tool count becomes heavy for an agent to navigate. The tools cover many subdomains, but several low-level probe primitives and debug-session helpers could be consolidated or omitted.

Completeness3/5

The server covers build, source editing, flashing, and basic debugging well. However, obvious lifecycle gaps exist: breakpoints can be set but not listed/deleted, memory/registers are read-only, and there is no standalone reset target operation or project creation/configuration update capability.

Maintenance

ActivityInactive

ResponsivenessLimited data

Resources

Related MCP Connectors

LabWired
io.github.w1ne
Design circuits, simulate and verify embedded firmware, and lay out PCBs with AI agents.
Embedded system Developer Tools Testing & QA Tools
190
https://api.labwired.com/mcp
Chiplab
ai.veecle
Run, build, and validate firmware on virtual hardware from your AI agent. Hardware knowledge corpus.
Embedded system Code Execution Virtualization
218
https://chiplab.veecle.ai/mcp
PAPI: Persistent Adaptive Project Intelligence
io.github.getpapi
Adaptive plan/build/review cycles for AI coding assistants, persisted across sessions.
Coding Agents Autonomous Agents
211
https://mcp.getpapi.ai/mcp
Power Automate MCP Server by Flow StudioA
io.github.ninihen1
Debug, build, and manage Power Automate cloud flows with AI agents
App Automation Workplace & Productivity Cloud Platforms
37235
https://mcp.flowstudio.app/mcp

Related MCP Servers

stmctl-mcp
Embedded system Command Line
Sathvik-smarttrak
A
license
A
quality
D
maintenance
Enables AI assistants to flash firmware, program memory, modify option bytes, erase chips, reset boards, and capture SWO printf traces for STM32 microcontrollers via STM32CubeCLT.
Updated 4 months ago (2026-07-30 13:32 UTC)
12
MIT
mcp-stm32cubeide-server
Embedded system Developer Tools
Helistana
A
license
Not graded
quality
D
maintenance
An MCP server that lets AI coding agents drive the full STM32 development loop—code generation, build, flash, debug, serial monitoring, and fault diagnosis—end to end via CubeIDE, CubeMX, CubeProgrammer, OpenOCD, and GDB.
Updated 3 months ago (2026-08-13 19:34 UTC)
1
MIT
stm32-mcp
Embedded system Developer Tools
irrumi
A
license
A
quality
B
maintenance
Enables AI coding assistants to perform complete headless STM32 embedded firmware development, including project creation, pin configuration, code generation, building, and flashing, by driving the official STM32 command-line toolchain.
Updated 2 months ago (2026-09-29 18:07 UTC)
4
9
MIT
keil-mdk-mcp
Embedded system Developer Tools
lideshengstu
A
license
C
quality
C
maintenance
Enables AI agents to build, flash, and debug STM32 projects compiled with Keil MDK-ARM on Windows, returning structured UV4 build diagnostics and evidence-based results. It also provides pyOCD/ST-Link debugging operations such as run control, breakpoints, register/PC reads, and global/static variable inspection.
Updated 19 days ago (2026-10-27 08:30 UTC)
29
MIT

Keil5 MCP Server

Table of Contents

Features

Requirements

Installation

From PyPI

From source (GitHub)

Verify the install

Quick Start

MCP Client Configuration

DeepSeek Harness (DSH)

Claude Desktop / other stdio MCP clients

Tools

Build & Errors

Source Editing

Official Debug Channel

Project & Environment

Flash

Probe Debugging

Architecture

Configuration

End-to-End Workflow Example

Safety Rules

Testing

Troubleshooting

Roadmap

Contributing

License

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

stmctl-mcp

mcp-stm32cubeide-server

stm32-mcp

keil-mdk-mcp