labgrid-mcp
labgrid-mcp is a policy-gated MCP server that lets an AI client discover, reserve, and drive real embedded lab hardware through a labgrid coordinator.
Discover the lab: inspect the coordinator connection, list places/resources/reservations, show a place by name, and see who currently holds which board (
who).Reserve and acquire hardware: create keepalive-backed reservations, wait for allocation, acquire a free/taken place by name, release it (optionally kicking another holder), or release a foreign identity's stale hold.
Control board power and I/O: read/set power (on, off, cycle with delay), drive digital I/O, and switch SD-mux and USB-mux links.
Work with the serial console: open a session on an acquired place, drain buffered output, send input (with optional newline), and close it.
Reach the device over SSH: run remote commands, copy files to/from the board, and open local (
-L) or remote (-R) port-forward tunnels, then list or close them.Manage place metadata: create places, add/remove aliases, set tags and comments, and attach resource matches.
Watch for changes: long-poll
wait_for_changefor place/resource updates instead of a live event stream.Stay safe by default: tools carry honest
readOnly/idempotent/destructiveannotations; read-only mode and per-category allowlists gate risky actions, with flashing and place deletion off unless explicitly enabled (they aren't registered in this schema).
labgrid-mcp
Drive real embedded hardware from Claude, AI editors, and any MCP client.
labgrid is the open-source framework embedded teams use to share lab hardware: boards ("places") with remotely switchable power, serial consoles, USB muxes, and flashing tools. labgrid-mcp is a Model Context Protocol server that plugs any labgrid lab into the MCP ecosystem, so agents and dev tools can work with the lab directly:
"Acquire the rk3399 board, flash last night's image, power-cycle it, and tell me whether it reaches a login prompt. Paste the console log if it doesn't."
Not only for chat: any MCP client, scripted or human-driven, gets a policy-gated remote-control surface over labgrid's mature driver ecosystem, with the reservations and ownership arbitration ad-hoc device servers don't have.
Features
Full device lifecycle: discover, reserve, acquire, release; keepalive-backed so holds never expire mid-task
Hardware control: power on/off/cycle, digital I/O, SD/USB mux switching
Interactive serial console: open, read, send, close; ring-buffered
SSH to the device: run commands, transfer files, tunnels in both directions
Flashing (opt-in): DFU, fastboot, bootstrap loaders, image writing, all as background jobs with status/log polling
Lab housekeeping: tags, aliases, comments, place management, change monitoring
Safety gating: read-only mode and per-category allowlists; the irreversible families (flash, place deletion) are off by default
47 tools, 5 browseable labgrid:// resources, honest
readOnly/destructive annotations on every tool.
Related MCP server: Ollama MCP Server
Try it in 5 minutes (no hardware needed)
Requires uv (its bundled uvx does the rest,
including provisioning Python):
uvx labgrid-mcp demoThis boots a complete fake lab on your machine: a real labgrid
coordinator and exporter, one demo board with a fake power switch and a fake
serial console. It prints a paste-ready .mcp.json snippet. Then ask
your agent:
"List places, then acquire demo-place"
"Power demo-place on and read its power state"
"Open the console on demo-place and read its output"
Ctrl-C tears everything down.
Connect your lab
No separate install step — uvx fetches labgrid-mcp from PyPI the first
time it runs. (Prefer pip? pip install labgrid-mcp, then use
"command": "labgrid-mcp" with no args below.)
You need a running, gRPC-era labgrid coordinator (labgrid ≥ 24; tested against 26.x) reachable from this machine.
1. Register the server with your MCP client. The server definition is the
same everywhere — command uvx, args ["labgrid-mcp"], plus your LG_* env
vars — only the config file location and top-level key differ. Pick your
client:
Save as .mcp.json in your project root:
{
"mcpServers": {
"labgrid": {
"command": "uvx",
"args": ["labgrid-mcp"],
"env": { "LG_COORDINATOR": "your-coordinator-host:20408" }
}
}
}or one command: claude mcp add labgrid --env LG_COORDINATOR=your-coordinator-host:20408 -- uvx labgrid-mcp
Settings → Developer → Edit Config, then add under mcpServers in
claude_desktop_config.json:
{
"mcpServers": {
"labgrid": {
"command": "uvx",
"args": ["labgrid-mcp"],
"env": { "LG_COORDINATOR": "your-coordinator-host:20408" }
}
}
}Save as .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):
{
"mcpServers": {
"labgrid": {
"command": "uvx",
"args": ["labgrid-mcp"],
"env": { "LG_COORDINATOR": "your-coordinator-host:20408" }
}
}
}Save as .vscode/mcp.json — note VS Code uses a servers key:
{
"servers": {
"labgrid": {
"command": "uvx",
"args": ["labgrid-mcp"],
"env": { "LG_COORDINATOR": "your-coordinator-host:20408" }
}
}
}Add under mcpServers in ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"labgrid": {
"command": "uvx",
"args": ["labgrid-mcp"],
"env": { "LG_COORDINATOR": "your-coordinator-host:20408" }
}
}
}labgrid-mcp is a standard stdio MCP server: spawn uvx labgrid-mcp (or
labgrid-mcp after pip install labgrid-mcp) with LG_COORDINATOR set in
its environment, and speak MCP over stdin/stdout. Works with any client or
agent SDK that supports stdio servers.
2. Restart the client so it picks up the new server.
3. Confirm it's connected — ask your agent "List the labgrid places"; you should get your lab's boards back. You're ready.
Identity works exactly like labgrid-client: set LG_HOSTNAME /
LG_USERNAME, or omit them to use your real hostname/user. Security is
delegated to the network (VPN / SSH tunnel), same as labgrid-client.
(Running from a clone instead of PyPI? Use "command": "uv",
"args": ["run", "--directory", "/path/to/labgrid-mcp", "labgrid-mcp"].)
Run with Docker
Build the image from the repo's Dockerfile:
git clone https://github.com/onurcelep/labgrid-mcp && cd labgrid-mcp
docker build -t labgrid-mcp .Then point your MCP client at it:
{
"mcpServers": {
"labgrid": {
"command": "docker",
"args": ["run", "-i", "--rm",
"-e", "LG_COORDINATOR=your-coordinator-host:20408",
"labgrid-mcp"]
}
}
}A useful pattern for labs: build and run the container on a host inside the lab network while your MCP client runs anywhere, one container per user so identity and ownership stay per-person:
{
"mcpServers": {
"labgrid": {
"command": "ssh",
"args": ["labhost", "docker", "run", "-i", "--rm",
"-e", "LG_COORDINATOR=127.0.0.1:20408",
"-e", "LG_USERNAME=your-name",
"labgrid-mcp"]
}
}
}Don't share one running server between users: each instance holds a single labgrid identity, so a shared instance would make everyone's acquisitions indistinguishable. One container per user/agent keeps the lab's ownership model intact. (Note: an image you build bundles labgrid, LGPL-2.1-or-later — fine to use anywhere; if you redistribute the image, the LGPL's terms apply to that copy, with labgrid's license texts already inside it.)
Your first session
Just ask in plain language — the agent maps it to the right tools. A typical first workflow:
"Which places are free right now?"
"Acquire board-7 for me."
"Power it on, then open the serial console and show me the boot output."
"SSH in and run
uname -a.""Power it off and release the board."
Read-only asks ("list places", "who's holding board-7?") work immediately. Anything that changes hardware state is gated (see below), and the two irreversible families — flashing and place deletion — stay off until you explicitly enable them.
Configuration
Env var | Default | Effect |
|
| Coordinator address |
| real host/user | Identity, as in |
| off |
|
| unset | Comma list of categories to register; |
| unset | Private key for the SSH tools; unset, they error clearly at call time |
|
| Max seconds |
Safety in one paragraph: flashing and place deletion can do irreversible
damage, so each needs its own explicit LABGRID_MCP_ALLOW entry. SSH tools
are arbitrary command execution on the acquired board, the same trust class
as a console session; LABGRID_MCP_READONLY=1 drops them along with every
other gated tool (forward_list stays, since it only lists in-memory tunnel
state). And a labgrid caveat worth knowing: the coordinator enforces no
ownership guard on place metadata: this server refuses to edit an acquired
place without force=True, but nothing can protect a place nobody holds
(and an empty tag value in set_place_tags deletes that key, which is
labgrid's own semantics). Details: docs/DESIGN.md §4 and §11.12.
Tools
Group | Tools |
Read |
|
Acquisition / reservation |
|
Drivers |
|
Console |
|
SSH / forward |
|
Flash (opt-in) |
|
Place metadata |
|
Place deletion (opt-in) |
|
Change monitoring |
|
Resources: labgrid://places, labgrid://places/{name},
labgrid://resources, labgrid://reservations, labgrid://sessions.
Per-tool arguments and behaviors are documented in each tool's own
description (visible in your MCP client) and in
docs/DESIGN.md §5/§11.
Limitations
No video/audio/screen capture or USB instruments (need gstreamer + physical USB; no sane MCP surface)
No live event stream;
wait_for_changelong-polling insteadOld crossbar coordinators (labgrid < 24) can't connect
Authentication is network-level (VPN/tunnel), exactly labgrid's own model
The real flash/mux driver step needs a real board: the job machinery is fully CI-tested against fakes, the silicon-touching step is not
Development
The integration suite runs the whole stack, including the demo, against
real coordinator/exporter processes with fake hardware, in CI on every PR,
plus a weekly canary against labgrid master:
git clone <this-repo> labgrid-mcp && cd labgrid-mcp
uv sync
uv run pytest # unit
uv run pytest -m integrationArchitecture, decision log, and a verified reference of labgrid's
internals: docs/DESIGN.md.
Contributions are welcome; see CONTRIBUTING.md for the
workflow, the full check list, and the DCO sign-off requirement.
License
Apache-2.0. Copyright 2026 Onur Celep.
labgrid itself is LGPL-2.1-or-later and is used as a regular, unmodified dependency.
Available Tools
38 toolsacquire_placeADestructive
Acquire a place by name for this session.
Free places are acquired directly; a taken or reserved place is
acquired via a name-filtered reservation, polled until it
allocates our place (bounded by ``config.acquire_timeout``), then
acquired and the reservation dropped (session.py, DESIGN.md
section 11.8). Raises a tool error on RPC failure or timeout.
Inputs: name (required). Returns: object
add_placeADestructive
Create a new place by name.
No ownership check -- a brand-new name can never collide with an existing acquisition.
Inputs: name (required). Returns: object
add_place_aliasADestructive
Add an alias to an existing place.
Idempotent on the coordinator (adding a duplicate alias is a
no-op, OK). Refuses if the place is acquired by a DIFFERENT
identity unless ``force=True``. Returns the refreshed place dict
(bounded snapshot catch-up -- the mutating RPC's completion is
independent of the ClientStream update that lands the edit).
Inputs: alias (required), place (required), force. Returns: object
add_place_matchADestructive
Add a resource match to an existing place.
``pattern`` is ``"exporter/group/cls"`` or
``"exporter/group/cls/name"`` (exactly 3 or 4 non-empty
``/``-separated segments) -- validated here before any RPC,
since a different arity crashes the coordinator uncaught
(design §11.12 trap). ``rename`` sets an alternate resource
name; verified against labgrid 26.0 it is NOT part of a match's
identity (a duplicate ``pattern`` is rejected regardless of
``rename``, and ``delete_place_match`` removes by ``pattern``
alone -- see ``coordinator.py``). Refuses if the place is
acquired by a DIFFERENT identity unless ``force=True``.
Inputs: place (required), pattern (required), force, rename. Returns: object
allow_placeADestructive
Allow another user to use a place this session has acquired.
``user`` must be in "host/user" format; raises before any RPC if
it is not.
Inputs: name (required), user (required). Returns: object
cancel_reservationBDestructive
Cancel a reservation by ID and stop its keepalive task.
``reservation_id`` is required; ``token`` is its deprecated alias.
Inputs: token, reservation_id. Returns: object
console_closeAIdempotent
Close a console session: stop and join its reader, then deactivate the driver. Idempotent; an unknown session is a tool error.
Inputs: session (required). Returns: object
console_openA
Open an interactive console session on an acquired place.
Binds a raw-protocol ``SerialDriver`` and starts its background
reader (console.py, DESIGN §11.10); one session per place -- a
second open on a place that already has one is rejected by the
registry. The ownership check runs first, before any registry
call, so an unacquired/unknown place never touches the registry.
Inputs: place (required). Returns: object
console_readARead-onlyIdempotent
Drain up to max_bytes (default all) buffered console bytes.
Consumes the drained bytes and resets the truncated flag. An
unknown session is a tool error; an errored reader still surfaces
any buffered data alongside the failure (registry.read()).
Inputs: session (required), max_bytes. Returns: object
console_sendADestructive
Write data to an open console session.
Appends ``"\n"`` when ``newline=True``. An unknown, closed, or
errored session is a tool error.
Inputs: data (required), session (required), newline. Returns: object
coordinator_infoARead-onlyIdempotent
Report the coordinator connection.
Returns the coordinator address, the client's claimed identity, whether the subscription is currently connected, and the coordinator version if the protocol provides one (currently null).
Inputs: no named parameters. Returns: object
delete_place_aliasADestructive
Remove an alias from an existing place.
Pre-validates that ``alias`` is present in our snapshot BEFORE
any RPC: design §11.12 trap -- the coordinator raises an
uncaught ``KeyError`` (surfaced as gRPC ``UNKNOWN``) for a
nonexistent alias, so this is checked here instead, giving a
clean tool error and sending zero RPCs for a typo'd alias.
Refuses if the place is acquired by a DIFFERENT identity unless
``force=True``.
Inputs: alias (required), place (required), force. Returns: object
forward_closeAIdempotent
Close a forward tunnel by id (ssh -O cancel, best-effort).
Idempotent shape; an unknown tunnel id is a tool error.
Inputs: forward (required). Returns: object
forward_listARead-onlyIdempotent
List all live forward tunnels across every place (forwards.sessions()).
Inputs: no named parameters. Returns: object
forward_openA
Open a local port-forward tunnel to remote_port on a place.
``local_port=0`` (default) auto-assigns a free local port. Returns
``{"forward", "place", "local_port", "remote_port"}``. Multiple
tunnels per place are allowed (forwards.py, §11.13). The ownership
check runs first, before any registry call.
Inputs: place (required), remote_port (required), local_port. Returns: object
forward_remote_openA
Open a REMOTE (-R) port-forward tunnel on a place.
Unlike ``forward_open``'s local (``-L``) forward, BOTH ports are
required -- labgrid's ``SSHDriver.forward_remote_port`` has no
auto-assign for the local side (§11.14): a connection to
``remote_port`` on the DUT is forwarded to
``localhost:local_port`` on THIS host, so a local service must
already be listening there. Returns ``{"forward", "place",
"direction": "remote", "remote_port", "local_port"}``.
``forward_list``/``forward_close`` (and the ``labgrid://sessions``
forwards payload) work identically regardless of direction. The
ownership check runs first, before any registry call.
Inputs: place (required), local_port (required), remote_port (required). Returns: object
get_fileA
Copy remote_path from an acquired place to local_path (scp).
An existing local target is refused unless ``overwrite=True`` (pinned
ToolError); the parent directory must already exist. Returns
``{"place", "got": local_path, "bytes": <resulting size>}``. NOT
read-only (it writes a local file), but non-destructive to the DUT.
Inputs: place (required), local_path (required), remote_path (required), overwrite. Returns: object
get_ioARead-onlyIdempotent
Current digital IO state for an acquired place (HttpDigitalOutputDriver.get()).
``resource_name`` (§11.14) picks one of several same-class IO
resources on the place; omit it for a single-IO-resource place
(unchanged behavior). Echoed back in the result only when given.
Inputs: place (required), resource_name. Returns: object
get_power_stateARead-onlyIdempotent
Current power state for a place this server has acquired.
Reads via ``NetworkPowerDriver.get()`` (target.py). Category.POWER
gated even though it only reads: it talks to a real hardware path,
unlike the always-on Phase 1/2 read tools. ``resource_name``
(§11.14) picks one of several same-class power resources on the
place -- omit it for a single-power-resource place (unchanged
behavior); an unnamed pick on a multi-resource place is a tool
error naming the available resources. Echoed back in the result
only when given (additive).
Inputs: place (required), resource_name. Returns: object
get_sd_muxARead-onlyIdempotent
Current SD-mux mode for an acquired place (USBSDMuxDriver.get_mode()).
SD-mux only (§11.14): ``LXAUSBMuxDriver`` (the ``usb_mux`` kind)
has no read method, so there is no ``usb_mux`` equivalent.
Inputs: place (required). Returns: object
list_placesARead-onlyIdempotent
All places known to the coordinator, as labgrid place dicts.
Inputs: no named parameters. Returns: object
list_reservationsCRead-onlyIdempotent
Current reservations (live unary RPC to the coordinator).
Inputs: no named parameters. Returns: object
list_resourcesARead-onlyIdempotent
All exporter resources known to the coordinator.
Inputs: no named parameters. Returns: object
put_fileADestructive
Copy a local file to remote_path on an acquired place (scp).
The local file must exist (a missing one is a pinned ToolError,
checked before the driver is bound). Returns
``{"place", "put": remote_path, "bytes": <local size>}``.
Inputs: place (required), local_path (required), remote_path (required). Returns: object
release_fromADestructive
Release place from a specific host/user identity.
Unlike ``release_place`` (which only ever releases OUR OWN
acquisition), this targets an arbitrary identity -- useful for an
operator clearing a stale/foreign hold. Design §11.14/§11.8 trap:
the coordinator's ``ReleasePlace`` does NO format validation on
``fromuser``, and a non-empty ``fromuser`` that does not match the
place's actual holder is a SILENT no-op that still reports
success -- so simply checking "not acquired by fromuser
afterward" is USELESS (it is already true before the call
whenever ``fromuser`` never held the place, which is exactly the
mismatch case). The only way to tell whether THIS call actually
changed anything is to compare a snapshot from BEFORE the RPC
against one from after: ``released`` is True iff ``fromuser`` was
the holder beforehand AND is no longer the holder afterward (a
place ``fromuser`` never held reports ``released=False`` --
nothing was there for this call to release). This tool talks
directly to the coordinator client (like the place-metadata
mutators) rather than through ``session.release_place``, since
that helper only knows how to release OUR OWN identity and would
refuse before ever sending the RPC for anyone else's.
``host``/``user`` must each be non-empty and "/"-free -- validated
(mirroring ``allow_place``'s ``_validate_identity``) BEFORE any RPC,
since the coordinator does no validation of its own (§11.14 above).
Inputs: host (required), user (required), place (required). Returns: object
release_placeADestructive
Release a place by name.
By default this verifies we currently hold the place before releasing it; pass kick=True to release unconditionally regardless of the current holder.
Inputs: name (required), kick. Returns: object
reservation_waitA
Block-and-poll a reservation until it allocates a place, or times out.
``timeout_s`` is clamped to at most 25.0 (PlaceSession.reservation_wait,
§11.14), like ``wait_for_change``. Only an *acquired* reservation
auto-refreshes coordinator-side -- polling here IS what keeps a
merely-``waiting``/``allocated`` reservation's TTL alive, so the
reservation still needs an ``acquire_place`` (or another ``reservation_wait``/
``cancel_reservation``) soon after this returns, or it expires
~60s after creation regardless of the outcome reported here.
Returns ``{"reservation_id", "state", "allocations", "changed"}``
plus the deprecated ``token`` mirror of ``reservation_id`` --
``changed`` is True iff the reservation is allocated by the time
this returns; a dead reservation (expired/invalid/unknown) or a
genuine timeout both report ``changed=False`` without raising.
Non-destructive but not idempotent (each call keepalive-polls).
``reservation_id`` is required; ``token`` is its deprecated alias.
Inputs: token, timeout_s, reservation_id. Returns: object
reserveB
Create a reservation (with the given filters/priority) and keep
it alive in the background until it is cancelled, expires, or is
invalidated. Returns the serialized reservation, including its
reservation_id (also mirrored as the deprecated token).
Inputs: filters (required), prio. Returns: object
set_ioADestructive
Set digital IO on an acquired place, then re-read and return the resulting state (HttpDigitalOutputDriver.set() then .get()).
``resource_name`` (§11.14) picks one of several same-class IO
resources on the place; the SAME name is used for both the set
and the re-read, and omitting it preserves single-resource
behavior unchanged.
Inputs: place (required), value (required), resource_name. Returns: object
set_place_commentADestructive
Set an existing place's free-form comment (unvalidated by the coordinator).
Refuses if the place is acquired by a DIFFERENT identity unless
``force=True``.
Inputs: place (required), comment (required), force. Returns: object
set_place_tagsADestructive
Set tags on an existing place.
An empty string value for a key DELETES that key -- intentional
labgrid semantics (design §11.12): the coordinator's own value
validation is a no-op that lets an empty string straight
through, so this is surfaced honestly here rather than hidden.
Refuses if the place is acquired by a DIFFERENT identity unless
``force=True``.
Inputs: tags (required), place (required), force. Returns: object
set_powerADestructive
Drive power on/off/cycle on an acquired place, then return the resulting state.
``action`` must be one of "on", "off", "cycle"; anything else is
rejected with a tool error before the place is even checked or any
driver is touched. ``delay`` (§11.14) sets the off/on gap (in
seconds) ``NetworkPowerDriver.cycle()`` sleeps for; it is only
meaningful for ``action="cycle"`` -- passing it with "on"/"off" is
a tool error (clearer than silently ignoring it), raised alongside
the action check, before ownership or any driver call.
``resource_name`` picks one of several same-class power resources
on the place (§11.14); omit it for a single-power-resource place
(unchanged behavior).
Inputs: place (required), action (required), delay, resource_name. Returns: object
set_sd_muxADestructive
Set the SD mux mode on an acquired place (USBSDMuxDriver.set_mode()).
Inputs: mode (required), place (required). Returns: object
set_usb_muxBDestructive
Set USB mux links on an acquired place (LXAUSBMuxDriver.set_links()).
Inputs: links (required), place (required). Returns: object
show_placeARead-onlyIdempotent
One place by exact name. Raises a tool error if unknown.
Inputs: name (required). Returns: object
ssh_runADestructive
Run command over SSH on an acquired place and return its result.
Binds an ``SSHDriver`` (target.py, §11.13) and shells out via
``SSHDriver.run`` off the loop. Returns
``{"place", "stdout", "stderr", "exit_code"}`` -- labgrid returns
stdout/stderr as line LISTS, joined here with ``"\n"``. The
driver's own ``timeout=timeout_s`` is the sole enforcer of
``timeout_s``; the outer ``asyncio.wait_for`` only backstops a
wedged thread with a small grace (``timeout_s + 5.0``) so it
doesn't co-fire with the inner timeout. CAVEAT: a timeout does NOT
kill the remote command -- ``subprocess`` does not reap on
``communicate(timeout=...)``, so the underlying ``ssh`` may linger
until it finishes or the ControlMaster tears down. CAVEAT: labgrid
whitespace-splits ``command`` (``cmd.split(" ")``) with no shell
quoting, so multi-space or quoted arguments will split wrong.
Inputs: place (required), command (required), timeout_s. Returns: object
wait_for_changeARead-onlyIdempotent
Long-poll for the next place/resource change (design §11.12 -- the live-monitor substitute; FastMCP has no subscription surface).
``cursor=None`` bootstraps: returns the coordinator's current change
cursor immediately, with ``changed=false`` (no waiting) -- call this
once to get a starting point, then pass the returned ``cursor`` back
on later calls. Otherwise blocks (event-driven, no busy-polling)
until the cursor advances past ``cursor``, or ``timeout_s`` elapses,
whichever comes first, then returns the current cursor and whether it
changed. ``timeout_s`` is clamped to at most 25.0 regardless of what
is requested, to stay under typical MCP client request timeouts --
this assumes the caller's own MCP client timeout is set higher than
25s; a lower client timeout just means the client gives up first and
the orphaned poll on our side finishes harmlessly on its own.
Read-only and idempotent: it never mutates anything, and repeated
calls with the same arguments are safe to retry. Registered
unconditionally, like the other read tools -- available even in
readonly mode. The change cursor is process-local and resets to 0 on
server restart (design §11.12); a cursor value held from a previous
process is simply stale and self-heals after at most one full
``timeout_s`` -- the next call either sees an already-advanced
cursor (``changed=True``) or times out and returns the current one.
Inputs: cursor, timeout_s. Returns: object
whoARead-onlyIdempotent
Currently acquired places by host/user (derived from the snapshot).
Inputs: no named parameters. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 38 tools
Most tools target a clearly distinct resource+action (list_places vs show_place, get_power_state vs set_power, forward_open vs forward_remote_open). The two closest pairs — release_place vs release_from, and add_place_alias vs delete_place_alias — are explicitly differentiated in their descriptions. Only minor overlap remains, so an agent can reliably choose.
Two competing conventions coexist: verb_noun (list_places, set_power, add_place_match) and noun_verb (reservation_wait, console_send, forward_open, ssh_run), plus bare verbs (reserve, who). Each pattern is internally consistent per domain family and stays readable, but the set as a whole is mixed rather than uniform.
At 38 tools this is well above the 'heavy' threshold, and the surface is quite granular (separate get/set pairs for power, io, and sd_mux). The domain is genuinely broad, but the sheer count makes discovery harder than necessary.
Core lifecycle is covered well: places (acquire/release/allow/release_from), reservations (reserve/cancel/wait/list), console, forwards, ssh, and place metadata. However there is no delete_place and, notably, add_place_match exists without a matching delete_place_match (referenced in descriptions but unregistered), leaving real teardown gaps.
Maintenance
Related MCP Connectors
LLM Orchestration Agent (Opentelemetry Api)
LLM Orchestration Agent (Openai)
LLM Observability & Orchestration Agent
LLM Orchestration Agent (Opentelemetry Instrumentation Fastapi)
Related MCP Servers
- AlicenseBqualityDmaintenanceThis server facilitates the invocation of AI models from providers like Anthropic, OpenAI, and Groq, enabling users to manage and configure large language model interactions seamlessly.272 PyPI13MIT
- FlicenseNot gradedqualityDmaintenanceA server that enables seamless integration between local Ollama LLM instances and MCP-compatible applications, providing advanced task decomposition, evaluation, and workflow management capabilities.6-
- FlicenseNot gradedqualityBmaintenanceEnables local research workflows (paper discovery, relevance scoring, digests) and homelab monitoring (Prometheus, logs) through an MCP server, using local LLM inference via Ollama with no cloud dependencies.-
- AlicenseAqualityCmaintenanceEnables MCP clients to scan local GGUF models, estimate VRAM and suggest GPU offload layers, manage llama-server lifecycle, and proxy OpenAI-format chats with idle auto-unload.9MIT