Skip to main content
Glama

Server Details

Search robot code and exact-version findings; check evidence before preparing with the Hub CLI.

If you are the author of this connector, you can claim ownership by verifying the domain or GitHub account it belongs to. Claimed connector authors can inspect health checks, view analytics, and manage their listing.
Status
Healthy
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
Repository
Superfast-Robotics/robot-skill-hub
GitHub Stars
0
Server Listing
robot-skill-hub

TDQS

A3.5/5.0

Scored across 3 tools

Disambiguation5/5

Each tool targets a distinct operation: find_robot_skills searches the catalog, get_hub_capabilities reads hub-level metadata, and inspect_robot_skill reads one pinned recipe in detail. The descriptions explicitly bound each one (search vs. read vs. capability discovery), leaving little room for misselection.

Naming Consistency5/5

All three tools follow a clean verb_noun snake_case pattern (find_robot_skills, get_hub_capabilities, inspect_robot_skill). Verb choice varies (find/get/inspect) but is meaningful and consistent with the snake_case convention.

Tool Count4/5

Three tools is on the thin side, but the server's scope is narrowly read-only discovery, so each tool earns its place. It could be slightly over-compressed if contribution or task-memory actions are expected.

Completeness3/5

Discovery and inspection are covered, but the hub advertises contribution and task-memory capabilities with no corresponding tools, and there is no way to act on inspection results. Installation/execution being out of scope is stated, but the write-side surface is a notable gap.

Available Tools

3 tools
find_robot_skillsB
Read-onlyIdempotent
Inspect

Search pinned robot code across robots and runtimes. Results distinguish prepared recipes from upstream references; source discovery is not runtime verification.

ParametersJSON Schema
NameRequiredDescriptionDefault
qNoDefault all_terms: all query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses.
osNo
kindNo
limitNo
robotNo
offsetNo
pythonNo
runtimeNo
controllerNo
hub_commitNo
query_modeNotask opts into ASCII English lexical ranking over at most512 hard-filtered records; narrow runtime/robot when query_too_broad. No execution or compatibility inference.all_terms
observationNo
architectureNo
runtime_versionNo

TDQS

B3/5.0
Behavior3/5

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds a genuine semantic caveat about what results mean (recipes vs references, discovery != verification), but says nothing about pagination despite limit/offset, or result ordering/truncation 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?

Two tight sentences, front-loaded with the core action and then the result caveat. No filler, no restating of the tool name, every clause carries information.

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?

For a 14-parameter search tool with no output schema and 14% schema coverage, this is far too thin. Filter semantics, pagination behavior, result shape and the meaning of the two query modes are left entirely to inference.

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 14% across 14 parameters, so the description carries most of the burden and largely fails to. It hints at the recipe/reference distinction (mapping loosely to the kind enum) but leaves robot, runtime, os, python, controller, hub_commit, architecture, observation, runtime_version, limit and offset completely unexplained.

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?

States a specific verb and resource: 'Search pinned robot code across robots and runtimes.' It also characterizes the result set (prepared recipes vs upstream references), which separates it conceptually from inspect_robot_skill and get_hub_capabilities, though it never names those siblings explicitly.

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?

There is no when-to-use/when-not guidance and no routing to siblings such as inspect_robot_skill for drilling into a hit. The only contextual note ('source discovery is not runtime verification') is an interpretation caveat, not usage direction.

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

get_hub_capabilitiesA
Read-onlyIdempotent
Inspect

Read public discovery, preparation, contribution and task-memory capabilities, local CLI onboarding links and current catalog counts. No authentication is needed for reads.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A3.7/5.0
Behavior4/5

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

Annotations already declare read-only, idempotent, open-world and non-destructive semantics, so the safety bar is largely met structurally. The description adds a genuinely useful behavioral fact beyond them: reads require no authentication. It does not describe pagination, caching or freshness of the catalog counts.

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 tight sentences with no filler. The capability scope is front-loaded ahead of the supporting auth detail.

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

Completeness4/5

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

With no output schema, the description usefully sketches what comes back (capability groups, onboarding links, catalog counts) and confirms no auth is needed. Given zero parameters and rich annotations, this is close to sufficient; a note on whether counts are live or cached would complete it.

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 takes zero parameters, so there is no parameter semantics to document; baseline is 4. The description does not need to compensate for any schema gap.

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?

States a specific verb ('Read') and a well-enumerated resource (public discovery, preparation, contribution and task-memory capabilities, CLI onboarding links, catalog counts). It distinguishes itself from the skill-oriented siblings implicitly by returning hub-level metadata rather than skill data, but never names those siblings explicitly.

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?

There is no when-to-use statement, no condition that selects this tool over find_robot_skills or inspect_robot_skill, and no exclusions. The only guidance is the auth note, which is a constraint rather than usage routing.

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

inspect_robot_skillA
Read-onlyIdempotent
Inspect

Read a pinned recipe or reference and up to three exact-version findings as untrusted data. Findings need an applicability check; no installation or execution is performed.

ParametersJSON Schema
NameRequiredDescriptionDefault
skill_idYes
environmentNoOptional explicit task environment labels for findings only. Omit unknown values; no environment is inferred.
record_versionNoCopy record_version from the selected search result. Source references use source-<source.sha256>, not record.maintenance.record_version.

TDQS

A3.6/5.0
Behavior4/5

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

Annotations already cover readOnly, idempotent, openWorld and non-destructive. The description adds genuinely useful context beyond them: results are 'untrusted data' (a prompt-injection safety signal), findings require an applicability check, and no installation or execution occurs. This is real value not present in the structured fields.

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?

Two tight sentences with no filler, and the core purpose is front-loaded ahead of the safety caveat. Slightly dense jargon ('pinned recipe', 'findings') but efficient overall.

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?

For a read tool with no output schema, the description should sketch the return shape; it names the conceptual payload (recipe/reference plus up to three findings) but not its structure, and it omits the relationship to the sibling search tool that produces the required record_version. Adequate but incomplete for the task.

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 moderate (67%), with the environment object and record_version partially self-documented. The description hints at exact-version semantics but adds no detail on the skill_id pattern, the environment label constraints, or how record_version is sourced beyond what the schema already says. Baseline 3 is appropriate.

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?

States a specific verb (read/inspect) and resource (pinned recipe/reference plus exact-version findings), and the term 'pinned' implies it fetches a specific record rather than searching. It distinguishes itself functionally from find_robot_skills but never names that sibling, so the differentiation is inferred rather than explicit.

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 'up to three exact-version findings' and 'findings need an applicability check' phrasing implies this is a follow-up to a search, and the schema's record_version tells the agent to copy from a search result. However, the description never states when to use this tool versus find_robot_skills, nor any explicit preconditions or exclusions.

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

Tool Schema Changelog

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

  1. 2 tool updates
    • Changedfind_robot_skills2 fields changed
      • changedInput schema / properties / q / description
        Previous value: -"All query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses."New value: +"Default all_terms: all query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses."
      • addedInput schema / properties / query_mode
        Added value: +{
        +  "default": "all_terms",
        +  "description": "task opts into ASCII English lexical ranking over at most512 hard-filtered records; narrow runtime/robot when query_too_broad. No execution or compatibility inference.",
        +  "enum": [
        +    "all_terms",
        +    "task"
        +  ],
        +  "type": "string"
        +}
    • Changedinspect_robot_skill1 field changed
      • addedInput schema / properties / environment
        Added value: +{
        +  "additionalProperties": {
        +    "maxLength": 240,
        +    "minLength": 1,
        +    "type": "string"
        +  },
        +  "description": "Optional explicit task environment labels for findings only. Omit unknown values; no environment is inferred.",
        +  "maxProperties": 16,
        +  "propertyNames": {
        +    "anyOf": [
        +      {
        +        "enum": [
        +          "runtime",
        +          "runtime_version",
        +          "robot",
        +          "controller",
        +          "observation",
        +          "os",
        +          "python",
        +          "architecture",
        +          "sim_backend",
        +          "render_backend"
        +        ]
        +      },
        +      {
        +        "pattern": "^package\\.[A-Za-z_][A-Za-z0-9_]{0,79}$"
        +      }
        +    ]
        +  },
        +  "type": "object"
        +}
  2. 1 tool update
    • Changedfind_robot_skills1 field changed
      • addedInput schema / properties / q / description
        Added value: +"All query terms must match word prefixes. Standalone A*, D* and RRT* are read as astar, dstar and rrtstar; embedded identifiers and repeated stars keep ordinary tokenization. Empty q browses."
  3. 1 tool update
    • Changedinspect_robot_skill1 field changed
      • addedInput schema / properties / record_version / description
        Added value: +"Copy record_version from the selected search result. Source references use source-<source.sha256>, not record.maintenance.record_version."
  4. 3 tool updates
    • First observedfind_robot_skills
    • First observedget_hub_capabilities
    • First observedinspect_robot_skill

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    A
    maintenance
    Enables locating evidence for repository questions using CodeGraph or ripgrep, providing verified results and follow-ups.
    11 npm
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables evidence-grounded implementation research by searching GitHub, scoring candidate repositories, extracting source evidence, and generating planning artifacts like research and implementation checklists.
    1
    MIT
  • F
    license
    A
    quality
    A
    maintenance
    Clones and inspects public GitHub repositories to extract evidence like manifests, dependencies, and version hints, and can run allow-listed repos in isolated Docker containers for reproducible verification.
    4
    -
  • A
    license
    B
    quality
    B
    maintenance
    Enables coding agents to establish exact-release library identity, search provenance-tracked API, docs, example, source, and release evidence, compare releases, and test proposed invocations in isolated capsules for Rust and Python dependency environments.
    9
    Apache 2.0
Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.