Skip to main content
Glama

labgrid-mcp

PyPI labgrid-mcp MCP server

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 demo

This 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

LG_COORDINATOR

127.0.0.1:20408

Coordinator address

LG_HOSTNAME / LG_USERNAME

real host/user

Identity, as in labgrid-client

LABGRID_MCP_READONLY

off

1 = only read-only tools are registered: the Read group plus wait_for_change and forward_list

LABGRID_MCP_ALLOW

unset

Comma list of categories to register; flash and place_delete must be listed explicitly; they're off even by default

LABGRID_MCP_SSH_KEYFILE

unset

Private key for the SSH tools; unset, they error clearly at call time

LABGRID_MCP_ACQUIRE_TIMEOUT

120

Max seconds acquire_place waits for allocation

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

coordinator_info, list_places, show_place, who, list_resources, list_reservations

Acquisition / reservation

acquire_place, release_place, allow_place, release_from, reserve, cancel_reservation, reservation_wait

Drivers

get_power_state, set_power, get_io, set_io, get_sd_mux, set_sd_mux, set_usb_mux

Console

console_open, console_read, console_send, console_close

SSH / forward

ssh_run, put_file, get_file, forward_open, forward_remote_open, forward_close, forward_list

Flash (opt-in)

flash_dfu, flash_fastboot, flash_script, bootstrap, write_image, flash_status, flash_logs

Place metadata

add_place, add_place_alias, delete_place_alias, set_place_tags, set_place_comment, add_place_match

Place deletion (opt-in)

delete_place, delete_place_match

Change monitoring

wait_for_change

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_change long-polling instead

  • Old 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 integration

Architecture, 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 tools
acquire_placeA
Destructive

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_placeA
Destructive

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_aliasA
Destructive

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_matchA
Destructive

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_placeA
Destructive

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_reservationB
Destructive

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_closeA
Idempotent

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_readA
Read-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_sendA
Destructive

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_infoA
Read-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_aliasA
Destructive

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_closeA
Idempotent

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_listA
Read-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_ioA
Read-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_stateA
Read-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_muxA
Read-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_placesA
Read-onlyIdempotent

All places known to the coordinator, as labgrid place dicts.

Inputs: no named parameters. Returns: object

list_reservationsC
Read-onlyIdempotent

Current reservations (live unary RPC to the coordinator).

Inputs: no named parameters. Returns: object

list_resourcesA
Read-onlyIdempotent

All exporter resources known to the coordinator.

Inputs: no named parameters. Returns: object

put_fileA
Destructive

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_fromA
Destructive

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_placeA
Destructive

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_ioA
Destructive

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_commentA
Destructive

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_tagsA
Destructive

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_powerA
Destructive

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_muxA
Destructive

Set the SD mux mode on an acquired place (USBSDMuxDriver.set_mode()).

Inputs: mode (required), place (required). Returns: object

set_usb_muxB
Destructive

Set USB mux links on an acquired place (LXAUSBMuxDriver.set_links()).

Inputs: links (required), place (required). Returns: object

show_placeA
Read-onlyIdempotent

One place by exact name. Raises a tool error if unknown.

Inputs: name (required). Returns: object

ssh_runA
Destructive

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_changeA
Read-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

whoA
Read-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

    B3.4/5.0

    Scored across 38 tools

    Disambiguation4/5

    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.

    Naming Consistency3/5

    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.

    Tool Count2/5

    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.

    Completeness3/5

    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

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables 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.
      -
    • A
      license
      A
      quality
      C
      maintenance
      Enables 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.
      9
      MIT