io.github.KenosInc/sigrok-mcp-server

Official

by KenosInc · Go

sigrok MCP Server

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

Captures and analyzes signal data, decodes protocols, and queries instruments.

Topics

logic-analyzermcp-serverprotocol-decodersigroksigrok-clihardware-debuggingmcpai-agentembedded-systemshardware-automationiot

README.md6 KBView on GitHub

sigrok-mcp-server

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

Tool	Description
`list_supported_hardware`	List all supported hardware drivers
`list_supported_decoders`	List all supported protocol decoders
`list_input_formats`	List all supported input file formats
`list_output_formats`	List all supported output file formats
`show_decoder_details`	Show detailed info about a protocol decoder (options, channels, documentation)
`show_driver_details`	Show detailed info about a hardware driver (functions, scan options, devices)
`show_version`	Show sigrok-cli and library version information
`scan_devices`	Scan for connected hardware devices
`capture_data`	Capture communication data from a device and save to file
`decode_protocol`	Decode protocol data from a captured file using protocol decoders
`check_firmware_status`	Check firmware file availability in sigrok firmware directories

Quickstart

Docker

bash

docker pull ghcr.io/kenosinc/sigrok-mcp-server
docker 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:

Variable	Default	Description
`SIGROK_CLI_PATH`	`sigrok-cli`	Path to the sigrok-cli binary
`SIGROK_TIMEOUT_SECONDS`	`30`	Command 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

code

MCP Client (LLM)
    |  stdio (JSON-RPC)
    v
sigrok-mcp-server (Go)
    |  exec.Command
    v
sigrok-cli
    |
    v
libsigrok / 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:

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

Development

bash

# Build
go build ./...

# Test
go test ./... -race

# Lint
golangci-lint run ./...

Project Structure

code

cmd/sigrok-mcp-server/     Entry point
internal/
  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.)

Install

Configuration

Environment variables

SIGROK_CLI_PATH

Path to sigrok-cli binary

SIGROK_TIMEOUT_SECONDS

Command execution timeout in seconds

SIGROK_WORKING_DIR

Working directory for sigrok-cli execution

claude_desktop_config.json

{
  "mcpServers": {
    "sigrok-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "ghcr.io/kenosinc/sigrok-mcp-server:0.2.0"
      ],
      "env": {
        "SIGROK_CLI_PATH": "<YOUR_SIGROK_CLI_PATH>",
        "SIGROK_TIMEOUT_SECONDS": "<YOUR_SIGROK_TIMEOUT_SECONDS>",
        "SIGROK_WORKING_DIR": "<YOUR_SIGROK_WORKING_DIR>"
      }
    }
  }
}