Skip to main content
Glama

search_tools

Filter GNS3 MCP tools by category, capability, or resource URI to locate relevant actions and see supported features and applicable resources.

Instructions

Discover GNS3 MCP tools (v0.47.0 - Tool Discovery)

Search and filter available tools by category, capability, or resource URI. Returns tool metadata including description, actions, and applicable resources.

Categories:

  • project: Project management (open, create, close)

  • node: Node management (create, delete, configure)

  • connection: Network connections and GNS3 server

  • console: Console access to devices

  • ssh: SSH access to devices

  • drawing: Topology visualization

  • resource: Resource query tools

  • docker: Docker-specific operations

  • docs: Documentation management

  • topology: Topology operations

  • management: Management operations

  • device-access: Device access (console/SSH)

  • visualization: Visual elements

  • discovery: Tool discovery

Capabilities:

  • CRUD: Supports create/read/update/delete operations via action parameter

  • batch: Supports batch operations (multiple operations in one call)

  • wildcard: Supports wildcard patterns (, Router, R[123])

  • parallel: Supports parallel execution

  • idempotent: Multiple executions produce same result

Resource Mapping:

  • projects://: project, query_resource

  • projects://{project_id}/topology_report: query_resource

  • nodes://{project_id}/: node, query_resource

  • links://{project_id}/: link, query_resource

  • drawings://{project_id}/: drawing, query_resource

  • sessions://console/: console, query_resource

  • sessions://ssh/: ssh, query_resource

  • diagrams://{project_id}/topology: export_topology_diagram, query_resource

Returns: JSON with matching tools and their metadata

Examples: # Find all CRUD tools >>> search_tools(capability="CRUD")

# Find tools for working with nodes
>>> search_tools(category="node")

# Find tools that work with projects:// resources
>>> search_tools(resource_uri="projects://")

# Find batch operation tools
>>> search_tools(capability="batch")

# Find tools with wildcard support
>>> search_tools(capability="wildcard")

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "search_tools"
  }
}

Input Schema

NameRequiredDescriptionDefault
categoryNoFilter by category: project, node, console, ssh, drawing, resource, docker, connection, docs, management, device-access, topology, visualization, discovery
capabilityNoFilter by capability: CRUD, batch, wildcard, parallel, idempotent
resource_uriNoFind tools applicable to resource URI (e.g., 'projects://', 'nodes://{project_id}/')

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.54.2

TDQS

A4/5.0
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 the output shape at a high level ('JSON with matching tools and their metadata') and the resource-mapping semantics, but never states that this is a read-only operation, what happens when all three filters are null (return everything?), how large the result set can get, or how multiple filters combine.

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?

Structure is front-loaded and scannable (categories, capabilities, resource mapping, examples), but it is padded: the 14-item category list is largely duplicated from the schema's category description, and five one-line examples largely repeat each other. For a three-optional-filter tool this is bulkier than needed.

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?

Since an output schema exists, the description needn't detail return values, and it covers the filter vocabulary thoroughly. The remaining gap is behavioral rather than semantic: default/no-filter behavior and multi-filter combination rules are not addressed, which matters for an agent deciding how to narrow a discovery query.

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 coverage is 100%, so baseline is 3; the description earns above that by defining what each capability token actually means (CRUD = action-parameter-driven create/read/update/delete, wildcard = patterns like Router*, R[123], idempotent = repeat-safe) and by mapping resource URI patterns to the tools that handle them. That is real meaning the schema does not carry.

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 ('Discover GNS3 MCP tools') and immediately states the three filtering axes and what is returned ('tool metadata including description, actions, and applicable resources'). This is unambiguously a meta/discovery tool, clearly separable from siblings like project, node, or query_resource.

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?

Usage is well supported: the category and capability lists define the valid filter dimensions, and five worked examples show concrete invocations (capability="CRUD", category="node", resource_uri="projects://"). What's missing is exclusion guidance — e.g., when to search by resource_uri versus category, or whether no-filter behavior is intended.

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