MCP Queen Registry
OfficialMCP Queen is a public discovery and evidence service for MCP servers, letting you search, inspect grades, trust receipts, and evidence, or submit feedback.
Search servers by task, filters (auth, category, minimum grade, max latency), and get ranked results.
Search tool names/descriptions across registered servers to find specific capabilities (e.g., 'query postgres', 'GET weather').
List top-graded servers with score, latency, tool count, and auth state.
Fetch a full operational grade and verbatim probe evidence for a specific server.
Retrieve a complete trust receipt: operational grade, security/data-integrity/citation/claim observations, and reviewed field reports.
Search published trust evidence and field reports by keyword, status, or dimension (e.g., security, citation quality).
Submit a field report about an MCP server you used (quarantined, human-reviewed, not auto-published).
Access via hosted Streamable HTTP endpoint (https://mcpqueen.com/mcp) or use the local stdio bridge in this repo.
Allows Cloudflare Agents to discover and evaluate MCP servers.
Provides Hugging Face agents with tools to search and verify MCP servers.
Provides LangChain agents with tools to search and verify MCP servers.
Allows OpenAI ChatGPT, Codex, and Responses API to discover and evaluate MCP servers before committing to them.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Queen Registrylist the top 10 MCP servers"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Queen
MCP Queen is a public discovery and evidence service for Model Context Protocol servers. It publishes dated operational observations, tool metadata, and separate Trust Receipts so developers and agents can inspect evidence before deciding what to connect.
An MCP Queen operational grade is not a security, privacy, data-quality, or compliance certification. Missing evidence is unaudited, not safe.
Use the hosted endpoint
The public Streamable HTTP endpoint requires no account for rate-limited evaluation:
https://mcpqueen.com/mcpIt exposes six read-only discovery/evidence tools and one additive feedback tool:
search_serverssearch_toolslist_gradesget_server_gradeget_trust_receiptsearch_trust_evidencesubmit_feedback— writes only to a quarantined review queue
For human-readable setup and current service limits, use mcpqueen.com/connect.
Claude Code
claude mcp add --transport http mcpqueen https://mcpqueen.com/mcpDirect protocol examples
The model-free examples under examples/clients call the
hosted endpoint directly:
node examples/clients/node-http.mjs "GitHub issue triage"The Python version uses the official MCP SDK. Additional examples show bounded
integration with LangChain, LlamaIndex, Cloudflare Agents, Hugging Face, and
the OpenAI Responses API. Agent examples allowlist only the six read-only
tools; submit_feedback is excluded from automatic model access.
Related MCP server: MCP Registry Server
Optional local stdio bridge
This repository contains a small zero-dependency stdio bridge for clients that
cannot connect to a remote Streamable HTTP endpoint directly. The bridge does
not contain MCP Queen's hosted implementation or evidence corpus; it forwards
JSON-RPC messages to https://mcpqueen.com/mcp.
git clone https://github.com/mcpqueen/mcpqueen.git
cd mcpqueen
npm ci
npm startTo point the bridge at another compatible endpoint during local testing, set
MCPQUEEN_MCP_URL in the process environment.
Docker is also supported:
docker build -t mcpqueen-bridge .
docker run --rm -i mcpqueen-bridgeWhat this public repository contains
registry metadata:
server.jsonandglama.jsonthe hosted-endpoint stdio bridge:
server.mjsmodel-free and framework examples:
examplespublic architecture and trust boundaries:
docs/architecture.mddeterministic tests and read-only CI
The production Worker, deployment configuration, evidence database, submission packages, operational records, and private source history are not part of this public developer surface. This repository is not a production deployment source.
Verify locally
npm ci
npm testThe tests exercise the bridge against a local mock endpoint and verify that public documentation and package scripts reference files that are actually in this repository.
License and support
Code in this repository is available under the MIT License. Product documentation, privacy, terms, and support are available from mcpqueen.com.
Available Tools
7 toolsget_server_gradeAInspect
Get the full grade and verbatim probe evidence for one MCP server, by its official registry name (e.g. 'com.healthai/radar').
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Registry server name |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states what the tool returns (grade and evidence) but does not disclose behavioral traits such as read-only nature, authentication requirements, rate limits, or any side effects. This is insufficient for a tool with no annotation coverage.
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 a single, well-structured sentence that is front-loaded with the action. Every word is necessary, no fluff. Ideal length for a simple 1-parameter 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?
Given no output schema, the description partially explains the return (full grade and verbatim probe evidence), but lacks context about when to prefer this tool over siblings like search_servers or list_grades. It also does not mention any output structure or size limits. Adequate but not thorough.
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 100% and schema already describes the parameter as 'Registry server name'. The description adds value by clarifying the exact format ('official registry name, e.g. com.healthai/radar'), providing a concrete example that aids understanding.
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 action ('get') and resource ('full grade and verbatim probe evidence for one MCP server'), and specifies the input format ('official registry name, e.g. com.healthai/radar'). It distinguishes from siblings: list_grades likely returns multiple grades, search_servers searches servers, etc.
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 (when you have the exact registry name and need grade/evidence for one server), but does not explicitly state when not to use or mention alternative tools. No exclusions or comparisons are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_trust_receiptAInspect
Get one MCP server's complete evidence receipt: operational grade, deterministic security/data-integrity/citation/claim observations, and reviewed real-usage field reports. Missing observations are explicitly unaudited, never treated as a pass.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Official registry server name |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries full burden. It adds behavioral context by stating 'Missing observations are explicitly unaudited, never treated as a pass,' which is a key trait beyond a simple read operation. However, it does not disclose whether the tool is destructive or has auth requirements, but since it's a read tool, this is minor.
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, no filler. First sentence states purpose and content; second adds crucial behavioral nuance. 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?
For a tool with one parameter and no output schema, the description covers what the receipt contains and a key behavioral trait. It could mention return format or data structure, but the agent can reasonably infer. Lacking output schema is compensated by detailed description.
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 100% for the single parameter 'name', described as 'Official registry server name'. The description does not add extra semantics beyond the schema, so baseline 3 is appropriate.
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 explicitly states 'Get one MCP server's complete evidence receipt' and lists its components (operational grade, observations, field reports), which clearly defines the tool's purpose. It distinguishes itself from siblings like get_server_grade (which likely returns a simpler grade) and search_trust_evidence (which is a search tool for evidence).
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 this tool is for comprehensive trust assessment but does not explicitly state when to use it versus alternatives like get_server_grade or search_trust_evidence. No when-not-to-use or prerequisite info is provided, relying on the user to infer based on the title.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_gradesAInspect
List the top graded MCP servers from the mcpqueen registry (deterministic probe grades with evidence). Returns grade, score 0-100, latency, tool count and auth state per server.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max servers to return (default 25, max 100) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full transparency burden. It discloses the deterministic nature of grades with evidence and lists the exact fields returned. However, it does not mention ordering details or that the operation is read-only, though that is inferable.
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 wasted words. The first sentence immediately describes the core action, and the second adds return info. Highly efficient.
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?
The description is adequate for a simple list tool: it covers purpose, return fields, and source. It lacks explicit mention of ordering by grade or score, and does not clarify whether pagination is supported beyond the limit parameter. Slightly incomplete for full autonomy.
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 100% for the single parameter 'limit'. The description adds no extra meaning beyond the schema's own description. Baseline 3 is appropriate as schema already fully documents the parameter.
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 lists top graded MCP servers from a specific registry, and enumerates the fields returned per server (grade, score, latency, tool count, auth state). This is specific and distinguishes it from siblings like search_servers or get_server_grade.
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 usage for viewing top servers but provides no explicit guidance on when to use this tool versus alternatives (e.g., search_servers, get_server_grade). No when-not-to-use or scenarios are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_serversAInspect
Search the MCP evidence registry using a natural multi-word task (e.g. 'reliable no-auth drug interaction server with citations'). Tokenizes and expands common synonyms, ranks metadata plus observed tool descriptions, and supports operational-grade/auth/latency/category filters. Use get_trust_receipt or search_trust_evidence for security, data, citation, claim, and response evidence.
| Name | Required | Description | Default |
|---|---|---|---|
| auth | No | Filter by authentication state (default any) | |
| limit | No | Max results (default 10, max 25) | |
| query | Yes | Keyword or task to search name/title/description for | |
| category | No | Optional category filter: Dev & Code, Data & Databases, Web & Search, AI & Agents, Finance & Crypto, Communication, Productivity, Security, Commerce, Media & Design, Cloud & Infra, Science & Health, Other | |
| minimum_grade | No | Worst acceptable live grade | |
| max_latency_ms | No | Maximum measured initialize latency in milliseconds |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses tokenization, synonym expansion, ranking based on metadata and tool descriptions, and filters. However, it does not mention whether the search is read-only, rate limits, or authentication requirements. Still, it provides significant behavioral context.
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 sentences. The first sentence states purpose with an example, the second combines behavioral details and usage guidelines. No wasted words, front-loaded, and efficient.
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 6 parameters, no output schema, and no annotations, the description covers query semantics, internal processing, filter support, and sibling differentiation. It lacks details on return format (e.g., what fields are returned) and pagination (limit parameter is mentioned but not behavior beyond max). Still, it is fairly comprehensive for a search tool.
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 baseline is 3. The description adds meaning by explaining that the query parameter accepts natural multi-word tasks and that tokenization/synonym expansion occurs. For other parameters (auth, category, minimum_grade, max_latency_ms), the description only references them generically, but the schema already describes them. Overall, the description adds moderate value 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 searches the MCP evidence registry for servers using natural multi-word tasks, with an example. It distinguishes from sibling tools like search_tools (for tools) and get_trust_receipt/search_trust_evidence (for security evidence).
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 tells when not to use the tool and provides alternatives: 'Use get_trust_receipt or search_trust_evidence for security, data, citation, claim, and response evidence.' This gives clear guidance on when to use each sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_toolsAInspect
Search across the actual tools that graded MCP servers expose (their tool names and descriptions, captured live from tools/list) — not just server metadata. Use this when you need a specific capability or data type, e.g. 'get weather', 'query postgres', 'device recall', 'FDA 510k'. Returns the matching tools with the server that offers each, its grade, and the remote endpoint so you can connect directly.
| Name | Required | Description | Default |
|---|---|---|---|
| auth | No | Filter by authentication state (default any) | |
| limit | No | Max matching tools (default 15, max 40) | |
| query | Yes | Capability, data type, or keyword to match against tool names and descriptions | |
| category | No | Optional server-category filter: Dev & Code, Data & Databases, Web & Search, AI & Agents, Finance & Crypto, Communication, Productivity, Security, Commerce, Media & Design, Cloud & Infra, Science & Health, Other | |
| minimum_grade | No | Worst acceptable live server grade | |
| max_latency_ms | No | Maximum measured initialize latency in milliseconds |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses that the tool searches live tool names and descriptions, and returns matching tools with server, grade, and endpoint. This adequately describes read-only search behavior and output, though rate limits and auth requirements are not mentioned.
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?
Description is concise with a clear front-loaded purpose. Each sentence contributes value (examples, result details). Slightly verbose but well-structured.
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 6-parameter search tool without output schema, the description covers purpose, usage context, and return format. Missing details like pagination or error handling, but adequate for basic understanding.
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 100%, so baseline is 3. The description adds limited meaning beyond the schema, such as framing the query parameter for 'capability or data type'. No additional context for optional parameters.
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 specifies the verb 'search' and the resource 'actual tools that graded MCP servers expose', distinguishing it from server metadata searches. Examples like 'get weather' and references to sibling tools (e.g., search_servers) reinforce differentiation.
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?
Provides explicit when-to-use guidance ('Use this when you need a specific capability or data type') and concrete examples. Does not explicitly state when not to use, but the contrast with server-level search is implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_trust_evidenceAInspect
Search published MCP trust evidence and reviewed real-usage field reports. Use for questions such as which servers expose citations, have access caveats, make unverifiable corpus claims, or show security concerns. Returns verbatim observations with dates and source type, not a synthetic trust score.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max evidence items (default 20, max 50) | |
| query | Yes | Evidence, claim, source, capability, caveat, or server keyword | |
| status | No | ||
| dimension | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries the burden. It discloses that returns are verbatim observations with dates and source type, and explicitly states it does not produce a synthetic trust score. Lacks details on permissions or rate limits.
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, front-loaded with purpose and followed by usage examples and output details. No redundant or unnecessary words.
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?
Adequate overview but lacks detail on parameter semantics and output structure (no output schema). Given moderate complexity, more guidance on enum parameters would improve completeness.
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 50%, but the description adds no additional meaning to parameters like status or dimension beyond what the schema provides. It does not explain enum values or usage.
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 searches published trust evidence and field reports, with specific verb and resource. It includes example questions that distinguish it from siblings like list_grades or search_servers.
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?
Provides context with 'Use for questions such as...' but does not explicitly state when not to use or mention alternatives. Still, the context is clear enough for typical use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
submit_feedbackAInspect
Submit a field report about an MCP server you have actually used (what worked, what failed, surprising behavior). Reports are quarantined for human review and never auto-published.
| Name | Required | Description | Default |
|---|---|---|---|
| report | Yes | The field report, 20-2000 chars, specific and factual | |
| agent_name | No | Optional: which agent/client is reporting | |
| server_name | Yes | Official registry name of the server the report is about |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses two behaviors: reports are quarantined for human review and never auto-published. However, it lacks details on success/failure responses, rate limits, or error handling, leaving gaps in behavioral understanding.
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, no waste. Front-loaded with the verb and resource, followed by content scope and behavioral note. Efficient and easy to parse.
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 or annotations, the description covers purpose, content, and a key behavioral trait (quarantine). It may lack return value info, but for a submission tool this is acceptable. Most aspects are addressed.
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 all parameters (report, agent_name, server_name) have schema descriptions. The description adds minimal extra meaning beyond mentioning content guidelines ('what worked, what failed'). For high coverage, baseline is 3.
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's purpose: submit a field report about an MCP server that was actually used, detailing what worked, failed, or surprised. It distinguishes from siblings (e.g., list_grades, search_servers) which are read/search operations, making this the only write 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?
The description implies the tool should be used after using a server, and mentions reports are quarantined and not auto-published. It does not explicitly state when not to use it, but the context of siblings (all read/search) makes the use case clear.
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.
7 tool updates
v0.3.0- First observed
get_server_grade - First observed
get_trust_receipt - First observed
list_grades - First observed
search_servers - First observed
search_tools - First observed
search_trust_evidence - First observed
submit_feedback
TDQS
Scored across 7 tools
Each tool has a clearly distinct purpose: listing top servers, getting individual grades, searching servers by task, searching tools across servers, retrieving trust receipts, searching trust evidence, and submitting feedback. No overlap.
All tools follow a consistent verb_noun pattern using snake_case (list_grades, get_server_grade, search_servers, etc.), making the interface predictable.
With 7 tools, the server is well-scoped for its purpose as a registry: covering listing, searching, detailed retrieval, and feedback submission without being overly minimal or bloated.
The tool surface covers the main registry workflows: discovery (list_grades, search_servers, search_tools), detailed inspection (get_server_grade, get_trust_receipt, search_trust_evidence), and user contribution (submit_feedback). No obvious gaps.
Maintenance
Related MCP Connectors
Publish and discover MCP servers via the official MCP Registry. Powered by HAPI MCP server.
Trust, freshness, policy, and discovery layer for public MCP servers.
Independent A-F trust grade for any MCP server, watched for drift. Free, never for sale.
Grade MCP servers A to F with the open behavioral litmus. npm: full toolset; hosted: lookups only.
Related MCP Servers
- AlicenseCqualityDmaintenanceEasily find MCP servers using our MCP registry. Search with natural language.15MIT
- 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.26 npm3MIT
- FlicenseNot gradedqualityNot gradedmaintenanceEnables querying and searching the MCP Hub database to discover MCP servers, view server details, find top servers by popularity or recency, and identify top contributors.-
- AlicenseAqualityDmaintenanceA comprehensive MCP server for checking package versions and rating package quality across Python (PyPI), JavaScript/TypeScript (npm), Dart (pub.dev), and Rust (crates.io) ecosystems.5MIT