Loading ToolBench
MCP server for API discovery and code execution across multiple API types (REST, GraphQL, SPARQL). Provides search, execute, and query tools for exploring and calling APIs with auto-staging of large responses.
This server exposes 5 tools with significant definition gaps. All tools have descriptions (positive), but schemas are incomplete or inferred. Tool names use verb_noun pattern (search, execute) which is good. However, parameter descriptions are sparse, output schemas are undocumented, and error handling guidance is absent. The tools appear to be code-execution sandboxes (V8 isolates) with dynamic behavior, this makes static schema definition difficult, but the server does not compensate with clear input/output documentation. Most parameters lack type constraints (e.g., 'code' is just a string with no length limits, format guidance, or examples). No pagination, no error recovery hints, no permission gates documented.
Execute JavaScript code against the API. Code runs in a sandboxed V8 isolate with: searchSpec(query) / searchPaths(query) — search the API catalog/spec; listCategories() / listTags() — inspect tags/categories; getEndpoint(path) / getOperation(idOrPath) — get endpoint docs; describeEndpoint(path, method?) / describeOperation(idOrPath) — format endpoint docs; spec — full frozen OpenAPI spec object; api.get(path, params) for GET, api.post(path, body, params) for POST; console.log() capture. Path params like /lookup/{id} are auto-interpolated from params. Large responses (>100KB) are auto-staged into SQLite. The last expression or return value is the result.
Execute JavaScript code against the GraphQL API. Code runs in a sandboxed V8 isolate with: gql.query(queryString, variables?) — GraphQL execution through host; schema.types(), schema.type(), schema.search() etc. — introspection helpers; db.stage(), db.queryStaged(), api.query() — staging helpers; console.log() capture. Optionally also a SECOND, REST upstream (api.get/api.post) routed through the same host proxy + DO-SQLite staging (hybrid GraphQL+REST). The last expression or return value is the result.
Execute JavaScript code against the SPARQL endpoint. Code runs in a sandboxed V8 isolate with: sparql.query(queryString, opts?) — run SELECT/CONSTRUCT/DESCRIBE; returns array of plain { variable: value } rows; sparql.ask(queryString) — run ASK; returns boolean; sparql.raw(queryString, opts?) — return unparsed { head, results } envelope; prefixes — object of common ontology prefixes (rdfs, owl, xsd, skos, dcterms, void, obo, uberon, go, ncbigene, efo, obi, sio, up, ensembl, bgee); prefixHeader — pre-built `PREFIX …` block to prepend to your queries; console logging (log, warn, error, info) — captured output; fs.readFile / fs.writeFile / fs.glob ... — persistent virtual filesystem (when enabled). The last expression or return value is the result. Large SPARQL responses (>30KB) are auto-staged into SQLite.
Search the API catalog (catalog mode). Returns matching endpoints with full parameter docs. Use this to discover API capabilities before calling {prefix}_execute. Categories are listed. USAGE IN {prefix}_execute: api.get(path, params) for GET, api.post(path, body, params) for POST. Path params like /lookup/{id} are auto-interpolated from params. Remaining params become query string. Large responses (>100KB) are auto-staged: check result.__staged, return the staging info, use {prefix}_query_data to explore. Use limit/pagination params to control response size.
Output schemas undocumented. Tools return JavaScript expression results with no declared structure. LLMs cannot plan downstream calls or extract typed fields. Violates pattern:tool and pattern:response-shaper.
Code parameter lacks constraints. No length limit, no format guidance, no examples of valid code. LLMs may pass arbitrarily large or malformed JavaScript. Violates pattern:constrained-input.
No error handling guidance. Tools execute arbitrary code in sandboxes, failures (syntax errors, timeouts, API errors) are likely. No recovery hints or error classification provided. Violates pattern:recovery-guide and pattern:error-classification.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | F | 40 | 2026-07-28+ | v2 |
Search the OpenAPI spec (OpenAPI mode). Write JavaScript code to search the OpenAPI spec, or use legacy query/category arguments for keyword search. Available functions: searchPaths(query, maxResults=10) — keyword search across paths, summaries, tags, parameters; listTags() — list all tags with operation counts; getOperation(idOrPath) — get full operation by operationId or path; describeOperation(idOrPath) — formatted documentation for an operation; searchSpec/query helpers are also available for backward compatibility inside execute(); spec — the full frozen OpenAPI spec object (spec.paths, spec.info, etc.). Use {prefix}_search to discover endpoints, then write code in {prefix}_execute to call them.
Duplicate tool names across modes. Both catalog and OpenAPI modes register as '{prefix}_search'; both REST and GraphQL register as '{prefix}_execute'. LLMs cannot distinguish between them. Violates pattern:tool naming clarity.
No permission gates or security declarations. Code execution tools can access APIs, databases, and filesystems. No scope declarations (read:api, write:db) or audit trail guidance. Violates pattern:scope-declaration and pattern:audit-trail.