Skip to main content
Glama
i-zrhe2016
by i-zrhe2016

Xray MCP Monitor

xray-mcp-monitor is an MCP server for checking the reachability of nodes inside an Xray subscription.

It accepts an http or https subscription URL, parses common node formats, runs scheduled TCP probes against each matched node, and exposes the whole workflow through MCP tools.

Features

  • Fetches Xray subscriptions from http and https URLs

  • Parses raw URI lists and common base64-encoded subscription payloads

  • Supports vmess, vless, trojan, ss, socks, http, and https

  • Recognizes hy2, hysteria, hysteria2, and tuic, but marks them unsupported for probing

  • Runs a background scheduler for recurring checks

  • Persists monitor definitions and latest results to a local JSON state file

  • Exposes both one-off checks and long-running monitors through MCP tools

  • Works over stdio, streamable-http, and sse

Related MCP server: domain-mcp

How It Works

  1. A client calls register_subscription_monitor or check_subscription_once.

  2. The server fetches the subscription payload from the provided URL.

  3. The payload is parsed into Xray nodes.

  4. Each matched TCP node is checked with a direct host:port TCP connection.

  5. The result is returned to the MCP client, and scheduled monitors are stored in local state.

Limits

  • This is a TCP reachability probe, not a full proxy or handshake validation.

  • UDP-style protocols are currently not actively checked.

  • Monitor state is local to the process and stored in a JSON file.

  • interval_seconds must be at least 10.

  • timeout_seconds must be greater than 0.

Requirements

  • Python >=3.10

  • mcp[cli] >=1.27,<2

Install

Using pip:

python3 -m venv .venv
./.venv/bin/pip install -e .

Using uv:

uv sync

Run The Server

Stdio transport:

./.venv/bin/python -m xray_mcp_monitor.server

Streamable HTTP transport:

./.venv/bin/python -m xray_mcp_monitor.server --transport streamable-http

SSE transport:

./.venv/bin/python -m xray_mcp_monitor.server --transport sse

You can also use the installed console script:

./.venv/bin/xray-mcp-monitor

Manage scheduled checks without Codex:

./.venv/bin/xray-mcp-monitor-cli --help

Run the web dashboard:

./.venv/bin/xray-mcp-monitor-web --help

Environment Variables

export XRAY_MCP_TRANSPORT=stdio
export XRAY_MCP_HOST=127.0.0.1
export XRAY_MCP_PORT=8000
export XRAY_MCP_STATE_FILE=./xray_watch_state.json
  • XRAY_MCP_TRANSPORT: default transport when --transport is omitted

  • XRAY_MCP_HOST: bind host for network transports

  • XRAY_MCP_PORT: bind port for network transports

  • XRAY_MCP_STATE_FILE: path to the persistent watch state JSON file

Run Without Codex

If you want the scheduler to keep running without an interactive Codex session, use the bundled CLI manager instead of the MCP transport.

Register a scheduled watch:

./.venv/bin/xray-mcp-monitor-cli \
  --state-file /root/xray-mcp/.codex/xray_watch_state.json \
  register "https://example.com/subscription" \
  --interval-seconds 300 \
  --timeout-seconds 5 \
  --node-name-keyword hk

List stored watches:

./.venv/bin/xray-mcp-monitor-cli \
  --state-file /root/xray-mcp/.codex/xray_watch_state.json \
  list

Run the background scheduler as a long-lived process:

XRAY_MCP_STATE_FILE=/root/xray-mcp/.codex/xray_watch_state.json \
./.venv/bin/python -m xray_mcp_monitor.cli daemon

You can also use:

./.venv/bin/python -m xray_mcp_monitor cli list

The scheduler state is persisted in XRAY_MCP_STATE_FILE, so the daemon reloads existing watches on startup.

Web Dashboard

The project now includes a built-in local dashboard for creating and managing monitors in a browser.

Start it locally:

XRAY_MCP_STATE_FILE=/root/xray-mcp/.codex/xray_watch_state.json \
./.venv/bin/xray-mcp-monitor-web --host 127.0.0.1 --port 8080

Then open:

http://127.0.0.1:8080

The dashboard supports:

  • creating scheduled monitors

  • running one-off checks

  • listing current monitor health

  • enabling or disabling monitors

  • running a monitor immediately

  • removing monitors

If you prefer the module form:

./.venv/bin/python -m xray_mcp_monitor web --host 127.0.0.1 --port 8080

systemd Service

This repository includes a sample unit at deploy/systemd/xray-mcp-monitor.service.

Recommended install flow:

sudo mkdir -p /opt/xray-mcp /var/lib/xray-mcp-monitor
sudo cp -r /root/xray-mcp /opt/xray-mcp
cd /opt/xray-mcp
python3 -m venv .venv
./.venv/bin/pip install -e .
sudo cp deploy/systemd/xray-mcp-monitor.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now xray-mcp-monitor

After that:

sudo systemctl status xray-mcp-monitor
journalctl -u xray-mcp-monitor -f

Before enabling the service, edit the unit file paths if your checkout is not under /opt/xray-mcp.

systemd Web Service

A separate sample unit is included at deploy/systemd/xray-mcp-monitor-web.service.

Install it with:

sudo cp deploy/systemd/xray-mcp-monitor-web.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now xray-mcp-monitor-web

Check logs with:

sudo systemctl status xray-mcp-monitor-web
journalctl -u xray-mcp-monitor-web -f

If you expose it beyond localhost, put it behind a reverse proxy or a firewall. The current dashboard does not include authentication.

MCP Tools

register_subscription_monitor

Create a scheduled monitor and immediately run the first check.

Parameters:

  • subscription_url: str

  • interval_seconds: int = 300

  • timeout_seconds: float = 5.0

  • node_name_keyword: str | None = None

check_subscription_once

Fetch a subscription and run a one-time check without storing a monitor.

Parameters:

  • subscription_url: str

  • timeout_seconds: float = 5.0

  • node_name_keyword: str | None = None

list_subscription_monitors

List all registered monitors.

get_subscription_monitor

Return one stored monitor and its latest result.

Parameters:

  • watch_id: str

run_monitor_now

Run a stored monitor immediately.

Parameters:

  • watch_id: str

set_monitor_enabled

Enable or disable a stored monitor.

Parameters:

  • watch_id: str

  • enabled: bool

remove_subscription_monitor

Remove a stored monitor.

Parameters:

  • watch_id: str

Status Values

Watch-level statuses:

  • error: fetching the subscription failed

  • empty: no nodes were found

  • no_match: nodes were parsed, but none matched node_name_keyword

  • healthy: all matched nodes were reachable

  • healthy_with_warnings: all matched nodes were reachable, but some non-fatal parse warnings were recorded

  • degraded: some matched nodes were reachable and some were unreachable

  • partial: some matched nodes were reachable and some were unsupported

  • unsupported: all matched nodes were unsupported for probing

  • down: no matched nodes were reachable

Node-level statuses:

  • reachable

  • unreachable

  • unsupported

Example Tool Call

Input:

{
  "subscription_url": "https://example.com/path/to/subscription",
  "interval_seconds": 300,
  "timeout_seconds": 5,
  "node_name_keyword": "hk"
}

Useful response fields:

  • watch.watch_id: stable ID for later operations

  • watch.last_result: latest stored result for a scheduled monitor

  • result.status: current overall health state

  • result.nodes: per-node reachability, latency, and error details

  • result.errors: parse or fetch warnings

Codex Integration

This repository already includes a project-scoped Codex MCP config at .codex/config.toml.

If you want to configure it manually, use:

[mcp_servers.xray_monitor]
command = "/path/to/xray-mcp/.venv/bin/python"
args = ["-m", "xray_mcp_monitor.server"]
cwd = "/path/to/xray-mcp"
startup_timeout_sec = 15
tool_timeout_sec = 120
enabled = true

[mcp_servers.xray_monitor.env]
XRAY_MCP_STATE_FILE = "/path/to/xray-mcp/.codex/xray_watch_state.json"

If you use the checked-in .codex/config.toml, update the paths if this repository is not located at /root/xray-mcp.

Then start Codex in this project:

codex -C /path/to/xray-mcp

Inside Codex, use /mcp to verify that xray_monitor is connected.

Claude Desktop Style Config

{
  "mcpServers": {
    "xray-monitor": {
      "command": "/path/to/xray-mcp/.venv/bin/python",
      "args": ["-m", "xray_mcp_monitor.server"],
      "cwd": "/path/to/xray-mcp"
    }
  }
}

Development

Run tests:

./.venv/bin/python -m unittest discover -s tests

Useful local checks:

./.venv/bin/python -m xray_mcp_monitor.server --help
codex -C /path/to/xray-mcp mcp list
codex -C /path/to/xray-mcp mcp get xray_monitor

Available Tools

7 tools
check_subscription_onceB

Fetch a subscription URL and run a one-time connectivity check.

ParametersJSON Schema
NameRequiredDescriptionDefault
timeout_secondsNo
subscription_urlYes
node_name_keywordNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.3/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'one-time' (implying no persistence) but does not explain side effects (e.g., network request, potential subscription state changes), timeout behavior, or what constitutes success/failure. The description is too sparse for a network-involved tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler. It is concise and front-loaded with the action ('Fetch a subscription URL') followed by the purpose ('run a one-time connectivity check'). Every word contributes meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the presence of an output schema, the description lacks sufficient context for a 3-parameter tool with no annotations. It does not explain what a subscription is, what a connectivity check entails, or the role of optional parameters. The tool is under-specified for reliable agent selection and invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It mentions 'subscription URL,' which maps to the `subscription_url` parameter, but it does not explain `timeout_seconds` or `node_name_keyword`. The word 'fetch' adds some context but leaves other parameters undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's action: 'Fetch a subscription URL and run a one-time connectivity check.' The verb 'run' and resource 'subscription URL' are specific. The phrase 'one-time' distinguishes it from sibling tools like `register_subscription_monitor` and `run_monitor_now`, which involve persistent or recurring checks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies a one-time ad-hoc check but does not explicitly state when to use this tool versus registering a monitor or triggering an existing one. There is no mention of alternatives or exclusions, so usage guidance is only implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_subscription_monitorA

Get a monitor by watch ID, including the latest stored result.

ParametersJSON Schema
NameRequiredDescriptionDefault
watch_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the burden of behavioral disclosure. It states that the result includes the latest stored result, which is useful, but it does not mention error behavior, authentication, or side effects. The 'Get' verb implies a read-only operation, but no deeper transparency is provided.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clearly worded sentence that immediately conveys the tool's action and key detail. No wasted words, and the most important information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple retrieval tool with one parameter and an output schema, the description is sufficient: it identifies the resource, the key behavior (latest stored result), and the selection mechanism. Some details like what a monitor is or where watch IDs come from are omitted, but sibling tool names and context fill in gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It clarifies that 'watch_id' is the identifier used to select the monitor, which adds some context beyond the raw schema, though it largely restates the parameter name and does not explain the format or origin of watch IDs.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Get'), resource ('monitor'), and identifier type ('watch ID'), and adds that it includes the latest stored result. This distinguishes it from siblings like list_subscription_monitors (which lists all) and remove_subscription_monitor (which deletes).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'by watch ID' clearly implies the tool is for retrieving a single, known monitor, as opposed to listing all monitors or running checks. While no explicit alternatives or exclusions are named, the context of a specific identifier provides clear usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_subscription_monitorsB

List all registered scheduled monitors.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.3/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic operation ('List all registered scheduled monitors') with no mention of read-only nature, pagination, order, or potential side effects. The name implies a read operation, but the description itself adds no safety or behavioral context beyond the action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with no wasted words (six words total). It is appropriately minimal for a parameterless list tool and gets straight to the point without extraneous detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is very simple (no params) and has an output schema, so the description does not need to explain return values. The description covers the core function clearly, but it lacks differentiation from the similar 'get_subscription_monitor' and provides no usage context. Given the simplicity of the tool, this is a minor gap, so the description is nearly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, and the input schema is empty. The description implies that no arguments are needed, which aligns with the schema. Per the rubric, a zero-parameter tool receives a baseline score of 4, and the description does not need to add parameter details because there are none to explain.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action 'List' and the resource 'all registered scheduled monitors', making its purpose unambiguous. It is concise and uses specific language, though it does not explicitly differentiate from the sibling tool 'get_subscription_monitor'. The word 'all' implies listing versus retrieving a single monitor, but that distinction is not made explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'get_subscription_monitor' or how it relates to other monitor management tools. There is no mention of prerequisites, use cases, or exclusions, leaving the agent without directional context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

register_subscription_monitorA

Create a scheduled connectivity monitor for an Xray subscription URL.

ParametersJSON Schema
NameRequiredDescriptionDefault
timeout_secondsNo
interval_secondsNo
subscription_urlYes
node_name_keywordNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.5/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of disclosing side effects. It reveals the creation of a persistent scheduled monitor, but gives no details on idempotency, permissions, rate limits, or what happens at each scheduled run. This is minimal but not misleading.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no filler. Every word adds meaning, and it is front-loaded with the action ('Create...').

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has moderate complexity (4 params, 1 required) and no annotations, yet the description only covers the core action. It omits parameter meaning, scheduling behavior, and any caveats, making it incomplete for an agent to use confidently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must clarify parameters. It only implicitly touches on subscription_url ('subscription URL'), leaving timeout_seconds, interval_seconds, and node_name_keyword unexplained. This fails to compensate for the schema's lack of detail.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Create a scheduled connectivity monitor for an Xray subscription URL,' using a specific verb (create) and resource (scheduled monitor). It distinguishes from siblings like check_subscription_once by emphasizing 'scheduled' and 'monitor' rather than a one-time check.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this tool is for setting up recurring monitoring but does not explicitly state when to use it versus alternatives. It lacks a clear 'when-not-to-use' or mention of sibling tools like check_subscription_once for one-off checks.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

remove_subscription_monitorC

Remove a scheduled monitor.

ParametersJSON Schema
NameRequiredDescriptionDefault
watch_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

C2.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full disclosure burden. 'Remove' indicates a likely destructive action, but it does not state permanence, permission needs, or side effects on scheduled jobs. Minimal transparency for a deletion operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The six-word description is extremely short and front-loaded, but the brevity sacrifices substantive detail. It is not padded, yet under-specification makes it less useful than a slightly longer, structured description.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite a simple one-parameter, destructive operation, the description omits restoration mechanics, output/return behavior, and cannot differentiate from disabling. The presence of sibling tools and output schema do not compensate for these missing contextual details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The sole parameter 'watch_id' is only defined as a required string in the schema with 0% description coverage. The description never explains what watch_id refers to, where to obtain it, or its format, leaving the agent without sufficient information to populate it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a clear verb ('Remove') and identifies the resource ('a scheduled monitor'), aligning with the tool name. It is not as specific as 'remove subscription monitor' but sufficient to distinguish from monitor listing/running tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus siblings like 'set_monitor_enabled' or 'run_monitor_now'. The description offers no context or exclusions, so the agent must infer intended usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

run_monitor_nowC

Run a monitor immediately.

ParametersJSON Schema
NameRequiredDescriptionDefault
watch_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

C2.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It does not explain side effects, whether the action is asynchronous, whether it requires special permissions, or what consequences 'running a monitor' has. The word 'immediately' hints at direct execution but provides no further detail.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no wasted words. It is front-loaded and easy to parse, though its brevity results in under-specification rather than elegant conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of sibling tools and a required parameter, the description is severely incomplete. It fails to explain what a monitor run entails, how it relates to other subscription-monitor operations, or what the output schema represents. The agent is left without sufficient context to invoke the tool safely and correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has one required parameter (watch_id) with 0% description coverage. The description does not mention watch_id or any parameter semantics, leaving the agent to infer its meaning solely from the name 'watch_id' without additional context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('Run') on a specific resource ('a monitor') with a temporal qualifier ('immediately'). However, it does not differentiate from sibling tools, particularly 'check_subscription_once', which may also trigger a one-time check, leaving ambiguity about the exact distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description simply states the action without context, prerequisites, or exclusions, leaving the AI agent without clear decision criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

set_monitor_enabledC

Enable or disable a scheduled monitor.

ParametersJSON Schema
NameRequiredDescriptionDefault
enabledYes
watch_idYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

C2.6/5.0
Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It simply restates the action without explaining side effects, persistence, permission requirements, or what happens to the monitor when enabled/disabled. This is a significant gap for a mutating operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that is easy to parse. It is appropriately concise for such a simple tool, though it sacrifices detail for brevity. No unnecessary words are present.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity, the description is not entirely inadequate, but it lacks important context. It does not mention return values, whether the change is persistent, or any error conditions. With no annotations and an unhelpful schema, more explanation is needed for a complete picture.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides no property descriptions (0% coverage), and the description does not explain the meaning of 'watch_id' or 'enabled' beyond the implied toggle. The description adds no value to the parameter understanding, leaving the agent to guess at identifiers and boolean semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Enable or disable') and the resource ('a scheduled monitor'), making its purpose unambiguous. It also distinguishes itself from siblings like run_monitor_now (executes immediately) and register_subscription_monitor (creates a new monitor), as it specifically toggles the enabled state.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or cases where another sibling tool would be more appropriate. The intended context is only implicitly understood from the name and description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

  1. 7 tool updatesv0.1.0
    • First observedcheck_subscription_once
    • First observedget_subscription_monitor
    • First observedlist_subscription_monitors
    • First observedregister_subscription_monitor
    • First observedremove_subscription_monitor
    • First observedrun_monitor_now
    • First observedset_monitor_enabled

TDQS

B3.4/5.0

Scored across 7 tools

Disambiguation5/5

Each tool targets a distinct operation: creation, one-time check, listing, retrieval, manual run, enable/disable, and deletion. While run_monitor_now and check_subscription_once both perform connectivity checks, the former applies to an existing monitor while the latter is standalone, and descriptions clearly disambiguate them.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern using snake_case, with clear verbs such as register, check, list, get, run, set, and remove. The naming is uniform and predictable.

Tool Count5/5

Seven tools is well-scoped for a monitoring server, covering the full lifecycle without redundancy. Each tool serves a clear purpose and the count is neither too sparse nor overwhelming.

Completeness4/5

The tool set covers the full CRUD lifecycle (register, list/get, remove, set_enabled) plus a one-time check and manual run. The only notable gap is the lack of an update tool for modifying a monitor's subscription URL or schedule, but this is a minor limitation that can be worked around by removing and re-registering.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    C
    maintenance
    Read-only MCP server that monitors a Bitcoin Core full node via JSON-RPC, providing tools to check node status, network info, mempool, and peer information.
    MIT
  • A
    license
    A
    quality
    A
    maintenance
    MCP server for checking domain name availability via RDAP and WHOIS fallback, supporting single and bulk domain lookups.
    5
    MIT
  • A
    license
    A
    quality
    B
    maintenance
    MCP server for monitoring health of MCP servers, GitHub Actions, GitLab pipelines, and HTTP endpoints with health history, TLS expiry, assertions, diagnostics, and alerts.
    22
    92 npm
    2
    MIT