Skip to main content
Glama

serial-console-mcp

Project page: ae5vg.com/products/serial-console-mcp

AI for the configuration of telecommunication equipment, through the console port it already has.

build PyPI  MIT licensed  ·  Python 3.10+  ·  status: 0.3.2, verified live on a Juniper EX2200 console

serial-console-mcp connects an AI assistant such as Claude to the serial console of the equipment that runs networks and radio stations, and of anything else with a serial port:

  • Routers and switches. Juniper (Junos) and Cisco (IOS, IOS-XE) console and craft ports: log in, read state, change configuration with a safety net (commit confirmed on Junos, reload in on IOS), and leave the console as it was found.

  • Radio transceivers. Icom and Xiegu over CI-V; Kenwood, Yaesu and Elecraft over their text CAT protocols: identify the rig, read and set frequency and mode.

  • Antenna rotators. Yaesu GS-232 and the many controllers that speak it: read the heading, turn, stop.

  • Anything else with a serial port. Nothing is tied to telecom: the server talks raw bytes, cleans up ANSI output, or keeps a full VT100/xterm screen, so IoT gateways, alarm and access-control panels, UPS and PDU menus, lab instruments, industrial controllers, Linux and BIOS consoles and microcontrollers work too.

You say what you want in plain language. The assistant drives the console through this server, Claude Desktop asks you to approve each step, and bundled operating skills teach it the Junos and IOS basics: which mode a prompt means, how to get in and out, which show commands answer everyday questions.

Juniper support is verified on a real EX2200 console. Cisco, CI-V, CAT and rotator support follows the vendors' protocol references and has not yet met hardware on this bench. The other device types use the generic tools rather than device-specific helpers.

You do not need to know any programming. After it's installed you talk to Claude normally:

You: What serial ports do you see? Claude: I found two. One looks like a Silicon Labs CP210x on COM4 — that's probably your device.

You: Connect to COM4 at 9600 baud. Claude: Connected.

You: Log in and show me the version.

How it works (the important part)

A serial console isn't a simple question-and-answer channel. It echoes what you type, prints unsolicited messages on its own (logs, interface flaps), and can dump pages of output. So the moment a port is open, a background reader keeps draining it into a buffer. That means Claude can:

  • send a command (writes only — doesn't guess when the reply is done), then

  • read until a prompt appears (# , > , login: …) to capture the whole reply — even a long one — without cutting it off, or

  • read whatever's waiting for streaming/unsolicited output.

This is the same model minicom and expect use, which is why it handles interactive CLIs properly.

The tools

Tool

What it does

list_serial_ports

Enumerate ports with description and USB hardware id; marks ones open here

list_presets

Usual settings per device family: Cisco/Juniper/Linux consoles, full-screen consoles (BIOS, BMC, menus), Kenwood/Elecraft/Yaesu CAT, Icom and Xiegu CI-V, rotators, Arduino, NMEA GPS

connect / reconnect_last / disconnect

Open a port by name. Defaults 9600 8N1, no flow control; baud, data bits, parity, stop bits, RTS/CTS, XON/XOFF, line ending and prompt are all settable, or loaded from a preset. Several ports at once

send_keys / screen

Press Ctrl-C, Esc, Tab, arrows, F-keys by name; view the VT100/xterm screen of a full-screen console (BIOS, BMC, menu switches, vi)

send_text / send_hex

Write an ASCII line (CR / LF / CRLF / none) or raw hex bytes. Write-only

read_until_prompt

Return buffered output up to a literal or regex prompt, leaving the rest; auto_reply pages through --More--

read_available

Return whatever has arrived, as text and hex

query_text

Clear, send, then read until the prompt or until the line goes idle

expect

A scripted list of send-and-wait steps in one call: logins, command sequences

set_lines / pulse_line / send_break

Drive DTR and RTS (PTT, Arduino reset), send BREAK

capture_start / capture_stop / get_transcript

Log a session to a file (raw or timestamped TX/RX); re-read the rolling transcript

port_in_use_by / detect_baud

Which program holds a port; which baud rate produces readable text

cat_build / cat_parse

Kenwood, Elecraft and Yaesu ; commands: build a frequency set, decode ID, FA, MD, IF and error replies

civ_build / civ_parse / civ_freq

Icom CI-V frames: build, decode (echo vs reply, BCD frequency, mode, PTT), convert

rotator_build / rotator_parse

GS-232 rotator commands (read, move, stop, speed) and position replies

clear_buffer / status

Housekeeping; status shows every open port with control-line states

Ports are opened by name ("rig", "rotator"); tools default to the most recently used one. Each connection has a terminal mode: dumb (raw bytes, the default), ansi (colours and escape sequences stripped, CR/backspace overwrites applied, prompts matched on the line as displayed even after a device redraws it with spaces and backspaces; used by the console presets), or xterm/vt100 (a real screen you can read with screen; needs pip install 'serial-console-mcp[screen]', included in the desktop connector). The receive buffer is capped at 4 MB per port; if a device streams for hours unread, the oldest bytes are dropped and status says how many.

Operating skills

Three skill files in skills/ teach an agent the discipline. In the Claude desktop app, upload them as described under Add the operating skills; in Claude Code, copy them into ~/.claude/skills/ or a project's .claude/skills/:

Skill

What it teaches

serial-console

The console model, the six rules, terminal modes, keys, presets

junos-operating

Junos modes from the prompt (% shell, > operational, # configure), out of the BSD shell and back, configure exclusive, show | compare, commit confirmed, rollback, cli -c and start shell, health and interface show commands verified on an EX2200 (show chassis routing-engine, show interfaces terse/brief)

ios-operating

IOS modes (>, #, (config)#), enable/configure terminal/end, reload in 10 as the safety net, write memory, everyday show commands (show ip interface brief, show processes cpu sorted)

Environment variables

Variable

Effect

SERIAL_CONSOLE_READ_ONLY=1

Refuse writes except read-style commands (show, ID;, CI-V reads) and refuse control-line changes

SERIAL_CONSOLE_ALLOW=<regex>

Override the read-only allowlist

SERIAL_CONSOLE_IDLE_MINUTES=15

Auto-close a port idle that long (default: never)

Set them in the server's entry in claude_desktop_config.json under "env".

Related MCP server: MCP Remote Access

Installing

  1. Download serial-console-mcp.mcpb from the Releases page. The same file works on Mac, Windows and Linux.

  2. In Claude Desktop, open Settings → Desktop app, click Manage next to Extensions, and drag the file onto that page (or use Advanced settings → Install extension). It then shows as a connector under Settings → Customize → Connectors. A short settings form offers read-only mode and an idle timeout; both are off unless you turn them on.

  3. In a new chat, type: "What serial ports do you see?" If Claude lists your ports, you're done.

No terminal, no Python, nothing to configure by hand.

Upgrading from the 0.3.x .pkg or .exe installer? Remove the old copy first, or Claude Desktop starts two servers. On a Mac:

"/Library/Application Support/SerialConsoleMCP/serial-console-mcp" configure --remove
sudo rm -rf "/Library/Application Support/SerialConsoleMCP"

On Windows, uninstall Serial Console MCP under Settings → Apps. Then quit and reopen Claude Desktop.

Add the operating skills

The desktop connector installs only the server. Its operating skills are separate downloads: serial-console.skill, junos-operating.skill and ios-operating.skill, from the latest release or ae5vg.com/downloads.html. In Claude, open Customize → Skills, click Add, then Upload skill, and choose all the files at once.

For Claude Code or another MCP client, copy the folders under skills/ into the client's skills folder, for Claude Code ~/.claude/skills/.

To run the server itself in Claude Code, Codex, Cursor or VS Code, see Other AI assistants for the command or configuration block to copy.

Installing from PyPI

If you already have Python 3.10+ and uv or pipx, you can skip the desktop connector:

uvx serial-console-mcp --version                                   # fetches and runs it
uvx serial-console-mcp configure --command uvx --arg serial-console-mcp

or

pipx install serial-console-mcp
serial-console-mcp configure --command "$(which serial-console-mcp)"

configure writes a serial-console entry into claude_desktop_config.json (merging with whatever is already there and backing the old file up first). Quit and reopen Claude Desktop. serial-console-mcp configure --remove undoes it. Any other MCP client can launch the same command over stdio.

Installing from source (developers)

git clone https://github.com/sbrunner-atx/serial-console-mcp.git
cd serial-console-mcp
uv sync                       # or: python3 -m venv .venv && . .venv/bin/activate && pip install -e . pytest
uv run pytest                 # fake serial port, no hardware needed
uv run serial-console-mcp configure --command "$PWD/.venv/bin/serial-console-mcp"

The package lives in src/serial_console_mcp/: server.py is the MCP server, configure.py the Claude Desktop registrar. manifest.json describes the desktop extension; npx @anthropic-ai/mcpb pack builds it. BUILD.md covers the retired .pkg and .exe installers.

Using it

Plain-English requests work. Some examples:

  • "List my serial ports."

  • "Connect to the console on /dev/cu.usbserial-10 at 9600 baud."

  • "Connect to /dev/cu.BLTH at 38400, 8 data bits, no parity, 1 stop bit, XON/XOFF flow control."

  • "Connect to the Kenwood with the kenwood-cat preset and call it rig; connect the rotator on the other port."

  • "Log in as admin and run show version" (one expect call: return, login, password, command).

  • "What baud rate is this thing?" (detect_baud).

  • "Key the rig for two seconds" (pulse_line("RTS", 2000), after you confirm).

  • "Ask the IC-7300 for its frequency" (civ_build, send_hex, read_available, civ_parse).

  • "What is the TS-590 tuned to?" (query_text("FA;"), cat_parse).

  • "Turn the rotator to 45 degrees and confirm" (rotator_build, query_text, rotator_parse).

  • "Record this console session to a file."

  • "Hit Ctrl-C, that ping is still running." (send_keys)

  • "Open the BIOS console at 115200 and show me the screen; go down two and press Enter." (screen-console preset, screen, send_keys)

  • "Reconnect to the same port as last time." (it remembers)

  • "Send a return, then read until the login prompt."

  • "Log in as admin and run show interfaces terse, then show me all of it."

  • "Just read whatever the device is printing right now."

  • "Disconnect when you're done."

For a router/switch console, tell Claude the prompt it should wait for (often # for enable mode or > for user mode) and it will read until it sees it. For an Icom radio (CI-V), tell Claude — it can send the hex commands those radios expect.

If something doesn't work

"No serial ports found."

  • Is the device turned on?

  • Is the USB cable a real data cable, not a charge-only one? (A very common gotcha.)

  • On Windows, open Device Manager and look under Ports (COM & LPT). If nothing's there, Windows needs the cable's driver (often FTDI, CP210x, or CH340).

"Could not open the port" / "access denied."

  • A serial port can only be used by one program at a time. Close anything else that might be holding it: a terminal (PuTTY/minicom/screen), WSJT-X, your contest logger, the device's own software.

Claude says it can't access serial ports at all.

  • Make sure you fully quit and reopened Claude Desktop after installing.

  • Start a brand-new chat and ask "What serial ports do you see?" again.

It connected but a command gets no reply.

  • Almost always the baud rate is wrong, or the line ending is wrong for your gear. Most Unix-style consoles want a plain newline (LF); most rigs want a carriage return (CR). Ask Claude to send a return first to draw a fresh prompt.

A word on safety

These tools send exactly what you (through Claude) ask them to send, to whatever device is on the cable. Claude Desktop asks you to approve each tool call, so you see every command before it runs. Read it. A console session on a router or a rig can reconfigure, reboot, or transmit, and this server does not try to guess which commands are dangerous. If something looks wrong, decline it, and keep a real terminal handy for anything you would not want an assistant to type.

License

MIT. See LICENSE.

73!

Available Tools

30 tools
capture_startA

Start writing this connection's traffic to a file until capture_stop.

Args: path: File to write. Empty = an auto-named file in the app's captures folder. A bare name goes in that folder; an absolute path is used as is. Existing files are appended to. format: "raw" writes received bytes exactly as they arrive (a terminal log; echo included). "annotated" writes timestamped lines marked TX or RX, which is better for protocol debugging. connection: Which open connection (name). Default: the current one.

Inputs: path, format, connection. Returns: result

capture_stopA

Stop the capture started by capture_start and report the file and size.

Inputs: connection. Returns: result

cat_buildA

Build a ';'-terminated text CAT command (Kenwood, Elecraft, Yaesu) for query_text or send_text with line_ending="NONE".

Common commands: ID (rig id), FA/FB (VFO A/B frequency; empty value = read), MD (mode; read, or set with the family's code), IF (full status), PS (power), TX/RX, AI0 (silence auto-info), SM0 (S-meter), PC (output power).

Args: command: Two letters, e.g. "FA". value: Digits/letters to append for a set, e.g. "2" for MD2 (USB). Empty = read. frequency_mhz: For FA/FB sets: the frequency; formatted as 11 digits of Hz (Kenwood/Elecraft) or 9 (Yaesu). flavor: Which family's conventions: "kenwood" (default), "elecraft", "yaesu".

Inputs: command (required), value, flavor, frequency_mhz. Returns: result

cat_parseA

Decode ';'-terminated text CAT replies: rig id to model, FA/FB to MHz, MD to mode name, IF to frequency/mode/VFO/split/TX state, and the ?; E; O; error answers. Pass the text returned by query_text.

Inputs: reply (required), flavor. Returns: result

civ_buildA

Build an Icom CI-V frame as hex, ready for send_hex.

Args: command: Command byte(s) as hex, e.g. "03" read frequency, "04" read mode, "05" set frequency, "06" set mode, "1C 00" PTT, "19 00" read rig address. data: Data bytes as hex. For frequencies use civ_freq: set 14.070 MHz is command "05" with data "00 00 07 14 00" (BCD, low byte first). rig: The rig's CI-V address (IC-7300 94, IC-7610 98, IC-9700 A2, IC-705 A4). controller: Our address, conventionally E0.

Inputs: command (required), rig, data, controller. Returns: result

civ_freqA

Convert between a frequency in MHz and CI-V BCD data bytes.

Give mhz to get the 5 data bytes for a set-frequency command (05), or bcd_hex (5 bytes from a reply) to get the frequency.

Inputs: mhz, bcd_hex. Returns: result

civ_parseA

Decode Icom CI-V frames from hex (as returned by read_available).

Splits the bytes into frames, tells our own echoed command apart from the rig's reply, and decodes frequencies (BCD), modes, OK/NG and PTT state.

Inputs: hex_bytes (required), controller. Returns: result

clear_bufferA

Discard any buffered received data. Handy right before sending a command so the next read starts clean (drops old echo, prior output, or syslog noise).

Inputs: connection. Returns: result

connectA

Open a serial port and start its background reader.

Defaults are 9600 baud, 8 data bits, no parity, 1 stop bit, no flow control ("9600 8N1"), CR line ending, which is what most console/craft ports expect. Give preset (see list_presets) to load a device family's usual settings, and override any field explicitly, e.g. "38400 with XON/XOFF" -> baud=38400, xonxoff=True. Several ports can be open at once; each gets a name and later tools default to the most recently used one. Nothing is specific to telecom gear: any device on a serial port works, including IoT gateways, alarm and control panels, UPS and PDU menus and lab instruments; choose terminal by what the device prints.

Args: port: System port name, e.g. "COM4" (Windows), "/dev/cu.usbserial-10" (macOS), or "/dev/ttyUSB0" (Linux). Get exact names from list_serial_ports. preset: Device preset name such as "cisco-console", "juniper-craft", "kenwood-cat", "icom-civ", "yaesu-rotator", "arduino", "nmea-gps". name: Nickname for this connection ("rig", "rotator"). Defaults to the port's short name. Use it in other tools' connection argument. baud: Baud rate. Common values: 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200. Unknown? Use detect_baud first. bytesize: Data bits: 5, 6, 7, or 8. Almost always 8. parity: "N" none, "E" even, "O" odd. Almost always "N". stopbits: 1, 1.5, or 2. Almost always 1. rtscts: Hardware (RTS/CTS) flow control. Off unless the manual says so and the cable carries those lines. xonxoff: Software (XON/XOFF) flow control. Off by default. Never for binary protocols (it swallows 0x11 / 0x13 bytes). line_ending: Default line ending for send_text/query_text on this connection: "CR" (most rigs, consoles), "LF" (Unix, Arduino), "CRLF", or "NONE" (Kenwood-style CAT ending in ';'). prompt: Default prompt for read_until_prompt/query_text on this connection, e.g. "# ", "> ", ";" (CAT replies). Say what the device shows, with its trailing space. prompt_regex: Treat prompt as a regular expression. terminal: How to interpret what the device sends. "dumb" (default): raw bytes, right for CAT, CI-V, rotators and most CLIs. "ansi": strip colour/escape sequences and apply CR/backspace overwrites so shells and coloured prompts read cleanly (the console presets use it); prompts are also matched on the last line as displayed, so a line redrawn with spaces and backspaces (Junos after ? or Ctrl-U) still ends in its prompt. "vt100"/"xterm": additionally keep a real screen for full-screen menus, BIOS/BMC consoles, vi/top; read it with the screen tool, navigate with send_keys. cols: Screen width for vt100/xterm (default 80). rows: Screen height for vt100/xterm (default 24).

Inputs: port (required), baud, cols, name, +11 more. Returns: result

detect_baudA

Try common baud rates on a closed port and rank them by how readable the reply is. Use when the user doesn't know the device's rate.

Each candidate is opened briefly, probe (default: a bare return) is sent, and whatever comes back is scored by its share of printable text. The right rate yields clean text; wrong rates yield garbage or nothing. Note: opening a port resets many Arduinos (DTR), and some devices (Kenwood CAT) only answer a real command, so pass e.g. probe="ID;" with probe_line_ending="NONE".

Args: port: The port to probe (must not be open here). probe: Text to send at each rate. Empty sends only the line ending. probe_line_ending: Line ending appended to the probe ("NONE" for CAT). candidates: Rates to try. Default: 9600, 115200, 19200, 38400, 57600, 4800, 2400, 1200, 230400. settle: Seconds to wait for a reply at each rate.

Inputs: port (required), probe, settle, candidates, +1 more. Returns: result

disconnectA

Close a serial port and free it for other programs.

Args: connection: Which connection to close (name from connect). Default: the current one. all_connections: Close every open port.

Inputs: connection, all_connections. Returns: result

expectA

Run a scripted sequence of send-and-wait steps in one call, like expect.

Use it for login flows and multi-step commands instead of one tool call per line: [{send: "", expect: "login: "}, {send: "admin", expect: "Password:"}, {send: "", expect: "> "}, {send: "show version", expect: "> "}]. Each step's output is returned. A step with no send just waits; one with no expect just sends.

Args: steps: The steps, in order. auto_reply: Triggers answered automatically while waiting, e.g. {"--More--": " "}. stop_on_timeout: Stop at the first step whose expect isn't seen. connection: Which open connection (name). Default: the current one.

Inputs: steps (required), auto_reply, connection, stop_on_timeout. Returns: result

get_transcriptA

Return the tail of everything received on a connection since it was opened.

This is a rolling record (last 256 KB) kept regardless of what the read tools consumed, so you can re-read output that an earlier call already returned or that arrived between calls. Also available as the MCP resource serial://transcript/{name}.

Inputs: connection, last_bytes. Returns: result

list_presetsA

Show the device presets connect(preset=...) understands, with their settings.

A preset supplies baud, data bits, parity, stop bits, flow control, the line ending the device expects, and the prompt that ends a reply. Anything you pass explicitly to connect overrides the preset. Families: network consoles (Cisco, Juniper, Linux), text CAT radios (Kenwood, Elecraft, Yaesu), Icom CI-V, rotators, Arduino, NMEA GPS.

Inputs: no named parameters. Returns: result

list_serial_portsA

List every serial port the computer can currently see.

Call this FIRST whenever the user wants to connect to a device but hasn't given an exact port name, or when a connection fails. Returns each port's system name (what you pass to connect), a human description, and the USB hardware id, so you can guess which one is the user's gear. Ports already open here are marked.

Inputs: no named parameters. Returns: result

port_in_use_byA

Report which program currently holds a serial port (macOS/Linux, via lsof).

Use when connect says the port is in use, or before asking the user to close something. On Windows the OS doesn't expose this; the usual suspects are a terminal (PuTTY), WSJT-X, a logger, or the Arduino Serial Monitor.

Inputs: port (required). Returns: result

pulse_lineA

Drive DTR or RTS to level for ms milliseconds, then restore it.

Uses: reset an Arduino (DTR, 100 ms), enter a bootloader, or key a rig's PTT for a timed transmission (RTS or DTR per the interface's wiring). The line is always restored, even if the wait is interrupted. Refused in read-only mode.

Inputs: line (required), ms, level, connection. Returns: result

query_textA

Convenience: clear the buffer, send an ASCII command, and read the reply.

For the common "ask the device something and read its answer" case. Reads until prompt (or the connection's prompt) appears; with no prompt anywhere, or prompt="", reads until the device goes idle for a short beat (best for line-based rigs/CAT that reply with a terminated string and no shell prompt).

Args: data: Command text, e.g. "show version" or "ID". line_ending: "CR", "CRLF", "LF", or "NONE" (see send_text). Default: the connection's line ending. prompt: Literal prompt to read until, e.g. "# " or ";". "" forces an idle-terminated read even if the connection has a prompt. read_timeout: How long to wait overall, in seconds. connection: Which open connection (name). Default: the current one.

Inputs: data (required), prompt, connection, line_ending, +1 more. Returns: result

read_availableA

Drain and return whatever the device has sent, without transmitting anything.

Use for unsolicited/streaming output (syslog on a console, GPS, a sensor, a rig in auto-info mode), or to grab a binary reply after send_hex. Waits up to read_timeout for the first bytes, then briefly settles so a full chunk is captured, then returns everything buffered, as text and as hex.

Inputs: connection, read_timeout. Returns: result

read_until_promptA

Read accumulated output until a prompt appears, or until timeout.

This is the right tool for interactive CLI sessions (routers, switches, shells). It reads from the background buffer until prompt is seen, then returns everything up to and including it, leaving anything after the prompt in the buffer for the next read. Because the reader runs continuously, large multi-page outputs are captured in full rather than being cut off by a fixed delay.

Typical flow: send_text("show version", clear_buffer_first=True) read_until_prompt(prompt="# ")

Args: prompt: The text that marks the end of output. Literal by default, e.g. "# ", "> ", "login: ", "$ ", "Password:". Prefer a prompt with its trailing space over a bare "#": the match is searched in everything received, including the echo of your own command. Default: the connection's prompt (from connect/preset), else "ends with #, >, $ or %". timeout: Max seconds to wait for the prompt to appear. regex: Treat prompt as a Python regular expression (e.g. r"[\w.-]+[#>] ?$" for a hostname-style prompt). auto_reply: Text to send automatically when a trigger shows up while waiting, e.g. {"--More--": " "} to page through long output, or {"[confirm]": "\r"}. Each occurrence is answered once. connection: Which open connection (name). Default: the current one.

Inputs: regex, prompt, timeout, auto_reply, +1 more. Returns: result

reconnect_lastA

Reconnect to a remembered port with the same settings as last time.

Every successful connect is remembered by name across sessions (port, baud, flow control, line ending, prompt, preset). With no name, reopens the most recently used one. Handy at the start of a chat so the user doesn't repeat the port and baud rate. If nothing is remembered, says to use connect instead.

Inputs: name. Returns: result

rotator_buildA

Build a Yaesu GS-232A/B rotator command for send_text (CR) or query_text.

Actions: "azimuth" (C, read), "position" (C2, read az+el), "elevation" (B), "move" (M), "move_azel" (W ), "stop"/"stop_azimuth"/ "stop_elevation", "left"/"right"/"up"/"down" (run until stop), "speed" (X1..X4), "help". Reads reply immediately; moves reply nothing, so read the position afterwards to confirm.

Inputs: action (required), speed, azimuth, elevation. Returns: result

rotator_parseA

Decode a GS-232 reply into azimuth/elevation degrees ("+0180", "+0180+0045", "AZ=180 EL=045") or the ?> rejection.

Inputs: reply (required). Returns: result

screenA

Show the current terminal screen of a vt100/xterm connection: what a person at a real terminal would see right now, as rows of text, plus the cursor position. This is how to read full-screen interfaces (BIOS setup, RAID/BMC consoles, menu-driven switches, vi, top): press keys with send_keys, then look at the screen again.

Args: reset: Clear the screen model first (after garbage, or a resize). connection: Which open connection (name). Default: the current one.

Inputs: reset, connection. Returns: result

send_breakA

Send a BREAK condition (TX held low) for ms milliseconds.

Some consoles use BREAK to enter ROMMON or interrupt boot; some serial devices use it as an attention signal. Refused in read-only mode.

Inputs: ms, connection. Returns: result

send_hexA

Send raw bytes given as hex. Writes to TX only; does NOT read.

Use for binary protocols — notably Icom CI-V, which is all hex (e.g. "FE FE 94 E0 03 FD"; civ_build makes these). Spaces in the hex string are ignored. To see a binary reply, call read_available afterward and hand the hex to civ_parse (binary replies rarely have a text prompt, so read_until_prompt usually isn't the right tool for these).

Args: hex_bytes: Bytes as hex, e.g. "FE FE 94 E0 03 FD". clear_buffer_first: Discard buffered RX before sending. connection: Which open connection (name). Default: the current one.

Inputs: hex_bytes (required), connection, clear_buffer_first. Returns: result

send_keysA

Press keys by name, encoded the way a VT100/xterm terminal sends them.

Use it for what send_text can't type: Ctrl-C to interrupt a running command (ping, monitor, a stuck process), Ctrl-Z, Esc, Tab (completion), arrows (history, menus), Enter alone, function keys, Page Up/Down. Each item is a key name ("ctrl-c", "esc", "tab", "enter", "up", "down", "left", "right", "home", "end", "pgup", "pgdn", "backspace", "delete", "f1".."f12", "space"), a single character, or "text:..." for a literal run. Nothing is read; follow with read_until_prompt, read_available, or screen.

Inputs: keys (required), connection. Returns: result

send_textA

Send an ASCII command to the device. Writes to TX only; does NOT read.

On an interactive console the device will ECHO this text back and then print its output; call read_until_prompt (or read_available) afterward to see it. Use clear_buffer_first=True to discard any stale/unsolicited output so the next read starts clean.

Args: data: The command text, e.g. "show version", "FA014250000", or "ID". Non-ASCII characters are sent as "?"; use send_hex for raw bytes. line_ending: What to append — "CR" (\r, most rigs), "CRLF" (\r\n), "LF" (\n, most Unix-style consoles), or "NONE". Default: the connection's line ending (from connect or its preset). clear_buffer_first: Discard buffered RX before sending. connection: Which open connection (name). Default: the current one.

Inputs: data (required), connection, line_ending, clear_buffer_first. Returns: result

set_linesA

Set the DTR and/or RTS output lines and hold them.

Uses: key a transmitter whose PTT is wired to RTS or DTR (set it True to transmit, False to stop; pulse_line is safer for that), hold an Arduino in reset (DTR False), or tell a modem you're present. Leave a line at None to keep it unchanged. Refused in read-only mode.

Inputs: dtr, rts, connection. Returns: result

statusA

Report every open port: settings, reader state, buffered bytes, control-line states, capture, and which connection is current. With nothing open, lists what reconnect_last remembers.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 30 tools

    Disambiguation5/5

    Each tool targets a distinct operation: connection management, data sending/receiving, key presses, line control, capture, and protocol-specific build/parse helpers. Even closely related tools like send_text, send_hex, and query_text have clear boundaries (send-only vs. send+read), and read_until_prompt, read_available, screen, and get_transcript serve different reading modes.

    Naming Consistency4/5

    Names are mostly snake_case and follow a verb-first pattern (list_serial_ports, clear_buffer, read_available, capture_start). A few exceptions exist: 'status' and 'screen' are bare nouns, 'reconnect_last' uses an adverb, and 'port_in_use_by' is a noun phrase, but these are still understandable and don't undermine predictability.

    Tool Count3/5

    At 30 tools, the server is on the heavier side and exceeds the 15-tool sweet spot. However, the count is justified by the broad domain: general serial I/O, terminal emulation, line control, capture, and three separate radio/rotator protocol families each have dedicated builders/parsers. It's borderline but each tool serves a concrete purpose.

    Completeness5/5

    The tool surface thoroughly covers serial console workflows: discovery, connection, reconnection, baud detection, text/hex/key input, multiple read modalities, prompt-based reading, scripting, line control, break, capture, transcript access, and port conflict checks. The protocol helpers for CI-V, CAT, and rotators are complete with build/parse and frequency conversion, leaving no obvious dead ends.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Enables AI assistants to communicate with serial port devices, supporting port management, data transmission in text/binary modes, interactive terminal sessions, and automatic reconnection.
      14
      12
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables SSH and UART/serial port access for Claude Code to directly control remote devices like Raspberry Pi, embedded systems, and IoT devices. Supports command execution, file transfers via SFTP, and serial communication.
      24
      2
      AGPL 3.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI tools like Claude Code and Codex CLI to read and write serial port data, facilitating embedded development workflows such as coding, flashing, and debugging.
      32 npm
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Enables AI agents to control serial port devices (modems, instruments, embedded boards) via MCP tools for listing ports, connecting, and sending/receiving commands.
      3
      1
      MIT