ros2-mcp-server

Server Quality Checklist

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

Latest release: v1.1.0
Disambiguation4/5
Most tools are clearly distinct, but system_diagnostics and get_robot_snapshot both report robot health, and predict_trajectory/predictive_safety_check could be confused at first glance. Descriptions help disambiguate, so the overlap is minor.
Naming Consistency3/5
The majority follow a verb_noun pattern (list_nodes, get_parameter, read_topic), but ping, system_diagnostics, and swarm_fleet_status break the convention with verb-only or noun-only names. The mix is readable but not fully consistent.
Tool Count4/5
With 16 tools, the count is slightly on the heavier side but appropriate for a ROS2 server that covers node inspection, parameter management, topic I/O, diagnostics, and advanced safety features. Each tool has a reasonable justification to exist.
Completeness4/5
The tool surface covers the core ROS2 interactions: listing nodes/topics, reading/writing parameters, publishing/subscribing to topics, and running diagnostics. It lacks direct service call support and topic lifecycle management, but these are minor gaps for the intended use in robot control.
Average 3.8/5 across 16 of 16 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 10 commits in the last 12 weeks
- Last stable release on July 22, 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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It mentions the conversion to an ASCII grid and that the output appears directly in the MCP response JSON, which is a useful behavior. Yet it does not disclose potential performance implications of processing LiDAR data, behavior on missing scan topics, latency, or any side effects. Given the tool's potentially heavy operation, this is a significant gap.
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 description is a single sentence, which is concise, but it includes the marketing phrase '[WORLD-FIRST]' that adds no functional value and could distract from the core information. The sentence is packed with detail but lacks a clear structure that separates purpose from usage context. It earns a middle score because it is not overly verbose, yet it contains superfluous hype and could be better organized.
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 has no annotations, no output schema, and two undocumented parameters, the description needs to provide substantial context. It explains the high-level purpose but does not cover parameter semantics, output format beyond 'ASCII grid', edge cases, or prerequisites (e.g., active LiDAR topic). The description leaves too many unknowns for an agent to confidently invoke the tool correctly in varied scenarios.
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?
Schema description coverage is 0%, and the description provides no explanation of the two parameters (grid_size and scan_topic). An agent invoking the tool would have no hints about valid values, units, or how these parameters affect the output. The description does not compensate for the schema's lack of documentation, making parameter usage entirely opaque.
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: converting 360° LiDAR pointclouds into a 2D ASCII spatial radar grid. It uses specific verbs and resources ('converts', 'LiDAR pointclouds', 'ASCII spatial radar grid') and mentions the output location in the MCP response, which differentiates it from simply reading raw topics. However, it does not explicitly contrast with sibling tools like read_topic or get_robot_snapshot, so it misses full sibling 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 the tool is for gaining spatial awareness in LLMs ('allowing text & vision LLMs to see surrounding space'), providing clear context for when it might be used. However, it offers no explicit guidance on when not to use it or what alternative tools exist (e.g., read_topic for raw pointcloud data). The use-case framing is useful but lacks explicit exclusions or comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for behavioral disclosure. It only says 'Read' which implies non-mutating, but it does not explain what 'with safety bounds' entails, what happens if the node or parameters are missing, or whether any state is changed. The ambiguity around 'safety bounds' leaves significant gaps.
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 with no wasted words. However, the phrase 'with safety bounds' is vague and may add confusion rather than clarity, preventing a perfect score.
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 is relatively simple but has four parameters and no output schema. The description does not mention return values, error behavior, or distinguish from similar tools like get_parameter. Given the complexity and lack of annotations/schema descriptions, it is far from complete.
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 schema has 0% description coverage and the tool description does not clarify how the four parameters are used. It mentions Kp, Ki, Kd but does not map them to the kp_param, ki_param, kd_param fields nor explain what node_name is for. The description fails to compensate for the lack of schema explanations.
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 ('Read') and the target resource ('Kp, Ki, Kd gains from a PID controller node'), making it easy to identify the tool's purpose. It distinguishes itself from generic tools like get_parameter by being specific to PID gains.
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. It does not mention that get_parameter could be used for single gains or that tune_pid is for adjusting gains, so the agent has no context for choosing this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden. It discloses that it evaluates, auto-corrects, and returns proof, but it does not clarify whether it mutates system state or only returns corrected values, what happens when the input is safe, or any side effects. 'Auto-correcting' is ambiguous—whether it actually applies the correction or just suggests it—which is a significant gap for a tool that might affect the robot.
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 core sentence is information-dense and to the point, covering evaluation, auto-correction, and proof output. However, the '[WORLD-FIRST]' prefix is noise and does not earn its place, and there is no structural breakdown (e.g., separate sections for behavior and parameters). It is concise but not perfectly clean.
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?
This is a complex tool with no output schema and no annotations. The description mentions returning mathematical proof but does not specify the return structure (e.g., fields like safe, corrected_value, proof), nor does it describe error cases, limits, or preconditions. Given the tool's potential to affect commands, the description is insufficient for an agent to use it correctly without guessing.
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 100%, so the baseline is 3. The description adds some context by mentioning 'parameter or velocity commands' and 'auto-correcting', which aligns with the parameters, but it does not add substantial meaning beyond the schema. The parameter descriptions themselves are minimal and the tool provides no extra detail about required value formats or constraints.
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 uses a specific verb ('evaluates') and identifies the resource ('proposed parameter or velocity commands') and the criterion ('against dynamic stability bounds'). It also mentions auto-correction and returning proof, clearly distinguishing this from sibling tools like publish_topic or set_parameter, which execute commands directly.
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 its usage for safety-checking proposed commands ('proposed parameter or velocity commands', 'unsafe LLM inputs') but does not explicitly state when to use it instead of directly calling publish_topic or set_parameter, nor does it mention exclusions or alternatives. This leaves the agent to infer the appropriate context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose safety and behavioral traits. It indicates a read-style scanning operation, but does not mention return format, potential side effects (though likely none), cost/performance, or failure modes. The 'WORLD-FIRST' hype and vague 'health' terminology add little. This is insufficient for a tool with no annotation support.
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 sentence that front-loads the action. It is concise, but the leading '[WORLD-FIRST]' is unnecessary hype that wastes space. Otherwise well-structured.
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?
Without annotations or an output schema, the description needs to explain what 'fleet health' means and what the aggregate result looks like. It does not. The tool seems simple in parameters, but the output semantics are undefined, making the description incomplete for an agent to fully predict the tool's behavior.
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 schema (empty) already fully covers parameter semantics. The description adds no parameter info, but none is needed. Baseline 4 is appropriate.
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: 'Scans multi-namespace ROS2 graph' and aggregates 'multi-robot fleet health in one call.' This distinguishes it from sibling tools that operate on individual nodes, topics, or parameters.
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 phrase 'in one call' implies convenience over calling per-robot tools, and the multi-namespace scope suggests when to use it. However, there is no explicit guidance on when not to use it or how it compares to calling get_robot_snapshot individually. Usage context is implied but not fully articulated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. However, it only restates the basic action of listing nodes and offers no additional context about side effects, read-only nature, connectivity requirements, or return format. The description adds minimal value beyond the tool name.
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, succinct sentence that is front-loaded with the main action and resource. It conveys the essential information without any filler or redundancy.
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 simple with no parameters and no output schema, so the description is mostly adequate. It specifies that namespaces are included in the listing, which gives some idea of the return content. However, it could be slightly more explicit about the output structure (e.g., a list of node names with their namespaces), though this is not a critical gap.
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 input schema is empty with no parameters, so there is no parameter information to explain. The baseline for zero parameters is 4, and the description correctly makes no parameter claims. No additional semantics are needed.
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 lists all currently running ROS2 nodes and includes namespaces. The verb 'list' is specific, the resource is identified, and it distinguishes from sibling tools like get_node_info and list_topics.
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 about when to use this tool versus alternatives. There is no mention of when not to use it or how it relates to get_node_info or list_topics. The description simply states what it does without contextual usage advice.
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?
With no annotations, the description must carry the transparency burden. It does add useful behavioral context: it is a simulation, runs at 1000Hz, and computes in under 0.1ms. However, it does not disclose what the output looks like or whether any state changes occur, leaving some uncertainty for an agent.
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 sentence and front-loaded with the core purpose. It loses one point for the unnecessary '[WORLD-FIRST]' marketing phrase, which is extraneous for an AI agent.
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 no output schema, so the description should explain what the simulation returns. It does not, and it also omits any prerequisites or side effects. For a tool that is meant to pre-validate trajectory commands, this is a notable gap.
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 100% coverage of parameter descriptions (linear_x, angular_z, dt_sec). The description adds minimal extra meaning by mentioning 'over time dt_sec' and implying the velocities are inputs, but it does not enrich the semantics 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 uses a specific verb ('Pre-simulate') and clearly identifies the resource (robot trajectory) with coordinates and time. It also distinguishes from siblings by emphasizing the simulation happens before sending commands to hardware, which is a unique purpose among the listed tools.
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 states the tool is used 'BEFORE sending commands to hardware', which gives clear context for when to use it. However, it does not explicitly mention when not to use it or name alternative tools, so it stops short of full guidance.
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?
With no annotations, the description carries the full burden. 'Inspect' implies a read-only operation, and 'exact name match' adds a useful behavioral constraint. However, it does not clarify what 'related topics' includes (e.g., published/subscribed) or what the return format is, leaving some ambiguity.
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, focused sentence without unnecessary words. It front-loads the action and resource, making it easy to parse.
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 simple with one parameter, no output schema, and no annotations. The description adequately explains the core behavior and result (finding related topics), though it could be more explicit about what 'related topics' means. Given the simplicity, this is sufficient.
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 covers the only parameter (node_name) with a description and example, so the description adds no additional semantic value. The baseline of 3 applies because schema coverage is 100%.
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 inspects a specific ROS2 node and finds its related topics, using a specific verb and resource. It distinguishes itself from siblings like list_nodes and list_topics by focusing on a single node's related topics, though it does not explicitly name alternatives.
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 'specific ROS2 node' implies the tool is for targeted inspection rather than listing all nodes or topics. This provides clear context for when to use it, but it does not explicitly state exclusions or alternatives, so it stops short of a 5.
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?
With no annotations, the description carries the behavioral burden. It communicates a non-destructive read operation and the prerequisite that the node must be running, but it does not disclose error handling, permissions, or potential side effects beyond the inherent read behavior.
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, focused sentence with no wasted words. It is concise, front-loaded, and effectively communicates the core functionality.
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 two-parameter read operation with no output schema, the description adequately covers the essential context: what it does and the prerequisite that the node is running. It lacks details on return format or failure modes, but these are not critical for a basic read tool.
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. While it does not explicitly define node_name or param_name, the context 'from a running ROS2 node' and 'parameter value' provide implicit meaning. The parameter names are self-explanatory, but no additional format or constraint details are given.
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 reads a live parameter value from a ROS2 node, using the specific verb 'Read' and resource 'parameter value'. It distinguishes itself from sibling tools like set_parameter by focusing on reading rather than setting.
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 context ('from a running ROS2 node') but does not explicitly state when to prefer this tool over alternatives or mention exclusions. The contrast with set_parameter is implicit, not explicit.
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?
Discloses return payload (serialized message, data age) and latched behavior. However, no annotations are present, and it fails to mention timeout/failure behavior or what happens if no message is available. Moderate transparency.
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?
Two concise sentences that front-load the core purpose and include a practical usage tip. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple read tool with good schema coverage. However, no output schema exists, so the description should more precisely define the return structure beyond 'serialized message'. Also omits error and timeout behavior.
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 100%, so baseline is 3. Description adds a note about latched topics, but this is already in the schema. No significant additional parameter meaning beyond 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?
Clearly states the verb 'read' and resource 'ROS2 topic', and specifies it retrieves the latest message. Distinguishes itself from sibling tools like list_topics and publish_topic.
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?
Provides explicit conditional guidance for latched topics ('set latched=true'). Does not discuss when to use this tool instead of alternatives, but the context is clear for this read operation.
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 important behaviors: gains are validated before reaching hardware, negative gains are rejected, and tuning guidance is returned. With no annotations, this significantly helps the agent understand safety and side effects. However, it does not mention whether changes are persistent or could disrupt the running controller, leaving some transparency gaps.
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 two sentences long, front-loaded with the primary purpose, and contains zero redundant phrases. Every sentence contributes necessary behavioral or output information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 7 parameters, no output schema, and no annotations, the description provides a clear core behavior but leaves meaningful gaps: it does not explain the *_param parameters, any prerequisites like node type, or the structure of the tuning guidance. This makes it adequate but not fully complete.
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 coverage is 43%, with only the gain parameters described as 'must be >= 0'. The description reinforces this by stating negative gains are rejected, adding value for those params. However, the *_param parameters are completely unexplained, and node_name lacks description. The description does not compensate for the coverage gap.
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 uses a specific verb ('Apply') and identifies the resource ('new PID gains to a controller node'). It clearly distinguishes this tool from siblings by mentioning safety validation and tuning guidance, which set_parameter and get_pid_state do not.
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 its use for PID tuning but does not explicitly state when to prefer it over alternatives like set_parameter or get_pid_state. It also omits any preconditions, such as the node being a controller node or the need to stop the controller, so 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the burden of behavioral disclosure. It mentions sandbox behavior, which is useful context. However, it does not elaborate on potential errors, side effects, or output behavior, leaving some gaps for a publish operation.
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 two concise sentences, front-loaded with the purpose and immediately providing sandbox context. No wasted words.
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 simple, and the description covers its main function and sandbox constraints. No output schema is needed. Given the low complexity and rich schema/annotations, the description is sufficiently complete.
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 coverage is 100%, with all three parameters described. The description adds no extra meaning beyond the schema, so the baseline score of 3 is appropriate.
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 purpose: 'Publish a message to a ROS2 topic.' It uses a specific verb and resource, and distinguishes itself from sibling tools like read_topic and list_topics.
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?
Provides clear context by explaining sandbox mode restrictions (blocked in READ_ONLY, allowlisted in SAFE_WRITE), which implicitly tells the agent when it can be used. However, it does not explicitly name alternatives or mention when to prefer other tools.
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?
Since no annotations are provided, the description carries the full burden. It explicitly discloses that the tool is a mutation ('update') and introduces the sandbox/allowlist restriction, which is important safety context. It does not detail error handling or reversibility, but the core behavioral traits are covered.
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?
Two sentences, front-loaded with the primary action, and every word adds value. The safety constraint is included without unnecessary padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description captures the core purpose and safety restriction, but with no output schema and no parameter details, the agent lacks information about return values, error conditions, or how to discover allowlisted parameters. It is adequate but not complete.
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 only 33%, and the description adds no parameter-level details. The value field is documented in the schema, but node_name and param_name are left without explanations. The description does not compensate for the low 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 the tool's function with a specific verb ('update') and resource ('parameter on a running ROS2 node'). It distinguishes from sibling tools like get_parameter (read) and tune_pid (specialized tuning).
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?
Provides clear contextual constraints: the tool operates on running ROS2 nodes and only allowlisted parameters in SAFE_WRITE mode. However, it does not explicitly mention alternatives or exclusions (e.g., when to prefer tune_pid or get_parameter).
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?
With no annotations, the description carries the full burden. It discloses that only active topics are listed and that message types are included, which is transparent for a read-only listing. However, it does not explain what 'active' means in practice or any edge cases, leaving some ambiguity.
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, well-structured sentence with no wasted words. It front-loads the action and clearly conveys the tool's purpose.
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 params, no annotations, no output schema—the description is complete. It states exactly what the tool does and what information is returned (topics and message types), fully meeting the needs for this context.
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 there is nothing to explain. The description appropriately does not mention parameters, and the baseline for 0 params is 4.
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 uses a specific verb 'List' with a clear resource 'ROS2 topics' and adds scope ('active') and output detail ('message types'). It distinguishes from siblings like 'list_nodes' (lists nodes) and 'read_topic' (reads topic data) by focusing on topic metadata.
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 its use for enumerating available topics with their types, but it does not explicitly state when to use it versus alternatives, nor does it mention exclusions or prerequisites. No explicit guidance is provided.
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?
With no annotations, the description carries the full behavioral burden. It adds useful context by mentioning 'parallel call' and 'faster,' but it does not explicitly state side effects, error handling, or the read-only nature, leaving some ambiguity for a fetch operation.
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 only two sentences, front-loaded with the tool's core function and followed by a performance rationale. Every word contributes value, with no redundant or extraneous information.
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 no-parameter tool with no output schema, the description sufficiently states the input (none) and the output data types (LiDAR, IMU, battery, cmd_vel, odometry). It could elaborate on return format or failure behavior, but given the simplicity of the tool, the description is adequately 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, so the schema already fully documents the input (empty properties). The description does not need to add parameter meaning, and the baseline of 4 applies because there are no parameters to explain. The description correctly implies that no configuration is needed.
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 fetches LiDAR, IMU, battery, cmd_vel, and odometry in one call, specifying a concrete verb and resource. It distinguishes itself from sibling tool read_topic by aggregating multiple topics, so an agent can easily identify its unique 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 provides a clear usage context by stating it is faster than calling read_topic five times sequentially, which implies when to prefer this tool over the alternative. It does not explicitly list exclusions or when not to use it, but the comparison to read_topic serves as a practical guideline.
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?
No annotations are provided, so the description carries the full burden. It discloses the exact return data (battery, LiDAR, IMU, node count, issues/warnings) and implies a read-only check. Minor gap: it does not explicitly state whether running the check has side effects or takes time.
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 two sentences, front-loaded with purpose and output list, and the second sentence gives decisive usage guidance. No wasted words.
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 zero-parameter tool with no output schema, the description fully covers what the tool does, what it returns, and when to invoke it. It is complete in context.
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 needs to add no parameter context. The rubric sets a baseline of 4 for zero-param tools, and there is no missing parameter information.
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 uses a specific verb 'Run' and a clear resource 'full robot health check', enumerating concrete outputs (battery level, LiDAR status, IMU health, active node count, critical issues/warnings). The trigger phrase 'what's wrong?' or 'is the robot ready?' differentiates it from more granular sibling tools like list_nodes or get_pid_state.
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?
It provides explicit when-to-use guidance: 'ALWAYS call this first when the user asks...' This gives clear context. However, it does not mention when not to use it or name alternative tools, so a full 5 is not warranted.
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?
With no annotations provided, the description carries the full burden. It discloses the behavior of testing connectivity and returning status and node count, which is appropriate for a ping tool. It does not detail possible failure modes or timeouts, but these are implicitly understood for a connectivity check.
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 two sentences, front-loaded with the action verb 'Test,' and each sentence adds critical information: what it does and when to use it. No wasted words.
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 ping tool with no parameters, the description is sufficient. It covers purpose, output, and usage context. It could elaborate on what 'status' includes or potential error responses, but that is not essential for an agent to correctly invoke the tool.
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 baseline is 4. The description correctly omits parameter details as there are none, and this does not need further explanation.
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: 'Test the connection to the ROS2 bridge.' It also specifies the output ('Returns status and active node count') which distinguishes it from sibling tools like list_nodes or system_diagnostics that have different scopes.
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 gives explicit usage guidance: 'Call this before any other tool to verify the server is reachable.' This tells the agent exactly when to use this tool and that it should be a prerequisite for other operations.
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:

[![ros2-mcp-server MCP server](https://glama.ai/mcp/servers/EngineerAbdullahBinZafar/ros2-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/EngineerAbdullahBinZafar/ros2-mcp-server)

Score Badge

Copy to your README.md:

[![ros2-mcp-server MCP server](https://glama.ai/mcp/servers/EngineerAbdullahBinZafar/ros2-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/EngineerAbdullahBinZafar/ros2-mcp-server)

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/EngineerAbdullahBinZafar/ros2-mcp-server'

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