xray-mcp-monitor
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@xray-mcp-monitorcheck subscription https://mysub.link"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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
httpandhttpsURLsParses raw URI lists and common base64-encoded subscription payloads
Supports
vmess,vless,trojan,ss,socks,http, andhttpsRecognizes
hy2,hysteria,hysteria2, andtuic, but marks them unsupported for probingRuns 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, andsse
Related MCP server: domain-mcp
How It Works
A client calls
register_subscription_monitororcheck_subscription_once.The server fetches the subscription payload from the provided URL.
The payload is parsed into Xray nodes.
Each matched TCP node is checked with a direct
host:portTCP connection.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_secondsmust be at least10.timeout_secondsmust be greater than0.
Requirements
Python
>=3.10mcp[cli] >=1.27,<2
Install
Using pip:
python3 -m venv .venv
./.venv/bin/pip install -e .Using uv:
uv syncRun The Server
Stdio transport:
./.venv/bin/python -m xray_mcp_monitor.serverStreamable HTTP transport:
./.venv/bin/python -m xray_mcp_monitor.server --transport streamable-httpSSE transport:
./.venv/bin/python -m xray_mcp_monitor.server --transport sseYou can also use the installed console script:
./.venv/bin/xray-mcp-monitorManage scheduled checks without Codex:
./.venv/bin/xray-mcp-monitor-cli --helpRun the web dashboard:
./.venv/bin/xray-mcp-monitor-web --helpEnvironment 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.jsonXRAY_MCP_TRANSPORT: default transport when--transportis omittedXRAY_MCP_HOST: bind host for network transportsXRAY_MCP_PORT: bind port for network transportsXRAY_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 hkList stored watches:
./.venv/bin/xray-mcp-monitor-cli \
--state-file /root/xray-mcp/.codex/xray_watch_state.json \
listRun 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 daemonYou can also use:
./.venv/bin/python -m xray_mcp_monitor cli listThe 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 8080Then open:
http://127.0.0.1:8080The 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 8080systemd 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-monitorAfter that:
sudo systemctl status xray-mcp-monitor
journalctl -u xray-mcp-monitor -fBefore 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-webCheck logs with:
sudo systemctl status xray-mcp-monitor-web
journalctl -u xray-mcp-monitor-web -fIf 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: strinterval_seconds: int = 300timeout_seconds: float = 5.0node_name_keyword: str | None = None
check_subscription_once
Fetch a subscription and run a one-time check without storing a monitor.
Parameters:
subscription_url: strtimeout_seconds: float = 5.0node_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: strenabled: bool
remove_subscription_monitor
Remove a stored monitor.
Parameters:
watch_id: str
Status Values
Watch-level statuses:
error: fetching the subscription failedempty: no nodes were foundno_match: nodes were parsed, but none matchednode_name_keywordhealthy: all matched nodes were reachablehealthy_with_warnings: all matched nodes were reachable, but some non-fatal parse warnings were recordeddegraded: some matched nodes were reachable and some were unreachablepartial: some matched nodes were reachable and some were unsupportedunsupported: all matched nodes were unsupported for probingdown: no matched nodes were reachable
Node-level statuses:
reachableunreachableunsupported
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 operationswatch.last_result: latest stored result for a scheduled monitorresult.status: current overall health stateresult.nodes: per-node reachability, latency, and error detailsresult.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-mcpInside 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 testsUseful 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_monitorAvailable Tools
7 toolscheck_subscription_onceB
Fetch a subscription URL and run a one-time connectivity check.
| Name | Required | Description | Default |
|---|---|---|---|
| timeout_seconds | No | ||
| subscription_url | Yes | ||
| node_name_keyword | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| watch_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| timeout_seconds | No | ||
| interval_seconds | No | ||
| subscription_url | Yes | ||
| node_name_keyword | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| watch_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| watch_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| enabled | Yes | ||
| watch_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
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.
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.
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.
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.
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.
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.
7 tool updates
v0.1.0- First observed
check_subscription_once - First observed
get_subscription_monitor - First observed
list_subscription_monitors - First observed
register_subscription_monitor - First observed
remove_subscription_monitor - First observed
run_monitor_now - First observed
set_monitor_enabled
TDQS
Scored across 7 tools
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.
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.
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.
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
Related MCP Connectors
Cloud-hosted MCP server for URnetwork VPN and Proxy
Conformance checker for MCP servers. Free, no key, verdicts recomputable and re-measured daily.
Experimental MCP server for current empirical verification of explicit public HTTPS endpoint claims.
Trust, freshness, policy, and discovery layer for public MCP servers.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceRead-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
- AlicenseAqualityAmaintenanceMCP server for checking domain name availability via RDAP and WHOIS fallback, supporting single and bulk domain lookups.5MIT
- MIT
- AlicenseAqualityBmaintenanceMCP server for monitoring health of MCP servers, GitHub Actions, GitLab pipelines, and HTTP endpoints with health history, TLS expiry, assertions, diagnostics, and alerts.2292 npm2MIT