Skip to main content
Glama
Busy Bar MCP Server

Busy Bar MCP Server

by nuxnik

Busy Bar MCP Server

A Python MCP server written with FastMCP that wraps the busybar_python_sdk to communicate with a physical Busy Bar device over HTTP. The Busy Bar is a digital time-management display — this MCP server provides 32 tools for account retrieval, system information, time operations, BLE control, and input events, exposing its functionality through the standard Model Context Protocol so other tools and AI assistants can interact with it programmatically.

Status: 32 MCP tools are fully implemented across account retrieval, system information, time operations, device state queries, BLE control, and input events, with a complete test suite. The project is ready to use — see the What's Next section below for planned work.

Prerequisites

  • Python ≥ 3.12 — the project pins Python 3.12+ (see .python-version)

  • uv — dependency manager and virtual environment resolver

Related MCP server: TimePRO MCP Server

Installation

Clone the repository and install dependencies:

uv sync

This creates a virtual environment and installs all packages declared in pyproject.toml, including busybar-python-sdk ≥ 27.14.0 from production PyPI (the default index — no index mapping or --index flags are required).

Configuration

The server supports configuration through either a .env file or environment variables. The same two variables are required in both cases:

Variable

Description

Example

BUSYBAR_API_TOKEN

API auth token for authenticating with the Busy Bar device; transmitted to the device as the X-API-Token header (per the busybar-python-sdk 27.14.0 generated ApiKeyAuth scheme — see Authentication below)

my-super-secret-token

BUSYBAR_BASE_URL

IP address or hostname of the Busy Bar device (a scheme-prefixed http://… / https://… value is also accepted)

10.0.4.20

Using .env

Create a .env file in the project root:

BUSYBAR_API_TOKEN=my-super-secret-token
BUSYBAR_BASE_URL=10.0.4.20

The server loads .env when it starts.

Using environment variables

You can also configure the server through variables already present in the process environment:

export BUSYBAR_API_TOKEN=my-super-secret-token
export BUSYBAR_BASE_URL=10.0.4.20

Then start the server normally.

Configuration precedence

Environment variables take precedence over values in .env. The server loads .env with override=False, so an environment variable that has already been exported is never replaced by the value in .env.

For example, if .env contains:

BUSYBAR_BASE_URL=10.0.4.20

but the shell contains:

export BUSYBAR_BASE_URL=10.0.4.30

then 10.0.4.30 is used.

Authentication

BUSYBAR_API_TOKEN is sent to the device as the X-API-Token header. It is wired through the busybar-python-sdk 27.14.x generated ApiKeyAuth scheme via Configuration(api_key={'ApiKeyAuth': <token>}).

Gotcha: the 27.14.x Configuration.auth_settings() silently drops access_token=… — it sends no header at all. The token MUST be passed through Configuration(api_key={'ApiKeyAuth': …}); passing it as Configuration(access_token=…) authenticates nothing. No new environment variable is required.

Usage

Set BUSYBAR_API_TOKEN and BUSYBAR_BASE_URL through either .env or the environment, then start the MCP server:

# One-shot run via uvx (no local install required)
BUSYBAR_API_TOKEN=… BUSYBAR_BASE_URL=10.0.4.20 uvx busybar-mcp

# Or install locally and run the console script
uv sync
BUSYBAR_API_TOKEN=… BUSYBAR_BASE_URL=10.0.4.20 busybar-mcp

Local development and device testing with MCP Inspector

For local development, the Inspector needs to launch the installed busybar-mcp console script from the project environment. This ensures it uses the project's installed dependencies and loads .env from the project root.

  1. Install the project dependencies:

    uv sync
  2. Create a .env file in the project root using the variables documented above. Do not commit this file; it contains your device token.

  3. Start the Inspector in one terminal:

    npm exec --yes --package=@modelcontextprotocol/inspector -- mcp-inspector

    Leave that terminal running and open the local URL it prints.

  4. In the Inspector, select STDIO and configure:

    • Command: the absolute path to this checkout's .venv/bin/busybar-mcp

    • Arguments: leave empty

    • Working directory: the absolute path to this repository's root directory

    Use the project's own virtual environment and working directory. The server loads .env automatically; you do not need to enter BUSYBAR_API_TOKEN or BUSYBAR_BASE_URL in the Inspector when .env is configured.

  5. Click Connect, open Tools, and call a read-only device tool such as get_transport or get_timezone to verify connectivity. Tools that change device settings or send input events should only be used when you intend to make that change.

Troubleshooting: if mcp dev fails with inspector: command not found, use the manual Inspector workflow above. If the Inspector cannot connect, verify the command points to .venv/bin/busybar-mcp, the working directory is the project root, .env contains both required values, and the device is reachable from this machine.

mcp_entry.py is a dev-only entry helper for mcp dev / the MCP Inspector: it loads .env and registers tools on the server object, but is not a standalone server launcher. The regular mcp dev path may start a separate environment; for validating the locally installed SDK and dependencies, use the Inspector configuration above.

Once started, clients can connect to the server using their MCP transport.

MCP Tools

Account tools

Tool

Description

get_account_info

Retrieve linked account information (email, account ID) from the Busy Bar device

get_account_status

Check MQTT connection state for the linked account

get_account_backend

Inspect MQTT backend configuration (server URL, certificate settings)

System tools

Tool

Description

get_api_version

Query the API version supported by the device

get_transport

Get the current network transport type (USB or Wi-Fi)

get_device_status

Comprehensive health check: device, firmware, system, and power state

get_device_info

Retrieve hardware identifiers and manufacturing details

get_firmware_info

Get firmware version and build metadata

get_system_status

Runtime system metrics (uptime, API SemVer, auto-update settings)

get_power_status

Battery charge level, voltage, current, and charging state

Time tools

Tool

Description

get_time

Retrieve the device's real-time clock timestamp in ISO 8601 format

get_timezone

Get the currently configured timezone (name, offset, abbreviation)

get_tzlist

List all supported timezones available for configuration

Device Status & Configuration

Tool

Description

get_ble_status

Retrieve BLE module status (powered state, MAC address)

enable_ble

Enable the BLE module and start advertising

disable_ble

Disable the BLE module and stop advertising

remove_ble_pairing

Remove the current BLE pairing so the device becomes discoverable again

get_busy_snapshot

Get the current BUSY timer state including profile and timing details

get_http_access

Inspect HTTP API key management mode and validity

get_device_name

Get the human-readable device name

get_display_brightness

Retrieve the current display brightness level

get_audio_volume

Retrieve the current audio volume level

get_smart_home_pairing_status

Query Matter fabric count and latest commissioning outcome

get_smart_home_switch_state

Read smart home relay/output state and startup behavior

list_storage_files

List files and directories on device storage (accepts optional path argument)

get_storage_status

Get storage capacity details (used, free, total bytes)

get_firmware_update_status

Check currently installed firmware and pending update state

get_update_changelog

Retrieve release notes for a specific firmware version (accepts required version argument)

get_autoupdate_settings

Get automatic update configuration (enabled, window start/end)

get_wifi_status

Get Wi-Fi connection details (SSID, signal strength, channel, security)

get_wifi_networks

Retrieve scanned available Wi-Fi networks in range (generated WiFiApi.get_wifi_networks() SDK call, GET /api/wifi/networks)

Input tools

Tool

Description

send_input_key

Send a single key-press event to the device (up, down, ok, back, start, busy, custom, off, apps, settings)

Architecture

The project follows a thin-client layering with a clear separation between MCP presentation, configuration, and device access:

┌───────────────────────────────┐      MCP/stdio       ┌──────────────────┐
│           MCP Client          │ ◄──────────────────► │   busybar_mcp    │
│         (AI tool)             │                      │                  │
└───────────────────────────────┘                      └────────┬─────────┘
                                                                │
                                      ┌─────────────────────────┼─────────────────────┐
                                      │                         │                     │
                                      ▼                         ▼                     ▼
                                  config.py                tools/              client.py
                                      │                         │                     │
                                      └─────────────────────────┼─────────────────────┘
                                                                │ SDK calls
                                                                ▼
                                                        busybar_python_sdk
                                                                │ HTTP
                                                                ▼
                                                          Busy Bar Device

Package structure

mcp_entry.py           # Repo-root dev-only entry file for mcp dev / MCP Inspector
busybar_mcp/
├── __init__.py       # Package API and entry point
├── __main__.py       # python -m busybar_mcp entry point
├── server.py         # MCP server and tool registration
├── client.py         # Busy Bar SDK client boundary
├── config.py         # Runtime configuration from environment
├── _server.py        # Backwards-compatible server import
├── utils.py          # Shared serialization/error utilities
└── tools/             # MCP tool modules and registration

The key responsibilities are:

  • server.py — creates the MCP server, registers the tool package, and starts the stdio transport.

  • config.py — reads BUSYBAR_BASE_URL and BUSYBAR_API_TOKEN from the process environment and validates that they are present.

  • client.py — provides the boundary between the MCP application and busybar_python_sdk.

  • tools/ — contains the MCP tool implementations and their registration.

  • utils.py — contains shared serialization and tool-error helpers.

  • __init__.py / __main__.py — provide the package and command-line entry points.

  • mcp_entry.py — repo-root dev-only entry file (loads .env, registers tools on server) for use with mcp dev; not part of the package or distribution.

At startup, server.py loads .env using load_dotenv(override=False). This means exported environment variables are preserved and take precedence over .env values.

The SDK communicates with the device over HTTP using the OpenAPI schema defined by openapi.yaml.

Testing

A working test suite is included with the project. The convenience runner at run_tests.py invokes pytest against the tests/ directory with sensible defaults and no-header output.

Run basic tests

python run_tests.py

Run with coverage output

COVERAGE=1 python run_tests.py

Coverage is reported via pytest-cov (--cov=busybar_mcp --cov-report=term-missing).

Test Coverage Summary

  • 32 MCP tools tested — one parametrized happy-path test per tool across account, system info, time, BLE, busy timer, settings, smart home, storage, update, wifi, and input categories.

  • Configuration tests verify required environment variables and configuration parsing.

  • Error-path tests verify behaviour when the Busy Bar device is missing or unreachable (mocked HTTP failures).

  • Missing environment variable tests confirm that absent BUSYBAR_BASE_URL / BUSYBAR_API_TOKEN are handled gracefully.

  • Serialization tests verify _serialize() handles SDK models, dicts, lists, scalars, and edge cases correctly.

Publishing

Releases are automated by the GitHub Actions pipeline (.github/workflows/publish.yml), triggered on every push to main:

  1. pyproject.toml metadata is synchronized (repository URL, testpypi index) via scripts/sync_metadata.py.

  2. The project version is aligned with the busybar-python-sdk version (the first X.Y.Z token in its dependency specifier).

  3. The updated commit is tagged v<version> (e.g., v27.14.0).

  4. The package is built with uv build (sdist + wheel).

  5. On success the artifacts are published to test.pypi.org via uv publish --index testpypi (never pypi.org).

Publishing requires a repository secret PyPI_API_TOKEN holding a test.pypi.org API token — obtain one at https://test.pypi.org/legacy/token/ and add it under Settings → Secrets and variables → Actions on https://github.com/nuxnik/busybar-mcp. Runs where the version was already published perform no commit, tag, or upload (idempotent).

What's Next

  • Extend with additional write/mutation tools (display messages, notifications)

  • Implement MCP resources for live device data streams

  • Configure linting and formatting toolchain

Available Tools

28 tools
get_account_backendA

Retrieve MQTT backend configuration for the linked account from the Busy Bar device.

This tool queries GET /api/account/backend via `AccountApi.get_account_backend()` to
inspect how the device is configured to reach the busy bar server over MQTT.

Returns an AccountBackend object containing:
    - server_url (str): MQTT server URL to connect to (e.g., "default", "mqtts://mqtt.example.com:8883")
    - client_cert_type (str): Client certificate type, one of "default", "custom", or "none"
    - ignore_server_cert (bool): Whether to ignore the server certificate during TLS handshake

Use case:
    Inspect backend configuration during MQTT troubleshooting; confirm the server URL
    and certificate settings match expectations.

Inputs: no named parameters.

get_account_infoA

Retrieve linked account information from the Busy Bar device.

This tool queries GET /api/account/info via `AccountApi.get_account_info()` to get
details about the account currently linked to the Busy Bar unit.

Returns an AccountInfo object containing:
    - linked (bool): Whether the device is linked to a busy bar account
    - id (str): The unique account identifier (UUID)
    - email (str): The email address associated with the account
    - user_id (str): The user identifier (UUID)

Use case:
    Verify an account is properly linked and inspect the associated email before
    performing account-specific operations like displaying messages or notifications.

Inputs: no named parameters.

get_account_statusA

Retrieve MQTT connection status for the linked account from the Busy Bar device.

This tool queries GET /api/account/status via `AccountApi.get_account_status()` to
learn whether the device's MQTT client is actively connected to the busy bar server.

Returns an AccountStatus object containing:
    - status (str): Connection state, one of "connected", "disconnected", or "error"

Use case:
    Check MQTT connectivity before pushing data that requires cloud sync; if the
    account is not connected, queue operations locally until reconnection.

Inputs: no named parameters.

get_api_versionA

Retrieve the API version information supported by the Busy Bar device.

This tool queries /api/version on the device to learn which set of API
operations are available.  Returns the full version response including
api_semver and any other metadata the device exposes.

Returns a VersionInfo object containing:
    - api_semver (str): API SemVer string (e.g., "0.0.0")

Use case:
    Call this first when building integrations to verify API compatibility
    with the connected Busy Bar unit before issuing further commands.

Inputs: no named parameters.

get_audio_volumeA

Retrieve the audio volume setting from the Busy Bar device.

This tool queries GET /api/audio/volume via `SettingsApi.get_audio_volume()`
to obtain the current volume level configuration.

Returns an AudioVolumeInfo object containing:
    - volume (int): Volume level as an integer value

Use case:
    Check or audit volume settings before playing audio notifications or tones;
    useful for confirming device is configured at an audible level.

Inputs: no named parameters.

get_autoupdate_settingsA

Retrieve automatic firmware update settings from the Busy Bar device.

This tool queries GET /api/update/autoupdate via `UpdaterApi.get_autoupdate_settings()`
to obtain the current autoupdate configuration.

Returns an AutoupdateSettings object containing:
    - is_enabled (bool): Whether automatic updates are enabled
    - interval_start (str): Start of the update window (e.g., "02:00")
    - interval_end (str): End of the update window (e.g., "04:00")

Use case:
    Confirm when or whether firmware updates happen automatically, to avoid unexpected
    reboots during active usage or schedule maintenance around the update window.

Inputs: no named parameters.

get_ble_statusA

Retrieve BLE module status from the Busy Bar device.

This tool queries GET /api/ble/status via `BLEApi.get_ble_status()` to return
the current Bluetooth Low Energy module state.

Returns a BleStatusResponse object containing:
    - status (str): Current BLE status string (e.g., "powered_on", "powered_off")
    - address (str | null): BLE MAC address if available

Use case:
    Verify the BLE module is powered on and has a valid address before attempting
    Bluetooth operations like smart home pairing or device discovery.

Inputs: no named parameters.

get_busy_snapshotA

Retrieve the current BUSY timer snapshot from the Busy Bar device.

This tool queries GET /api/busy/snapshot via `BusyApi.get_busy_snapshot()` to
return the current BUSY timer state including active profile and timing details.

Returns a BusySnapshot object containing:
    - snapshot (BusySnapshotSnapshot): The busy snapshot data — varies by type:
        - BusySnapshotSimple: started (bool), remaining_ms (int)
        - BusySnapshotInterval: started, remaining_ms, interval_index, intervals_count
        - BusySnapshotInfinite: started (bool)
        - BusySnapshotNotStarted: fields not applicable
    - snapshot_timestamp_ms (int): Timestamp of the snapshot in milliseconds since epoch

Use case:
    Check what BUSY timer profile is currently active and how much time remains
    before scheduling display messages or other operations around the timer.

Inputs: no named parameters.

get_device_infoA

Retrieve detailed hardware and identification info about the Busy Bar device.

This tool queries GET /api/status/device via `SystemApi.get_status_device()` to obtain
physical identifiers and manufacturing details of the unit.

Returns a StatusDevice object containing:
    - serial_number (str): Device serial number
    - usb_mac (str): MAC address of the USB ethernet interface
    - wifi_mac (str): Wi-Fi MAC address
    - ble_mac (str): Bluetooth Low Energy MAC address
    - otp_valid (bool): Whether OTP data has been programmed and is valid
    - otp_model (str): Device model code (e.g., "BB.1")
    - otp_timestamp (int): Production timestamp as Unix epoch seconds
    - firmware_security (str): Firmware signature protection state — one of "secure",
      "insecure", "other", or "unknown"

Use case:
    Inventory tracking, device identification in multi-device setups, or
    troubleshooting hardware-specific issues.

Inputs: no named parameters.

get_device_nameA

Retrieve the device name configured on the Busy Bar device.

This tool queries GET /api/name via `SettingsApi.get_name()` to obtain
the human-readable name currently set for this unit.

Returns a NameInfo object containing:
    - name (str): The device name (e.g., "My Busy Bar")

Use case:
    Confirm or audit the display name shown on the device, especially useful in
    multi-device setups where each unit needs an identifiable label.

Inputs: no named parameters.

get_device_statusA

Retrieve the current device status from the Busy Bar device.

This tool queries GET /api/status via `SystemApi.get_status()` and returns a comprehensive
overview of whether the device is online and healthy.  The response bundles four sub-objects:
device, firmware, system, and power.

Returns a Status object containing:
    - device (StatusDevice): Hardware identifiers — serial_number, usb_mac, wifi_mac,
      ble_mac, otp_valid, otp_model, otp_timestamp, firmware_security
    - firmware (StatusFirmware): Firmware details — version, target, branch, build_date,
      commit_hash, intercom_version, nwp_version, matter_version
    - system (StatusSystem): System metrics — api_semver, uptime, boot_time, auto_update_enabled
    - power (StatusPower): Power state — state (discharging/charging/charged), battery_charge
      (int %), battery_voltage (mV), battery_current (mA), usb_voltage (mV)

Use case:
    A quick health-check to confirm the device is reachable and in a valid
    operational state before issuing other commands.

Inputs: no named parameters.

get_display_brightnessA

Retrieve the display brightness setting from the Busy Bar device.

This tool queries GET /api/display/brightness via `SettingsApi.get_display_brightness()`
to obtain the current screen brightness level.

Returns a DisplayBrightnessInfo object containing:
    - value (int): Brightness level as an integer percentage or stepped value

Use case:
    Check brightness before adjusting display behavior, or audit settings during
    device configuration management.

Inputs: no named parameters.

get_firmware_infoA

Retrieve firmware version details from the Busy Bar device.

This tool queries GET /api/status/firmware via `SystemApi.get_status_firmware()` to get
information about the firmware currently installed on the unit.

Returns a StatusFirmware object containing:
    - version (str): Firmware version string (e.g., "1.0.0")
    - target (int): Firmware target code
    - branch (str): Git branch name the firmware was built from
    - build_date (str): Build date (e.g., "2024-01-01")
    - commit_hash (str): Git commit hash, may include a "-dirty" suffix
    - intercom_version (str): Intercom handshake version string
    - nwp_version (str): Radio firmware / NWP version (e.g., "1711.2.14.5.2.0.7")
    - matter_version (str): Matter framework version (e.g., "1.0")

Use case:
    Verify which firmware revision is running on a unit before deploying
    updates or diagnosing firmware-related bugs.

Inputs: no named parameters.

get_firmware_update_statusA

Retrieve firmware update state from the Busy Bar device.

This tool queries GET /api/update/status via `UpdaterApi.get_firmware_update_status()`
to learn about the current and pending firmware states.

Returns an UpdateStatus object containing:
    - install (UpdateStatusInstall): The currently installed firmware info — version, etc.
    - check (UpdateStatusCheck): Status of the latest automatic or manual update check

Use case:
    Verify which firmware is running and whether a new update has been detected but
    not yet installed — useful for maintenance and rollout planning.

Inputs: no named parameters.

get_http_accessA

Retrieve HTTP access configuration from the Busy Bar device.

This tool queries GET /api/access via `SettingsApi.get_http_access()` to obtain
the current HTTP API key management mode and validity state.

Returns an HttpAccessInfo object containing:
    - mode (str): HTTP access mode — one of "default", "custom_key", or "disabled"
    - key_valid (bool): Whether the configured key is currently valid

Use case:
    Inspect HTTP access configuration before deploying tools that rely on the device's
    HTTP API (e.g., remote messaging) to confirm the key setup is correct.

Inputs: no named parameters.

get_power_statusA

Retrieve power/battery status from the Busy Bar device.

This tool queries GET /api/status/power via `SystemApi.get_status_power()` to check
the current battery and charging state of the unit.

Returns a StatusPower object containing:
    - state (str): Power state — one of "discharging", "charging", or "charged"
    - battery_charge (int): Battery charge level as a percentage (0–100)
    - battery_voltage (int): Battery voltage in millivolts (e.g., 4183 mV)
    - battery_current (int): Battery current in milliamperes; negative means discharging
    - usb_voltage (int): USB input voltage in millivolts (e.g., 4843 mV)

Use case:
    Check battery health before operations that consume significant power;
    alert users when the device needs to be plugged in.

Inputs: no named parameters.

get_smart_home_pairing_statusA

Retrieve smart home commissioning (pairing) status from the Busy Bar device.

This tool queries GET /api/smart_home/pairing via `SmartHomeApi.get_smart_home_commissioning_status()`
to learn how many Matter fabric entries exist and the latest pairing outcome.

Returns a SmartHomePairingInfo object containing:
    - fabric_count (int): Number of commissioned Matter fabrics
    - latest_pairing_status (str | null): Status of the most recent pairing attempt
        (e.g., "success", "failure", or null if no attempt yet)

Use case:
    Verify smart home device commissioning state before troubleshooting connectivity,
    confirming pairings, or starting a new setup flow.

Inputs: no named parameters.

get_smart_home_switch_stateA

Retrieve smart home switch (output) state from the Busy Bar device.

This tool queries GET /api/smart_home/switch via `SmartHomeApi.get_smart_home_switch_state()`
to read the current relay/driver output configuration.

Returns a SmartHomeSwitchState object containing:
    - state (str): Current switch/output state (e.g., "on", "off")
    - startup (str | null): Startup behavior — what the switch does on power-on
        (e.g., "restore", "on", "off", "unknown")

Use case:
    Check whether a smart home relay is currently active or inspect its configured
    startup behavior to avoid unexpected device activation after power events.

Inputs: no named parameters.

get_storage_statusA

Retrieve storage capacity information from the Busy Bar device.

This tool queries GET /api/storage/status via `StorageApi.get_storage_status()`
to learn current flash storage usage and available space.

Returns a StorageStatus object containing:
    - used_bytes (int): Bytes currently used on the device storage
    - free_bytes (int): Bytes available for writing
    - total_bytes (int): Total capacity of the storage

Use case:
    Check available storage before uploading files or media to confirm there is
    sufficient space, and monitor storage consumption over time.

Inputs: no named parameters.

get_system_statusA

Retrieve detailed system metrics from the Busy Bar device.

This tool queries GET /api/status/system via `SystemApi.get_status_system()` to get
runtime resource usage and health information.

Returns a StatusSystem object containing:
    - api_semver (str): API SemVer string (e.g., "0.0.0")
    - uptime (str): System uptime as a human-readable duration (e.g., "00d 00h 04m 13s")
    - boot_time (int): System boot timestamp as Unix epoch seconds
    - auto_update_enabled (bool): Whether automatic firmware updates are enabled

Use case:
    Monitor available system resources before performing heavy operations (e.g. large
    file uploads or firmware updates) to avoid exhausting the device.

Inputs: no named parameters.

get_timeA

Retrieve the current timestamp from the Busy Bar device's real-time clock.

This tool queries /api/time on the device and returns the current date and time
in ISO 8601 format with timezone information (e.g., '2025-10-02T14:30:45+04:00').

Returns a TimestampInfo object containing:
    - timestamp: str  — the current UTC/RFC timestamp in ISO 8601 format

Use case:
    Querying the device's clock as an authoritative time source for scheduling,
    logging, or coordinating events with BUSY timer profiles.

Inputs: no named parameters.

get_timezoneA

Retrieve the current timezone configured on the Busy Bar device.

This tool queries /api/time/timezone on the device and returns the currently
active timezone configuration including the display name, UTC offset, and
abbreviation.

Returns a TimezoneInfo object containing:
    - name:  str  — human-readable timezone name (e.g., 'America/New_York')
    - offset: str — UTC offset string (e.g., '-05:00', '+05:30')
    - abbr:   str — timezone abbreviation (e.g., 'EST', 'IST')

Use case:
    Checking which timezone the device is configured to so you can display
    times correctly or decide whether an update is needed.

Inputs: no named parameters.

get_transportA

Retrieve the current network transport type used by the Busy Bar device.

This tool queries /api/transport on the device.  The returned information
describes how the MCP server is communicating with the Busy Bar hardware —
typically "usb" (USB ethernet) or "wifi" (Wi-Fi).

Use case:
    Diagnose connectivity path issues; shows whether the device is reachable
    via USB network interface or a Wi-Fi connection.

Inputs: no named parameters.

get_tzlistA

Retrieve the full list of supported timezones from the Busy Bar device.

This tool queries /api/time/tzlist on the device and returns every timezone
that can be used with the set_timezone functionality (/api/time/timezone POST).

Returns a TimezoneListResponse object containing:
    - list:  list[TimezoneInfo]  — an array of available timezones, each with:
        - name:  str  — human-readable timezone name (e.g., 'America/New_York')
        - offset: str — UTC offset string (e.g., '-05:00', '+05:30')
        - abbr:   str — timezone abbreviation (e.g., 'EST', 'IST')

Use case:
    Browsing the available timezones before choosing one to apply via set_timezone.
    Useful for building a UI dropdown or confirming that a specific named timezone is supported.

Inputs: no named parameters.

get_update_changelogA

Retrieve the changelog for a specific firmware version from the Busy Bar device.

This tool queries GET /api/update/changelog via `UpdaterApi.get_update_changelog(version)`
to obtain release notes and change details for the given firmware version.

Args:
    version: The firmware version string to fetch the changelog for (e.g., "1.0.0").

Returns a GetUpdateChangelog200Response object containing:
    - changelog (str): Human-readable release notes and change log text

Use case:
    Review what changed in a specific firmware revision before deploying updates,
    or compare versions to understand new features and bug fixes.

Inputs: version (required).

get_wifi_networksA

Retrieve currently scanned Wi-Fi networks from the Busy Bar device.

This tool queries GET /api/wifi/networks via `WiFiApi.get_wifi_networks()` to obtain
the latest scan results of available wireless access points in range.

Returns a NetworkResponse object containing:
    - count (int): Number of networks found in the scan
    - networks (list[Network]): Array of network entries, each with SSID, BSSID, RSSI,
      channel, security method, and frequency band information

Use case:
    Browse available Wi-Fi networks before switching the Busy Bar to a different
    access point or confirming signal quality at a new location.

Inputs: no named parameters.

get_wifi_statusA

Retrieve Wi-Fi connection status from the Busy Bar device.

This tool queries GET /api/wifi/status via `WiFiApi.api_wifi_status_get()` to obtain
the current network connection details on the Wi-Fi interface.

Returns a StatusResponse object containing:
    - state (str): Connection state — e.g., "connected", "disconnected"
    - ssid (str | null): SSID of the connected access point
    - bssid (str | null): MAC address of the connected access point
    - channel (int): Wi-Fi channel number (e.g., 1, 6, 36)
    - rssi (int): Received signal strength indicator in dBm (negative value)
    - security (str): Security type — e.g., "open", "wpa2", "wpa3"
    - ip_config (StatusResponseIpConfig): IP configuration including:
        - method (WifiIpType): How the IP was obtained ("dhcp" or "static")

Use case:
    Diagnostics for network troubleshooting — verify SSID, signal strength, security
    type, and IP assignment before debugging connectivity issues.

Inputs: no named parameters.

list_storage_filesA

List files and directories stored on the Busy Bar device at a given path.

This tool calls `StorageApi.list_storage_files(path)` to enumerate the directory
contents on the device's internal storage for the specified path.

Args:
    path: The directory path to list (e.g., "/", "/photos"). Defaults to "/".

Returns a StorageList object containing:
    - A list of StorageListElement objects, each with:
        - type (str): File type — "file" or "dir"
        - name (str): Name of the file or directory

Use case:
    Browse device storage to find files before uploading, downloading, or managing
    media assets for display on the Busy Bar unit.

Inputs: path.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 28 tools

    Disambiguation3/5

    Most tools target distinct endpoints, but there is overlap between the comprehensive get_device_status and its individual sub-getters (e.g., get_device_info, get_firmware_info, get_system_status, get_power_status), which could lead to redundant calls. Similarly, get_transport and get_wifi_status both relate to network connectivity, and the three account getters (info/status/backend) are closely related, though descriptions help differentiate them.

    Naming Consistency4/5

    The naming pattern is overwhelmingly consistent: almost every tool follows get_<resource>. The only deviations are list_storage_files (uses 'list' instead of 'get') and get_tzlist (a slightly non-standard noun form for a list), but these are minor and do not seriously disrupt the overall pattern.

    Tool Count2/5

    28 tools is above the threshold where a toolset starts to feel heavy; the calibration suggests 25+ tools is too many. While each tool corresponds to a distinct device endpoint, the sheer number of read-only getters makes the surface feel bloated and could overwhelm an agent, especially since many are minor status variations.

    Completeness2/5

    The tool surface is entirely read-only—there are no set, update, create, or delete operations. This is a significant gap for a device management server, as users cannot change brightness, volume, timezone, device name, firmware update settings, or perform any configuration action. The description of get_tzlist even references set_timezone, implying such functionality should exist but does not.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      The Time MCP Server is a Model Context Protocol (MCP) server that provides AI assistants and other MCP clients with standardized tools to perform time and date-related operations. This server acts as a bridge between AI tools and a robust time-handling back
      112 npm
      25
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that wraps the TimePRO API, enabling AI assistants to automatically create, view, and manage timesheets for authenticated users. It provides tools for searching clients and projects, retrieving configuration defaults, and performing full CRUD operations on timesheet entries.
      10
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Lightweight MCP server providing system time tools (current time, date, datetime, time components, unix timestamp) for LLM applications.
      1
      MIT