USBTMC MCP Server

by NaoNaoMe

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct operation: discovery, connection, communication, recovery, vendor unlock, and vendor-specific screenshots. The only potential confusion between list_devices and list_connected_devices is resolved by clear descriptions.
Naming Consistency5/5
All tools follow a usbtmc_<verb>_<noun> pattern in lowercase snake_case, with consistent verb-first ordering and vendor qualifiers where needed.
Tool Count5/5
11 tools is well-scoped for a USBTMC server, covering the full workflow without excessive fragmentation.
Completeness5/5
The tool set covers the complete lifecycle from discovery to disconnection, including send/receive/query for SCPI communication, recovery via clear, and vendor-specific features for Keysight and Tektronix.
Average 4.2/5 across 11 of 11 tools scored. Lowest: 3.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- Last stable release on February 11, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds return value details (success flag, disconnected device_id, product name, message) but does not disclose further behavioral traits such as failure modes or whether the connection becomes unusable. No contradictions with annotations.
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 structured with Args and Returns sections, making it easy to scan. It is reasonably concise, with each statement providing useful information. Minor redundancy exists with the schema description, but the format is effective.
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 disconnect operation with one parameter, the description covers the input meaning, return values, and success/error messaging. It lacks explicit preconditions or edge-case behavior, but given the annotations and the parameter hint about usbtmc_connect(), it is sufficiently 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 description explicitly documents the required parameter device_id, explaining it as the unique identifier returned by usbtmc_connect(). It also describes the return structure, which clarifies the parameter's effect. Even though the schema also has a description, the signal indicates low schema coverage, and this description compensates well.
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 (Disconnect) and resource (specific USBTMC device), making its purpose unambiguous. It does not explicitly distinguish itself from siblings beyond the verb, but the scope is clear and specific.
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 parameter description says the device_id is returned by usbtmc_connect(), which implies the tool is used after a connection is established. However, there is no explicit when-to-use or when-not-to-use guidance, nor any mention of alternatives, so usage context is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark readOnlyHint=true and destructiveHint=false. The description adds the prerequisite that device_id comes from usbtmc_connect(), implying an active connection is needed. However, it does not explain capture behavior, potential failures, or format of the returned image.
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?
Description is a short, front-loaded purpose sentence followed by compact parameter and return notes. It avoids unnecessary prose, though the Args section duplicates schema info.
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 read-only capture tool with a single well-documented parameter and good annotations, the description covers the essential invocation details. It lacks explicit sibling differentiation and output format detail, but the name and annotations fill some 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?
The schema fully describes device_id with type, range, and provenance ('returned by usbtmc_connect()'). The description repeats this information without adding new semantics, so it provides no value beyond the schema.
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 'Capture screenshot from a Tektronix oscilloscope', providing a specific verb, resource, and brand distinction from the Keysight sibling tool. This fully defines the tool's purpose.
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 offers no guidance on when to use this tool versus the alternative usbtmc_screenshot_keysight_display. It does not mention device compatibility conditions or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the return format and example but no additional behavioral traits such as edge cases or limitations. Given the annotation coverage, the description provides minimal extra behavioral information.
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 well-structured with a clear first sentence, workflow list, and example. It is slightly verbose for a parameterless tool, but the extra information about return format and workflow is useful. It earns its length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (no parameters), and the description fully covers purpose, when to use, return structure, and an example. Despite the existence of an output schema, the description itself provides sufficient detail for an agent to invoke correctly.
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, so the description need not explain parameter semantics; the baseline of 4 applies. The schema confirms no parameters, and the description correctly focuses on return values.
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 tool's function: 'List all available USBTMC devices connected via USB.' It also provides a workflow showing it's the discovery step. However, it doesn't explicitly differentiate from the sibling tool usbtmc_list_connected_devices, which may have overlapping purpose.
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 description includes a numbered workflow: 'usbtmc_list_devices() - Discover available devices' and labels it as 'typically the first step.' This gives clear context for when to use it, but it does not mention when not to use it or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds value by detailing the return structure and providing an example, which clarifies expected output behavior. No contradictory or missing behavioral traits are evident.
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 well-structured, leading with the main action, followed by a clear Returns section and a concrete example. Every sentence contributes useful information without being overly verbose, making it efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, read-only, output schema present), the description is complete. It fully specifies the returned fields (count, devices with device_id, manufacturer, product, serial_number) and includes an illustrative example, leaving no major gaps.
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?
This tool has zero parameters, so the baseline is 4. The description correctly avoids parameter details, and the input schema (empty properties) confirms no parameters need explanation.
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 'List all currently connected (active) USBTMC devices', which is a specific verb+resource. However, it does not explicitly distinguish this from the sibling tool 'usbtmc_list_devices', though the 'connected' qualifier provides some differentiation.
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 usage for retrieving currently connected USBTMC devices, but provides no explicit when-to-use guidance or alternatives. It does not mention when to prefer this over 'usbtmc_list_devices' or other siblings, leaving the agent to infer the use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the safety profile is known. The description adds the return type (Image) but lacks details on error behavior, prerequisites beyond device_id, or any side effects. It does not contradict annotations.
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 concise and well-structured, with a one-sentence purpose statement followed by clearly labeled Args and Returns sections. Every line earns its place with no redundancy or fluff.
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 read-only tool, the description covers the essential aspects: what it does, which vendor it supports, the required parameter, and the return type. It does not cover error conditions or image format, but the low complexity and strong annotations make this acceptable.
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?
Despite the 0% schema description coverage signal, the description explicitly documents device_id and its source (usbtmc_connect()), which compensates for the lack of schema-level descriptions. It provides clear meaning and provenance for the only parameter.
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 action (capture screenshot) and the resource (Keysight/Agilent oscilloscope), which distinguishes it from the Tektronix sibling tool. The vendor-specific naming removes ambiguity about which device family it applies to.
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 usage for Keysight/Agilent devices but does not explicitly mention when to use it versus the Tektronix sibling or provide exclusions. The context is present but not spelled out, leaving the agent to infer the alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that this function only sends data and does not read responses, and it outlines the return dict structure. It also notes the need for separate receive/query operations. This adds context beyond the annotations, though it does not discuss potential device-side effects or idempotency nuances. Minor inconsistency with schema examples querying commands, but overall transparent.
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 well-structured with purpose, usage guidance, args, and returns. It is reasonably concise, though the usage guidance and send-only note are slightly repetitive. Every sentence earns its place, but the redundancy prevents a perfect score.
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?
Given the tool's simplicity and the presence of an output schema, the description covers the essential aspects: what it does, when to use it, parameters, and return values. It does not mention error handling or edge cases, but the return message field addresses that. Overall, it is complete for practical use.
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?
The schema already provides detailed descriptions for device_id and command, including examples. The description's Args section repeats this information without adding new semantic meaning. It does helpfully frame the command as a SCPI string and device_id as a connection identifier, but this does not significantly exceed schema coverage.
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 'Send a SCPI command to a specific USBTMC device' with a specific verb and resource. It also distinguishes itself from siblings by explicitly directing query commands to usbtmc_query(), making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells the agent when to use this tool ('Use for SET commands (without '?')') and when to use alternatives (usbtmc_query() for queries, usbtmc_receive() for reading responses). This is model guidance with named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=false, idempotentHint=false, destructiveHint=false), the description discloses important behaviors: the need for a unique match, failure when multiple devices match, and a limit of 16 simultaneous connections. This adds meaningful context that annotations do not cover.
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 well-structured with a clear opening statement, then Args, Returns, and Note sections. It is slightly longer than necessary but every section adds valuable information without redundant fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers success and error return formats, the purpose of device_id, uniqueness requirements, and connection limits. Given the tool's complexity (nested parameters, failure modes, connection lifecycle), this is a complete and self-sufficient description.
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?
Schema description coverage is 0%, so the description compensates by listing all three parameters (manufacturer, product, serial_number) and their roles, including noting serial_number as 'most specific.' While schema descriptions already contain similar details, the description provides the functional context needed to choose criteria.
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 function with a specific verb and resource: 'Connect to a USBTMC device and receive a device_id for subsequent operations.' It distinguishes itself from sibling tools by focusing on establishing a connection, not listing, sending, or disconnecting.
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 description implies when to use the tool (before subsequent operations) and provides guidance on how to avoid failure: 'If multiple devices match the criteria, the connection will fail - provide more specific criteria.' It does not explicitly mention alternatives, but the context is clear enough without them.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds behavioral detail beyond annotations: it specifies the return dict with 'success', 'device_id', 'data' (or None on timeout), and 'message', and notes the default for max_bytes. This gives the agent useful expectations about timeouts and result structure, though it doesn't mention blocking behavior or partial reads.
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 well-structured docstring with a one-line summary, a compact Args block, and a Returns block. Every sentence carries necessary information, and the format is front-loaded with the primary purpose before details. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple receive tool, this description is complete. It includes an implicit output schema via the Returns section, covering success and error message fields, the data field with a timeout condition (None), and the device_id echo. With annotations covering read safety, the agent has sufficient context to select and invoke the tool correctly.
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 schema coverage is 0% per context, so the description must compensate for parameter meaning. It does: 'device_id (int): The unique identifier returned by usbtmc_connect()' clarifies the handle semantics, and 'max_bytes (int): Maximum bytes to read (default: 1024)' explains the read limit. This adds meaningful semantic value even though the nested schema also contains descriptions; the description makes the connection to the sibling tool explicit.
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 opens with a specific verb+resource statement: 'Receive data from a specific USBTMC device.' This clearly distinguishes it from siblings like usbtmc_send (send data), usbtmc_query (send-then-receive), and usbtmc_connect (establish connection). The title 'Receive Data from Device' further reinforces the purpose.
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 first line establishes a clear use case (receiving data). The Args section notes that device_id is 'returned by usbtmc_connect()', implying a prerequisite connection. However, it does not explicitly state when NOT to use this tool or name alternatives (e.g., 'for query/response use usbtmc_query'), so it lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=false, idempotentHint=true, etc.), the description discloses a critical side effect: devices will re-enumerate on the USB bus and the agent must wait before listing them. It also indicates that the result includes an error list, but it does not discuss permissions or non-Keysight devices, though that is arguably beyond the scope given the empty schema.
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 well-structured and concise: one purpose sentence, a two-sentence background, a clear post-usage instruction, and a cleanly formatted return-value block. Every sentence earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool takes no parameters and has a detailed output schema, the description is fully complete: it states the purpose, when to use it, the re-enumeration side effect, and the return structure. There are no missing pieces for an agent to invoke it correctly.
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, so the description correctly requires no input. Per the rule for 0-parameter tools, the baseline is 4. The description does not add parameter details because there are none to add.
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 opens with 'Switch all Keysight devices from firmware update mode to USBTMC mode,' a clear verb-object with scope. This directly distinguishes it from sibling tools like usbtmc_list_devices or usbtmc_connect by specifying the exact action and target device type.
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 description explains the triggering condition (some Keysight devices power on in firmware update mode) and gives a concrete workflow: call this function, wait, then call usbtmc_list_devices. It does not explicitly say when not to use it, but the context implies it is only for devices in firmware mode, making usage sufficiently clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate the tool is mutating, idempotent, and non-destructive. The description adds valuable context about what gets cleared (input/output buffers) and that it resets communication state. It also discloses the return structure. This goes beyond annotations and provides useful behavioral insight, so 4 is warranted.
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 succinct and well-structured. It leads with the core purpose, then usage, then parameters, then return values. Every sentence serves a purpose, and there is no fluff. It is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple single-parameter nature, the description covers all essential aspects: what the tool does, when to use it, the parameter meaning, and the return value. Annotations provide additional safety cues. The description is complete and leaves no significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite the schema description coverage being 0%, the description explicitly explains the parameter: 'device_id (int): The unique identifier returned by usbtmc_connect().' It fully conveys the meaning and origin of the parameter, effectively compensating for any schema gaps. The single parameter is well-documented.
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: 'Clear the device input/output buffers and reset communication state.' This is a specific verb and resource, distinguishing it from sibling tools like send/receive/query. The purpose is unambiguous and immediately understandable.
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 description provides explicit usage context: 'Use this to recover from communication errors or stuck states.' This tells when to use the tool, but it does not mention when not to use or contrast with alternatives. Since it gives clear context without explicit exclusions, a score of 4 is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behavioral details beyond the minimal annotations: it is a convenience function combining send and receive, waits between operations, and returns None if no data/timeout. It also provides wait-time recommendations for different command types, offering practical behavioral context that the annotations do not convey.
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 well-structured with a concise opening sentence, explicit usage rule, Args/Returns sections, and a practical Note. Every sentence adds relevant information—nothing is redundant or filler—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.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one nested parameter object and a non-trivial timing behavior, the description is complete: it covers purpose, when to use, all input fields with defaults, return fields, and time-wait recommendations. It gives an agent everything needed to select and invoke the tool correctly without guessing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Even though the schema description coverage is reported as 0%, the tool description thoroughly compensates by enumerating all four fields (device_id, command, wait_time, max_bytes), their meanings, defaults, and even usage guidance for wait_time. This adds clear semantic value beyond the raw schema.
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 opens with a clear, specific verb and resource: 'Send a SCPI command and immediately receive the response.' It explicitly frames the tool as the query variant and distinguishes it from usbtmc_send() by mentioning SCPI commands with '?'. This makes the tool's purpose unambiguous and differentiates it from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states exactly when to use this tool: 'Use for QUERY commands (with '?') that request information from the device.' It also explicitly names the alternative: 'For SET commands (without '?'), use usbtmc_send() instead.' This direct when-to-use/when-not-to-use guidance is exemplary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![usbtmc-lite-mcp MCP server](https://glama.ai/mcp/servers/NaoNaoMe/usbtmc-lite-mcp/badges/card.svg)](https://glama.ai/mcp/servers/NaoNaoMe/usbtmc-lite-mcp)

Score Badge

Copy to your README.md:

[![usbtmc-lite-mcp MCP server](https://glama.ai/mcp/servers/NaoNaoMe/usbtmc-lite-mcp/badges/score.svg)](https://glama.ai/mcp/servers/NaoNaoMe/usbtmc-lite-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/NaoNaoMe/usbtmc-lite-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server