Skip to main content
Glama

read_lookup_path

Read-only

Checks each segment of a LeafWiki path to confirm whether it exists and whether it can be created, so clients can validate paths before reading or editing pages.

Instructions

Whether a path exists, segment by segment, and whether it can be created.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "path": "<path>"
    },
    "name": "read_lookup_path"
  }
}

Input Schema

NameRequiredDescriptionDefault
pathYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.1.0

TDQS

C2.9/5.0
Behavior3/5

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description contributes something beyond that: it is a non-mutating probe that reports per-segment status and whether the path is creatable, which hints at the response shape. It still does not say what the result actually looks like (booleans, list of segments, ordering) or what makes a path non-creatable.

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?

A single compact sentence with no filler, and the core notion (existence check) is front-loaded. The economy is partly achieved by omitting detail an agent would need, so it is tight rather than well-structured.

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 one-parameter read tool with no output schema, the description should pin down the return value, and it only gestures at it ('segment by segment', 'can be created'). The parameter format is also left implicit. Adequate to guess intent, not adequate to call confidently without trial.

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 single 'path' parameter has 0% schema description coverage, so the description must carry the load. It adds real meaning by implying the path is hierarchical and evaluated segment by segment, but never specifies separator conventions, leading/trailing slash handling, or whether it is a wiki path vs a filesystem path. Partial compensation for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description conveys that this is a read-only existence check on a hierarchical path, and adds the unusual detail that the answer is broken down per segment and includes creatability. However, it never states a crisp verb+resource (e.g. 'Check whether a path exists') and leaves ambiguous whether it returns one boolean, three booleans, or a segment-by-segment breakdown. Compared to siblings like write_ensure_path, the read-vs-write distinction is only implied.

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 when-to-use guidance is given. The mention of 'whether it can be created' gestures at write_ensure_path but never names it or says to call that instead when the path is missing. An agent must infer the read/check-before-write pattern entirely on its own.

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