공식 Model Context Protocol Registry에 공개된 서버를 발견하고, 비교하며 감사하기 위한 읽기 전용 MCP 서버입니다.
공식 Model Context Protocol Registry에 있는 서버를 발견, 비교, 감사할 수 있는 읽기 전용 MCP 서버입니다.
MCP Registry Navigator는 에이전트와 개발자가 MCP 서버를 설치하거나 공개하기 전에 실용적인 질문에 답하는 데 도움을 줍니다.
어떤 MCP 서버가 특정 작업에 가장 잘 맞을까요?
어떤 패키지 레지스트리, 전송 방식, 설치 명령어를 사용하나요?
등록된 Server.json 파일이 레지스트리 공개에 준비되었나요?
PyPI, npm, OCI MCP 서버를 공개하기 전에 어떤 체크리스트를 따라야 하나요?
이 서버는 사용자 파일을 수정하지 않습니다. 호출자가 확인한 후 직접 적용할 수 있는 구조화된 보고서, 생성된 구성 스니펫, 검토 체크리스트를 반환합니다.
Related MCP server: MCP Registry Server
MCP Registry Navigator는 에이전트와 개발자가 MCP 서버를 설치하거나 공개하기 전에 실루적인 질문에 답을 내리도록 돕습니다:
어떤 MCP 서버가 특정 작업에 가잓 맞을가요?
수 Element: 등록 어느 패키지 등록, 뭔송 방식, 설치 명령어를 사해하나요?
server.json 파일이 레지스트리 공개를 준비되었나요?
PyI, npm, OCI MCP 서버를 공개하기 전에 따라야 할 체크리스트는 무엇인가요?
이 서버는 사용자 파일을 편집하지 않습니다. 호출자가 확인한 후 직접 적용할 수 있는 구조화된 보고서, 생성된 구성 snippet, 검토 체크리스트를 반환합니다.
https://registry.modelcontextprotocol.io에서 최신 서버를 검색합니다.
레지스트리 이름과 버전으로 특정 서버를 가져옵니다.
서버의 패키지 유형, 전송 방식, 설명을 비교합니다.
공개 전에 server.json 메타데이터를 검증합니다.
PyPI, npm, OCI 패키지용 MCP 클라이언트 설치 스니펫을 생성합니다.
PyPI, npm, OCI 레지스트리 절차에 맞는 공개 체크리스트를 준비합니다.
공식 Python SDK v2를 통해 MCP 도구, 리소스, 프롬포트를 노출합니다.
로컬 TTL JSON 캐시와 결정론적 테스트 픽스처를 사용합니다.
search_servers
get_server
compare_servers
validate_server_json
generate_install_config
prepare_publish_checklist
registry://servers/{name}
registry://latest
registry://cache/status
select_mcp_server처럼
audit_mcp_metadata
prepare_mcp_release
Python 3.12 또는 그 이상.
로컬 Python 의존성, 관리를 위한 uv.
MCP Inspector를 사용할 때만 Node.js 22.19.0 이상이 필요합니다.
로컬 체크아웃에서 직접 설치합니다:
uv sync
uv run mcp-registry-navigator --version로컬 클론에서 설치합니다:
uv sync
uv run mcp-registry-navigator --version로컬 MCP 클라이언트의 기본 전송 수단인 stdio로 실행합니다:
uv run mcp-registry-navigator로컬 MCP 클라이므로므로 실행합니다:
uv run mcp-registry-navigator로컬 테스트를 위해 Streamable HTTP로 실행합니다:
uv run mcp-registry-navigator --transport streamable-http --host 127.0.0.1 --port 8000로컬 테스팅을 위해 서버를 Streamable HTTP로 실행합니다:
uv run mcp-registry-navigator --transport streamable-http --host 127.0.0.1 --port 8000MCP Inspector를 실행합니다:
npm install
npm run inspectMCP Inspector를 실행합니다::
npm install
npm run inspect이 저장소에는 .node-versions와 package.json이 포함되어 있어, 로컬 검사에서 일부 mcp dev 환경이 사용하던 구형 v1 러처 대신 @modelcontextprotocol/inspector v2를 사용합니다.
{
"mcpServers": {
"mcp-registry-navigator": {
"command": "uv",
"args": [
"--directory",
"/path/to/mcp-registry-navigator",
"run",
"mcp-registry-navigator"
]
}
}
}Pypi에 공개한 뒤에는 명령을 다음과 같이 단순화할 수 있습니다:
{
"mcpServers": {
"mcp-registry-navigator": {
"command": "uvx",
"args": ["mcp-registry-navigator"]
}
}
}uv run python -m pytest -q
uv run ruff check .
uv run mypy
uv build
npm run inspect테스트 스위트는 결정론적 오프라인 커버리지를 확보하기 위해 가짜 레지스트리 응답을 사용합니다. MCP 통합 테스트는 SDK의 인-메모리 클라이언트를 사용하며 포트를 열지 않습니다.
기본 cache 파일입니다:
~/.cache/mcp-registry-navigator/registry-cache.json시 기본 파일 야는 형태:
~/.cache/mcp-registry-navigator/registry-cache.jsonXDG_CACHE_HOME를 설정하면 캐시 트를 변경할 수 있습니다. 포함된 디С크 쓰기를 원하지 않는 테스트 또는 코드에서는 NullCache를 사용하세요.
이 프로젝트는 현재 알파 상태입니다. MCP 레지스트리와 Python SDK의 발전에 따라 MIWA 등록에서 권장 사항이 변경될 수 있습니다.
PyPI에 공개하기 전에 pyproject.toml의 [project.urls]에 실제 GitHub repository 주소와 이슈 트래커를 추가하세요.
나중에 이 서버를 공식 MCP 레지스트리에 PyPI 패키지로 공개할 경우, 이 README에 레지스트리 검증 마귀를 추가하세요:
<!-- mcp-name: io.github.YOUR_GITHUB_USERNAME/mcp-registry-navigator -->이 후에 서버를 MCP 레지스트리의 소개 패키지 PyPI로 공개하게 되면 README에 레지스트리 검증 마귀를 추가하세요.
MIT. LICENSE를 참고하세요.
Compare package types, transports, and summaries for MCP servers.
| Name | Required | Description | Default |
|---|---|---|---|
| names | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, covering safety and open-world behavior; the description does not contradict these. It adds the specific aspects compared (package types, transports, summaries), but offers no detail on output shape, behavior with unknown names, or duplicate inputs. With annotations lowering the bar, this is adequate but not rich.
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?
An eleven-word single sentence with zero waste. The verb and resource are front-loaded, and every word contributes meaning. Appropriately sized for the tool's simplicity.
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 tool is low-complexity (one parameter, no nested objects), an output schema exists so return values need no explanation, and annotations cover the safety/open-world profile. The description identifies the comparison dimensions and domain. The only minor gap is not explicitly framing it as a multi-server side-by-side comparison distinct from get_server, but nothing critical for correct invocation 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 0%, so the schema gives only 'names: array of strings, min 2, max 5'. The description adds crucial domain context that 'names' refers to MCP server names, which the bare schema omits. However, it does not specify whether names must be exact identifiers, case sensitivity, or ordering semantics — leaving moderate ambiguity for the sole 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 names a specific verb ('Compare') with a defined resource ('MCP servers') and the precise comparison dimensions (package types, transports, summaries). This clearly distinguishes it from siblings — search_servers, get_server, validate_server_json, generate_install_config, prepare_publish_checklist — none of which perform a comparison.
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 verb 'compare' implies usage for comparing multiple servers side-by-side, and the minItems=2 constraint reinforces that. However, the description offers no explicit when-to-use/when-not-to-use guidance and names no alternatives, such as directing single-server lookups to get_server. Usage context is inferred, not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate an MCP client configuration snippet for one server.
| Name | Required | Description | Default |
|---|---|---|---|
| server_json | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and openWorldHint=false, which the description does not contradict. The description adds minimal behavioral context beyond the annotation (e.g., that it produces a snippet for one server), but does not disclose limitations, side effects, or dependencies. With annotations covering the safety profile, a score of 3 is appropriate.
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, front-loaded sentence with no wasted words. It delivers the core purpose immediately and is efficiently 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?
Although an output schema exists (so return values are not needed in the description), the input parameter is completely underspecified. With no guidance on server_json structure and no usage context, the tool is not fully described for an agent to call it correctly. The description is too sparse for a tool with an unstructured object parameter.
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 0%, and the description adds no information about the server_json parameter. The schema only indicates an object with additionalProperties, so an agent has no idea what fields or structure to provide. The description does nothing to clarify parameter meaning.
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 states a clear action ('generate'), a specific output ('MCP client configuration snippet'), and a scope ('for one server'). It is distinct from sibling tools like search_servers or validate_server_json, which focus on retrieval or validation, not generation.
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 provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, typical scenarios, or when to prefer another tool such as prepare_publish_checklist. Usage context is entirely absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch one MCP Registry server metadata record.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Registry server name, such as io.github.user/server. | |
| version | No | Exact version or latest. | latest |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description is consistent with that. The phrase 'metadata record' adds a small nuance that it returns metadata, not the actual server, but it does not disclose any additional behavior such as error handling, version resolution, or pagination. Given annotations cover the safety profile, the description adds minimal extra value.
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?
A single sentence with no filler. The purpose is front-loaded and every word contributes. It is appropriately minimal without sacrificing clarity.
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 simple fetch-with-optional-version tool, the description, combined with schema and output schema, is complete. The absence of explicit error-handling context is acceptable given this is a read-only operation with openWorldHint and the output schema defines the return structure. A minor gap is the lack of mention of 'version' behavior, but that is documented in the schema.
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%—both 'name' and 'version' are documented in the input schema. The description adds no additional parameter semantics beyond what the schema already provides, so the baseline score of 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?
The description clearly states the action ('Fetch') and the resource ('one MCP Registry server metadata record'). It distinguishes from siblings like search_servers (which presumably returns multiple) and compare_servers (which compares), making the tool's specific role obvious even without examining the schema.
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 provides no explicit guidance on when to use this tool versus alternatives. It does not mention that search_servers might be better for finding servers or that this tool is for retrieving a known server by name. The agent must infer usage context from the schema and sibling names, but the description itself offers no direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return a publication readiness checklist for a server.json file.
| Name | Required | Description | Default |
|---|---|---|---|
| server_json | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotation readOnlyHint=true already covers the non-mutating nature. The description adds the fact that it returns a checklist, but no further behavioral details (e.g., what happens with invalid input). It is consistent with annotations and provides minimal added context, so a 3 is appropriate.
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?
A single, focused sentence that states the purpose without any fluff. Every word adds value, and the sentence is front-loaded with the action and target.
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 omits critical usage context, such as when to call this tool versus validate_server_json or other siblings. It does not mention what constitutes 'publication readiness' or how the output might be used. Although an output schema exists, the description itself leaves the agent without enough context to decide when to use it.
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 0%, and the only parameter 'server_json' has no schema description or enum. The description merely says 'for a server.json file' but does not explain the expected format, structure, or any constraints. It does not compensate for the lack of schema documentation.
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 states a clear verb ('Return') and resource ('publication readiness checklist') for a specific target ('server.json file'). It is unambiguous, but it does not explicitly differentiate from siblings like validate_server_json or generate_install_config, so it loses one point.
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?
No guidance is given on when to use this tool versus its siblings. The description does not mention alternatives, exclusions, or prerequisites, leaving the agent to infer appropriateness.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search latest public MCP Registry server metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | No | Substring to search in server names. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and openWorldHint=true, so the description is not burdened with conveying safety or completeness. The phrase 'latest' adds a slight behavioral nuance (implying freshness), but it does not describe how the limit parameter interacts with results, whether results are ordered, or any pagination behavior. It neither contradicts nor meaningfully expands on 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 a single, compact sentence with no redundant words. It front-loads the core action and target. While it is short, it does not waste space; however, the brevity comes at the cost of necessary detail, making it less effective than a longer but more informative description.
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?
Although an output schema exists (which covers return fields), the description lacks essential context for correct invocation. It does not clarify how results are limited (despite the 'limit' parameter), how the query matching works, or when to prefer this tool over get_server. The description is minimal and does not help an agent make an informed decision among the listed siblings.
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 provides a description for 'query' ('Substring to search in server names') but no description for 'limit'. Since schema description coverage is 50%, the tool description should compensate for the missing parameter semantics, but it does not mention either parameter at all. An agent would have to infer the meaning of 'limit' from its constraints alone, which is insufficient.
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 a verb ('search') and a resource ('latest public MCP Registry server metadata'). It distinguishes the tool from siblings like get_server (which retrieves a single server) by focusing on searching, but does not explicitly clarify what 'metadata' includes or how search results are ordered. It is clear enough for a basic understanding, but leaves some ambiguity about the extent of the 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?
The description provides no guidance on when to use this tool versus alternatives such as get_server, compare_servers, or validate_server_json. It does not mention any exclusions or conditions that would help an agent decide between them. The absence of usage context is a significant gap given the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate MCP Registry server.json metadata without publishing it.
| Name | Required | Description | Default |
|---|---|---|---|
| server_json | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint:true, so the description adds the specific 'validate' behavior but does not go beyond the annotation's safety profile. It reinforces that this is a read-only operation but adds no new behavioral details.
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, tightly worded sentence with no filler words. The verb 'Validate' is front-loaded, and the scope is immediately clear.
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 simple single-parameter tool and the presence of an output schema (which handles return details), the description covers the essential purpose and the non-publishing aspect. No additional information is strictly needed for an agent to call it correctly.
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 0%, so the description must compensate. It clarifies that the server_json parameter refers to 'server.json metadata', adding meaning beyond the generic 'Server Json' in the schema. However, it does not explain the object vs. string distinction or expected format beyond that.
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 specific verb 'Validate', the resource 'MCP Registry server.json metadata', and adds the scope 'without publishing it'. This distinguishes it from a publish action and clearly separates it from sibling tools like search_servers or prepare_publish_checklist.
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 phrase 'without publishing it' provides clear context that this tool is for pre-publish validation, implying when it should be used. However, it does not explicitly name alternatives or exclusions, though the context makes usage obvious.
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.
v0.1.0compare_serversgenerate_install_configget_serverprepare_publish_checklistsearch_serversvalidate_server_jsonScored across 6 tools
Each tool performs a distinct operation: search, fetch, compare, validate, generate config, and checklist. There is no overlap or ambiguity between them.
All tool names follow a consistent verb_noun snake_case pattern (search_servers, get_server, compare_servers, validate_server_json, generate_install_config, prepare_publish_checklist), making them predictable and easy to parse.
With 6 tools, the set is well-scoped for a registry navigator and pre-publish helper. Each tool covers a necessary step in browsing, validating, and preparing server configurations without excess.
The tool surface covers search, retrieval, comparison, validation, config generation, and publication readiness. A direct publish tool is missing, but that may be intentionally outside the 'navigator' scope, so the gap is minor.
Publish and discover MCP servers via the official MCP Registry. Powered by HAPI MCP server.
The MCP server that finds MCP servers. Aggregates Official Registry, Glama, and Smithery.
Search the public universe of MCP servers. This data comes from the Official MCP Registry.
Search the official MCP registry: 17,000+ servers with trust grades, stars, tools, install config.
