Metabind Docs
Server Details
Search and read the Metabind documentation: MCP Apps, BindJS, the SDKs, the CLI, and the APIs.
- Status
- Healthy
- Uptime
- 100.0% over 40 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 3 tools
search_metabind (semantic/conceptual search) and query_docs_filesystem_metabind (exact rg/regex plus page reading) overlap in that both surface documentation, and the descriptions themselves cross-reference each other, which could still leave an agent unsure which to try first. submit_feedback is clearly distinct, and the descriptions do provide a usable heuristic (broad query → search, exact match or full page read → filesystem), so the ambiguity is mild rather than harmful.
All names are snake_case, but the conventions diverge: two tools are suffixed with the product name (query_docs_filesystem_metabind, search_metabind) while the third (submit_feedback) is not, and verbs range from search to query to submit. It is readable but not a predictable verb_noun pattern an agent could extrapolate from.
Three tools is at the low end but appropriate for a documentation-retrieval server: search, read/query, and feedback each cover a distinct need with no filler. A slightly richer surface (e.g., a page-listing helper) would help, but nothing here feels redundant.
The read path is well covered — semantic search plus a sandboxed filesystem with rg/cat/tree over .mdx pages and the mounted OpenAPI spec — and a feedback channel exists. Minor gaps: there is no direct 'get page by URL path' tool (agents must know to append .mdx and use cat/head) and no structured endpoint-lookup beyond jq-ing the spec.
Available Tools
3 toolsquery_docs_filesystem_metabindQuery documentation filesystemARead-onlyIdempotentInspect
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 layoutrg -il "rate limit" /— find all files mentioning "rate limit"rg -C 3 "apiKey" /some-directory/— show matches with 3 lines of context around each hithead -80 /some/page.mdx— read the top 80 lines of a specific pagehead -80 /page-one.mdx /page-two.mdx /section/page-three.mdx— read multiple pages in one callcat /some/page.mdx— read a full page when you need everythingcat /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`). |
TDQS
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_metabindSearch documentationARead-onlyIdempotentInspect
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 |
TDQS
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.
submit_feedbackSubmit documentation feedbackAInspect
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. |
TDQS
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.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
query_docs_filesystem_metabind - First observed
search_metabind - First observed
submit_feedback
Related MCP Connectors
Search and read the official MintMCP documentation, the enterprise MCP gateway.
Search and read documentation about NServiceBus and the Particular Service Platform.
Search and read the Druxt documentation and API reference.
Search and read SYMONE documentation: service, prices, public API, MCP servers, sandbox, limits.
Related MCP Servers
- AlicenseAqualityBmaintenanceSearch and read the Strands Agents SDK documentation section by section. Runs locally with uvx strands-agents-mcp-server.2886 npm9,066Apache 2.0
- AlicenseAqualityDmaintenanceSearch and fetch MCP protocol documentation using BM25 search with weighted scoring and stemming.253 npm2MIT
- AlicenseNot gradedqualityDmaintenanceSearch and read Kakao Developers REST API documentation through the MCP protocol.MIT
- AlicenseNot gradedqualityAmaintenanceEnables searching, reading, and navigating MkDocs documentation sites through MCP tools for keyword, semantic, or hybrid search, document browsing, and project metadata.1BSD 2-Clause "Simplified"
Glama MCP Gateway
Add one secure layer between your agents and this server.