protogrid
Server Details
Find MCP servers by intent and get exactly how to connect to them right now. No proxying.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
Each tool targets a distinct aspect: connections, server metadata, tool schemas, and search. There is minor overlap between get_server and list_tools since both expose tool details, but descriptions sufficiently differentiate them.
Two tools use get_ prefix, one uses list_, and one is a bare verb 'search'. The pattern is not entirely consistent, though the names are still readable and reasonably predictable.
With only 4 tools, the server's scope of read-only discovery and introspection is tightly covered. Each tool serves a clear purpose without redundancy.
The domain is server and tool discovery. Search provides broad access, get_server gives detailed server state, list_tools enumerates schemas, and get_connection supplies connection blocks—covering the full lifecycle of inspection with no obvious dead ends.
Available Tools
4 toolsget_connectionGet a connection blockARead-onlyInspect
Minimal connection block for the preferred remote (or package) with ${SECRET} placeholders, formatted for a target client. Secrets are never accepted or returned.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Official reverse-DNS name | |
| target | No | Output format (default mcpServers) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and openWorldHint=false, so the read-only nature is covered. The description adds valuable context by stating that secrets are never accepted or returned, which is a behavioral guarantee beyond the annotations and important for trust.
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?
Two sentences with no filler. The main purpose and key characteristics are front-loaded, and the critical secret-handling guarantee is placed immediately after. Every word earns its place.
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?
With no output schema, the description explains the return as a minimal connection block with placeholders and specifies that secrets are never returned. It does not detail the exact structure of the block, but for a simple read-only tool this is sufficient for correct invocation and basic expectation setting.
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 input schema has 100% description coverage for both parameters, so the schema already explains name as a reverse-DNS name and target as output format. The description reinforces that name refers to a remote/package and target to a client, but adds no new semantic detail beyond the schema.
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?
The description clearly states the tool retrieves a minimal connection block for the preferred remote or package, formatted for a target client. It uses a specific verb and resource, and the phrase 'connection block' differentiates it from siblings like get_server. It would be a 5 if it explicitly named the sibling it replaces or contrasts.
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?
The description implies when to use it: when a connection block with secret placeholders is needed for a target client. However, it does not explicitly name alternatives or state when not to use it, so the routing is left somewhat to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_serverGet a server descriptorARead-onlyInspect
Official server.json plus connectability (class, remotes with auth/health, packages), current tools, trust breakdown and identity for one server name.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Official reverse-DNS name, e.g. io.github.acme/acme-mcp | |
| schemas | No | Include tool input/output schemas (default false; use list_tools for full schemas) |
TDQS
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 adds useful behavioral context by enumerating the returned descriptor sections, including connectability with auth/health and trust breakdown. It does not cover error cases, but for a read-only getter this is a minor gap.
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?
One dense, front-loaded sentence that leads with the primary output ('Official server.json') and then lists additional sections in a compact parenthetical list. No filler or redundant phrasing.
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?
Given no output schema, the description does a good job of listing the main sections returned by the tool. It omits explicit error behavior and a precise return shape, but with a single required string parameter and read-only annotations, the remaining gaps are minor.
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%, so the baseline is 3. The description's 'server name' matches the `name` parameter and 'current tools' loosely maps to `schemas`, but it adds no parameter format, constraints, defaults, or behavior beyond what the schema already documents.
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?
Description states a specific verb and resource: getting the full server descriptor for one named server, and enumerates what is included (server.json, connectability, tools, trust breakdown, identity). It is clear and distinct from siblings in scope, though it does not explicitly name a sibling to differentiate from.
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?
The description implies when to use this tool: when you need the official server descriptor, connectability details, tools, trust, and identity for a single server. However, it does not explicitly state when to prefer get_connection, search, or list_tools instead, aside from the schema hint that full schemas belong with list_tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_toolsList a server's toolsARead-onlyInspect
Every current tool of a server with full input/output schemas, paginated by tool name.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Official reverse-DNS name | |
| limit | No | ||
| cursor | No | next_cursor from the previous page |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the operation safe and closed-world; the description adds that the result is a paginated enumeration ordered by tool name and includes full schemas for each tool. This gives useful behavioral context beyond the structured annotations.
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?
One concise sentence conveys the action, target, output content, and ordering/pagination behavior with no filler. All key information is front-loaded.
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?
Given the read-only annotations and the schema already documenting the cursor, the description covers what an agent needs to invoke the tool: server identity via name, pagination behavior, and the shape of returned tool definitions. Minor details like default page size are left to the implementation, but nothing critical 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?
With only 67% schema coverage (limit lacks a description), the description compensates by clarifying that the required name refers to the target server and that pagination proceeds by tool name, which gives meaning to cursor. Limit's semantics are only partially conveyed by its min/max bounds, but the core parameters are understandable.
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?
The description names a specific action ('list') and resource ('a server's tools'), and specifies that the result includes full input/output schemas and pagination by tool name. This clearly distinguishes it from siblings like get_connection and search, which target different resources.
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?
The description makes the tool's scope obvious: it enumerates every current tool of a given server, so an agent can infer it is the right choice for exhaustive tool discovery. It does not explicitly name alternatives or exclusion conditions, but the sibling tools are clearly different operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchSearch MCP servers by intentARead-onlyInspect
Hybrid (keyword + semantic) search over servers and their tools. Filter by connection class to keep only what you can reach autonomously (R0, R1).
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | What you want to do, in plain words, e.g. 'send an email' or 'query postgres' | |
| class | No | Connection classes to keep, e.g. ['R0','R1'] | |
| flags | No | Trust flags that must all be present | |
| limit | No | Results to return (default 10) | |
| category | No | ||
| min_trust | No | Minimum trust score 0-100 | |
| transport | No | ||
| exclude_flags | No | Trust flags, any of which excludes a server, e.g. ['multi-version-spam','duplicate-repo'] |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this as read-only and not open-world, and the description adds genuine behavioral detail: it is hybrid keyword+semantic and searches both servers and their tools. It does not over-disclose or contradict the annotations.
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?
The description is two short sentences with no filler. The core behavior is front-loaded, and the most important filter guidance follows immediately.
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 search tool with 8 parameters and no output schema, the description leaves some return-shape details implicit, but the title, schema field descriptions, and sibling context are enough for an agent to select and invoke it correctly. The main gap is an explicit statement of what the result set contains.
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 coverage is already high at 75%, and the description adds useful semantic context for the q parameter ('intent') and the class parameter (reachability via R0/R1). It does not need to restate every field, since the schema already documents most of them.
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?
The description names a specific action and resource: hybrid keyword+semantic search over servers and their tools. This clearly distinguishes it from siblings like get_server and list_tools, which are targeted retrieval and enumeration rather than intent-based discovery.
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?
The description gives practical filter guidance ('keep only what you can reach autonomously (R0, R1)') but does not explicitly state when to use search versus the sibling tools. Usage context is implied by the title rather than spelled out with exclusions or alternatives.
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.
4 tool updates
- Changed
get_connection1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
get_server1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
list_tools1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
- Changed
search1 field changed- changed
Input schema / $schemaPrevious value: -"http://json-schema.org/draft-07/schema#"New value: +"https://json-schema.org/draft/2020-12/schema"
1 tool update
- Changed
get_connection1 field changed- changed
Input schema / properties / target / enumPrevious value: -[ - "mcpServers", - "vscode", - "cursor", - "claude-code-cli", - "codex-toml", - "gemini", - "goose" -]New value: +[ + "mcpServers", + "vscode", + "cursor", + "claude-code-cli", + "codex-toml", + "opencode", + "gemini", + "goose" +]
4 tool updates
- First observed
get_connection - First observed
get_server - First observed
list_tools - First observed
search
Related MCP Connectors
Search and discover 25,000+ MCP servers across all major registries. Connect and pay autonomously.
Find MCP servers and check whether they actually respond, via live handshake probes.
Search 33,000+ MCP servers by job, see safety grades and reviews, and call them from one endpoint.
Capability registry for the agentic economy. Semantic search over verified MCP server listings.
Related MCP Servers
- AlicenseCqualityDmaintenanceEasily find MCP servers using our MCP registry. Search with natural language.16MIT
- AlicenseNot gradedqualityDmaintenanceEnables searching and retrieving detailed information about MCP servers from the official MCP registry. Provides tools to list servers with filtering options and get comprehensive details about specific servers.29 npm3MIT
- FlicenseNot gradedqualityDmaintenanceFinds the right MCP server for a task from over 1,400 indexed servers ranked by community trust. Also provides outcome-ranked web search for AI agents with no API key or rate limits.4-
- AlicenseAqualityDmaintenanceProvides intelligent recommendations for MCP servers based on development needs using natural language queries. Searches through 874+ curated MCP servers across 36+ categories with advanced matching algorithms.35MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.