sigrok MCP Server

io.github.KenosIncPublished by GitHub account KenosIncv0.2.0Updated Oct 24, 2026

Wraps sigrok-cli for signal analysis: capture data, decode protocols, and query instruments.

VerifiedSTDIODesktop onlyDeveloper ToolsSecurity & Monitoring

Overview

AI-generated overview

A local MCP server that wraps sigrok-cli so an assistant can capture, decode and analyze signals from logic analyzers and measurement devices.

What you can do
List supported hardware drivers, protocol decoders, input and output formats, and show sigrok-cli version information. Show details of a protocol decoder or hardware driver, including options, channels and documentation. Scan for connected hardware devices and check firmware availability. Capture communication data from a device and save it to a file. Decode captured data with protocol decoders such as I2C, SPI, UART and CAN.
When to use it
Useful when you work with logic analyzers or measurement hardware and want an assistant to discover devices, capture bus traffic and decode protocols like I2C, SPI, UART or CAN, then explain the results. Also handy for protocol-only analysis of existing capture files.
Requirements
Runs as a local stdio process, typically from the published container image or built from source with Go 1.25+. Requires sigrok-cli installed and reachable, configured via SIGROK_CLI_PATH, SIGROK_TIMEOUT_SECONDS and SIGROK_WORKING_DIR. USB device access from a container needs privileged mode; devices needing firmware require a mounted firmware directory.
Before you install
Capture writes data to files on the machine. Container setups for USB access use privileged mode, which grants broad host access. Some hardware drivers need firmware files that are not bundled and must be obtained separately. No authentication is declared, so anyone who can start the process can drive the attached hardware.

Installation

In SourceWeft

  1. Open sigrok MCP Server in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

sigrok-mcp-server

[CI] [Go Version] [License: MIT] [GitHub Release]

A Model Context Protocol (MCP) server for sigrok — enables AI agents like Claude Code, Codex, and Cursor to capture, decode, and analyze signals from logic analyzers and measurement devices. Supports I2C, SPI, UART, CAN, and 100+ protocols via sigrok-cli.

Documentation | Getting Started

Tools

ToolDescription
list_supported_hardwareList all supported hardware drivers
list_supported_decodersList all supported protocol decoders
list_input_formatsList all supported input file formats
list_output_formatsList all supported output file formats
show_decoder_detailsShow detailed info about a protocol decoder (options, channels, documentation)
show_driver_detailsShow detailed info about a hardware driver (functions, scan options, devices)
show_versionShow sigrok-cli and library version information
scan_devicesScan for connected hardware devices
capture_dataCapture communication data from a device and save to file
decode_protocolDecode protocol data from a captured file using protocol decoders
check_firmware_statusCheck firmware file availability in sigrok firmware directories

Quickstart

Docker

bash
docker pull ghcr.io/kenosinc/sigrok-mcp-serverdocker run -i ghcr.io/kenosinc/sigrok-mcp-server

From source

Requires Go 1.25+ and sigrok-cli installed on your system.

bash
go build -o sigrok-mcp-server ./cmd/sigrok-mcp-server./sigrok-mcp-server

The server communicates over stdio (stdin/stdout JSON-RPC).

Configuration

Configuration is via environment variables:

VariableDefaultDescription
SIGROK_CLI_PATHsigrok-cliPath to the sigrok-cli binary
SIGROK_TIMEOUT_SECONDS30Command execution timeout in seconds
SIGROK_WORKING_DIR(empty)Working directory for sigrok-cli execution

MCP Client Configuration

Claude Desktop

Add to your claude_desktop_config.json:

json
{  "mcpServers": {    "sigrok": {      "command": "docker",      "args": ["run", "-i", "--rm", "ghcr.io/kenosinc/sigrok-mcp-server"]    }  }}

To access USB devices from the container:

json
{  "mcpServers": {    "sigrok": {      "command": "docker",      "args": ["run", "-i", "--rm", "--privileged", "ghcr.io/kenosinc/sigrok-mcp-server"]    }  }}

To also provide firmware files for devices that require them (e.g. Kingst LA2016):

json
{  "mcpServers": {    "sigrok": {      "command": "docker",      "args": [        "run", "-i", "--rm", "--privileged",        "-v", "/path/to/sigrok-firmware:/usr/local/share/sigrok-firmware:ro",        "ghcr.io/kenosinc/sigrok-mcp-server"      ]    }  }}

Claude Code

bash
claude mcp add sigrok -- docker run -i --rm ghcr.io/kenosinc/sigrok-mcp-server

With USB access and firmware:

bash
claude mcp add sigrok -- docker run -i --rm --privileged -v /path/to/sigrok-firmware:/usr/local/share/sigrok-firmware:ro ghcr.io/kenosinc/sigrok-mcp-server

Firmware

Some hardware drivers require firmware files that cannot be bundled with this server due to licensing restrictions. The server works without firmware for devices that don't need it (e.g. demo, protocol-only analysis). For devices that require firmware (e.g. Kingst LA2016, Saleae Logic16), mount your firmware directory into the container at /usr/local/share/sigrok-firmware.

Use the check_firmware_status tool to verify firmware availability and diagnose device detection issues.

See the sigrok wiki for firmware extraction instructions for your device.

Architecture

MCP Client (LLM)    |  stdio (JSON-RPC)    vsigrok-mcp-server (Go)    |  exec.Command    vsigrok-cli    |    vlibsigrok / libsigrokdecode
  • Transport: stdio (stdin/stdout JSON-RPC)
  • No C bindings: sigrok-cli is the sole interface to sigrok
  • Capture & decode: capture_data acquires data from devices; all other tools are read-only queries
  • Structured output: Raw sigrok-cli text output is parsed into JSON

Workflow Example

A typical signal analysis workflow using Claude:

  1. scan_devices — Discover connected hardware
  2. show_driver_details — Check driver capabilities
  3. capture_data — Capture communication data to file
  4. decode_protocol — Decode captured data with protocol decoders
  5. Claude analyzes the decoded output and explains the communication

Development

bash
# Buildgo build ./...
# Testgo test ./... -race
# Lintgolangci-lint run ./...

Project Structure

cmd/sigrok-mcp-server/     Entry pointinternal/  config/                  Environment-based configuration  sigrok/    executor.go            sigrok-cli command execution with timeout    parser.go              Output parsing (list, decoder, driver, version, scan)    testdata/              Real sigrok-cli output fixtures  tools/    tools.go               MCP tool definitions and registration    handlers.go            Tool handler implementations

License

MIT (Kenos, Inc.)

Source: README.md at commit 71a652d

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v0.2.0LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts