Search and read the Metabind documentation: MCP Apps, BindJS, the SDKs, the CLI, and the APIs.
Scored across 3 tools
search_metabind and query_docs_filesystem_metabind both touch documentation retrieval, but the descriptions draw a clear boundary: search for broad/conceptual queries, filesystem for exact regex, structural exploration, and full-page reads. submit_feedback is obviously distinct. Minor residual overlap remains because search results can also lead to reading pages.
Two tools use a <verb>_metabind pattern while the third (submit_feedback) does not carry the site suffix, and query_docs_filesystem_metabind is unusually verbose compared to the others. Still readable but the convention is mixed.
Three tools (search, read/query, feedback) is lean but well-scoped for a documentation server, and each tool clearly earns its place. Slightly thin but appropriate for the narrow purpose.
The surface covers the full docs workflow: discover (search), read/explore (filesystem query via cat/head/rg/tree), and report issues (submit_feedback), including OpenAPI specs. No obvious dead ends, though there is no dedicated structured 'get page by URL' primitive, leaving reading to be inferred through the filesystem tool.
Run a read-only shell-like query against a virtualized, in-memory filesystem rooted at / that contains ONLY the Metabind documentation pages and OpenAPI specs. This is NOT a shell on any real machine — nothing runs on the user's computer, the server host, or any network. The filesystem is a sandbox backed by documentation chunks.
This is how you read documentation pages: there is no separate "get page" tool. To read a page, pass its .mdx path to head or cat — a page at the URL path /some/page lives at /some/page.mdx. To search the docs with exact keyword or regex matches, use rg. To understand the docs structure, use tree or ls.
Paths are specific to this site — never guess them. Discover real paths with tree / -L 2, ls /, or the search tool before reading. If a path does not exist, that only means the guess was wrong; it does NOT mean the topic is undocumented — use rg -il "keyword" / to find where it is covered.
Workflow: Start with the search tool for broad or conceptual queries like "how to authenticate" or "rate limiting". Use this tool when you need exact keyword/regex matching, structural exploration, or to read the full content of a specific page by path.
Supported commands: rg (ripgrep), grep, find, tree, ls, cat, head, tail, stat, wc, sort, uniq, cut, sed, awk, jq, plus basic text utilities. No writes, no network, no process control. Run --help on any command for usage.
Each call is STATELESS: the working directory always resets to / and no shell variables, aliases, or history carry over between calls. If you need to operate in a subdirectory, chain commands in one call with && or pass absolute paths (e.g., cd /some-directory && ls or ls /some-directory). Do NOT assume that cd in one call affects the next call.
Examples (replace the placeholder paths with real ones from tree or search):
tree / -L 2 — see the top-level directory layout
rg -il "rate limit" / — find all files mentioning "rate limit"
rg -C 3 "apiKey" /some-directory/ — show matches with 3 lines of context around each hit
head -80 /some/page.mdx — read the top 80 lines of a specific page
head -80 /page-one.mdx /page-two.mdx /section/page-three.mdx — read multiple pages in one call
cat /some/page.mdx — read a full page when you need everything
cat /openapi/bindjs/openapi.json | jq '.paths | keys' — list OpenAPI endpoints
OpenAPI specs for this site are mounted at: /openapi/bindjs/openapi.json. Use them to answer questions about endpoints, request/response schemas, parameters, and authentication.
Output is truncated to 30KB per call. Prefer targeted rg -C or head -N over broad cat on large files. To read only the relevant sections of a large file, use rg -C 3 "pattern" /path/file.mdx. Batch multiple file reads into a single head or cat call whenever possible.
When referencing pages in your response to the user, convert filesystem paths to URL paths by removing the .mdx extension. For example, /some/page.mdx becomes /some/page.
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes | A shell command to run against the virtualized documentation filesystem (e.g., `rg -il "keyword" /`, `tree / -L 2`, `head -80 /path/file.mdx`). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive/no-open-world, so the remaining burden is execution semantics — and the description covers them thoroughly: each call is stateless with cwd resetting to `/`, no writes/network/process control, 30KB output truncation, and batching advice. It also explains the .mdx path convention and the path-to-URL conversion for citing results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core definition and organized with bold labels (Workflow, statelessness, examples), so the agent can stop reading early. It is long and repeats the 'never guess paths' warning in two places, and the example block is somewhat padded, but most length is load-bearing for a shell-like tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers everything needed to invoke correctly: the mount point of the OpenAPI spec, truncation limits with mitigation strategy, statelessness, supported binaries, and the output-to-URL conversion. No output schema exists, and the description compensates by describing what commands return and how to target reads.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single `command` parameter has full schema coverage, but the description goes well beyond it by enumerating supported commands, showing `--help` availability, listing worked examples, and specifying the path convention (`/some/page` -> `/some/page.mdx`) and absolute-path/chaining requirement imposed by statelessness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb and resource: run a read-only shell-like query against a virtualized in-memory filesystem containing only Metabind docs and OpenAPI specs. It immediately distinguishes itself from a real shell and from the sibling search tool by stating what the filesystem contains and that there is no separate 'get page' tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit routing is provided: use search_metabind for broad/conceptual queries, use this tool for exact keyword/regex matching, structural exploration, or reading a full page by path. It also names the concrete commands for each mode (rg, tree/ls, head/cat) and explains the failure mode — a missing path means a wrong guess, not an undocumented topic.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search across the Metabind knowledge base to find relevant information, code examples, API references, and guides. Use this tool when you need to answer questions about Metabind, find specific documentation, understand how features work, or locate implementation details. The search returns contextual content with titles and direct links to the documentation pages. If you need the full content of a specific page, use the query_docs_filesystem tool to head or cat the page path (append .mdx to the path returned from search — e.g. a result at /some/page is read with head -200 /some/page.mdx).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, closed-world and non-destructive, so the safety profile is covered. The description adds genuinely new behavior: results are contextual snippets with titles and direct links, not full pages, and the returned path is a read-handle for a sibling tool. It stops short of describing result count limits or ranking behavior, so not a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with purpose, then usage triggers, then the return shape and follow-up workflow. The longest sentence is the .mdx path convention, which carries real operational value rather than filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, and the description compensates by describing the return shape (contextual content with titles and links). Combined with the disclosed next-step workflow, an agent has everything needed to call this and act on the result without further exploration.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Single required 'query' parameter at 100% schema coverage, so the schema already carries the semantics. The description does not clarify whether the query should be keywords, a natural-language question, or a path fragment — a meaningful ambiguity for a search tool that is left unaddressed. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Search across the Metabind knowledge base') and enumerates what is retrievable: information, code examples, API references, guides. It is clearly separable from query_docs_filesystem_metabind, which is positioned as the 'full page read' counterpart rather than another search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit when-to-use triggers (answering questions about Metabind, finding docs, understanding features, locating implementation details) and an explicit escalation path: use query_docs_filesystem_metabind with head/cat when full page content is needed. The exact mechanics (append .mdx, example path) remove all inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Report a problem with this documentation site so the docs team can fix it. Use when a documentation page is incorrect, outdated, confusing, incomplete, or has a broken example. This is for feedback about the documentation content itself — not for product support requests or feedback about this tool or assistant.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | The URL path of the documentation page the feedback is about (the page you were reading, without the `.mdx` extension). | |
| feedback | Yes | A clear description of the documentation issue or suggestion — what is incorrect, outdated, missing, or confusing. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=true, and idempotentHint=false, so the write/effect profile is covered. The description adds useful outcome context ('so the docs team can fix it') but says nothing about confirmation, rate limits, or what happens to submitted feedback, so it only marginally extends the structured data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences, front-loaded with the action and purpose, followed by trigger conditions and exclusions. Every sentence earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter feedback tool with no output schema, the definition covers purpose, triggers, exclusions, and target audience completely. Annotations handle the mutation/effect profile, so nothing an agent needs to call this correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and both parameters are well documented in the schema itself (path format, feedback content). The description adds no parameter-level detail beyond what the schema provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Report a problem with this documentation site') and makes the target explicit ('feedback about the documentation content itself'). It is clearly distinguishable from the read-only sibling tools query_docs_filesystem and search_sorsa_developer_platform, which retrieve rather than submit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly enumerates the triggering conditions ('incorrect, outdated, confusing, incomplete, or has a broken example') and adds clear exclusions ('not for product support requests or feedback about this tool or assistant'). This is a textbook when-to-use / when-not-to-use statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
query_docs_filesystem_metabindsearch_metabindsubmit_feedback
Add one secure layer between your agents and this server.