serial-console-mcp
serial-console-mcp lets an AI assistant discover, connect to, and interact with serial-port devices through MCP tools.
List serial ports and presets, connect/reconnect/disconnect, and inspect connection status.
Send text, hex bytes, and special keys; read output until prompts or stream available data.
Run scripted
expectsequences for logins and multi-step command flows.Interact with interactive consoles, raw serial devices, and full-screen VT100/xterm interfaces.
Drive DTR/RTS lines, pulse PTT/reset, send BREAK, detect baud rates, and check port ownership.
Capture sessions and retrieve rolling transcripts.
Build/parse protocol helpers for Icom CI-V, Kenwood/Elecraft/Yaesu CAT, and Yaesu GS-232 rotators.
Support read-only mode, write allowlists, and idle timeouts for safer operation.
Allows connecting to and interacting with Cisco devices through their serial console/craft port, including sending commands, reading output up to a prompt, and handling interactive CLI sessions.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@serial-console-mcp What serial ports do you see?"
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.
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.
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 confirmedon Junos,reload inon 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, orread 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 |
| Enumerate ports with description and USB hardware id; marks ones open here |
| 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 |
| 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 |
| 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) |
| Write an ASCII line (CR / LF / CRLF / none) or raw hex bytes. Write-only |
| Return buffered output up to a literal or regex prompt, leaving the rest; |
| Return whatever has arrived, as text and hex |
| Clear, send, then read until the prompt or until the line goes idle |
| A scripted list of send-and-wait steps in one call: logins, command sequences |
| Drive DTR and RTS (PTT, Arduino reset), send BREAK |
| Log a session to a file (raw or timestamped TX/RX); re-read the rolling transcript |
| Which program holds a port; which baud rate produces readable text |
| Kenwood, Elecraft and Yaesu |
| Icom CI-V frames: build, decode (echo vs reply, BCD frequency, mode, PTT), convert |
| GS-232 rotator commands (read, move, stop, speed) and position replies |
| 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 |
| The console model, the six rules, terminal modes, keys, presets |
| Junos modes from the prompt ( |
| IOS modes ( |
Environment variables
Variable | Effect |
| Refuse writes except read-style commands ( |
| Override the read-only allowlist |
| 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
Download
serial-console-mcp.mcpbfrom the Releases page. The same file works on Mac, Windows and Linux.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.
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-mcpor
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
expectcall: 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-consolepreset,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 toolscapture_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
Scored across 30 tools
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.
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.
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.
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
Related MCP Connectors
Work on your own computers from Claude or ChatGPT: run commands, edit and search files.
Use your Mac, Windows or Linux computer from ChatGPT, Claude or Codex: files, commands, documents.
Connect ChatGPT and Claude to your Mac, Windows or Linux with secure MCP remote access.
- DNS-DATA RemoteDeprecatedcom.dns-data
Connect AI assistants to authorized Windows and macOS devices for files, commands, and management.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI assistants to communicate with serial port devices, supporting port management, data transmission in text/binary modes, interactive terminal sessions, and automatic reconnection.1412MIT
- AlicenseBqualityCmaintenanceEnables 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.242AGPL 3.0
- AlicenseNot gradedqualityDmaintenanceEnables 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 npmMIT
- AlicenseAqualityDmaintenanceEnables AI agents to control serial port devices (modems, instruments, embedded boards) via MCP tools for listing ports, connecting, and sending/receiving commands.31MIT