convez.ai
MCP ServerIntegração & APIsAvançado
jianran

MCP Discovery Service

jianran/mcp-ds

DNS para descoberta dinâmica de ferramentas MCP por capacidade

Ver no GitHub
InicialPluginScore · de 0 a 100

Um serviço de descoberta federapado para servidores MCP que funciona como um DNS para ferramentas de agentes. Permite que agents encontrem dinamicamente ferramentas por capacidade em tempo de execução, com suporte a confiança transitiva e verificação de identidade.

Instalação

$npx convez-ai jianran/mcp-ds

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Agentes encontrarem ferramentas dinamicamente em tempo de execução sem configuração prévia
  • Registros federados consultarem múltiplos repositórios de servidores MCP simultaneamente
  • Verificar legitimidade e segurança de servidores MCP antes da conexão
  • Resolver endpoints de ferramentas por capacidade técnica (storage, read_file, oauth2, etc)

Veredito

Infraestrutura técnica sofisticada que resolve um problema real na escalabilidade de agentes IA — a descoberta dinâmica de ferramentas. Exige compreensão profunda de protocolo MCP e arquitetura distribuída; ideal para times construindo plataformas multi-agente corporativas.

README

A tradução para o português deste README ainda está na fila.

MCP-DS — MCP Discovery Service

The DNS for agent tools.

A federated protocol for dynamic MCP server discovery by capability, with transitive trust.

Why

MCP (Model Context Protocol) standardized how agents connect to tools — but not how they find them. Today, every MCP server is hard-configured in a JSON file before the agent starts:

{
  "mcpServers": {
    "filesystem": { "command": "npx", "args": ["@modelcontextprotocol/server-filesystem", "/tmp"] }
  }
}

This breaks when:

  • An agent needs a tool at runtime that wasn't pre-configured
  • You have 14,000 servers across 8 registries and no way to query by capability
  • You need to verify a server is legitimate before connecting
  • A server endpoint changes and every config file needs updating

MCP-DS fixes this by adding a programmatic discovery layer — agent runtimes query for tools by capability, get back verified endpoints, and connect dynamically.

The Stack (Where This Fits)

L4  Application           CrewAI / LangGraph / Claude SDK
                            ↑ A2A agent handoff
L3  Communication          MCP tools + resources
                            ↑ MCP-DS ← YOU ARE HERE
L2  Runtime                LangGraph / OpenAI SDK / Smolagents
                            ↑ OpenAI API format
L1  Models                 GPT-4o / Claude / Gemini / vLLM

Protocol Overview

MCP-DS defines four things:

ComponentWhatAnalogy
Registry APIStandard REST/gRPC API that any registry implementsDNS server
Capability QueryResolve {domain, action, inputs} → [MCP server URLs + trust]SRV record lookup
Server Card.well-known/mcp-server-card — discoverable metadata on any MCP hostrobots.txt
Trust ChainSigned attestations: registry signs server metadata, server signs its tool listDNSSEC

Key Design Decisions

Federated, Not Centralized

Multiple registries coexist. The protocol defines:

  • A standard query API (→ any registry is interchangeable)
  • A sync/zone-transfer mechanism (→ registries can mirror each other)
  • A namespace model based on reverse-DNS (→ io.github.username/server-name)

No single registry is the source of truth. Clients query the registry they trust, or multiple registries and merge results.

Query by Capability, Not Name

The primary query mode is what the agent needs to do, not what server to use:

Query:  { domain: "storage", action: "read_file", constraints: { "auth": "oauth2" } }
Result: [
  { uri: "mcp://filesystem.example.com", trust: 0.92, auth: "oauth2" },
  { uri: "mcp://s3-bridge.internal", trust: 0.85, auth: "api_key" }
]

Transitive Trust

Trust is layered:

  1. Registry-level: The official registry verifies namespace ownership (GitHub OAuth, domain DNS challenge)
  2. Publisher-level: Signed attestations link a server version to a publisher identity
  3. Audit-level: Third-party scanners (JFrog, etc.) can sign security audit results
  4. Client-level: The agent runtime decides what trust threshold to accept

Every MCP-DS response includes a trust score (0.0 – 1.0) derived from these layers.

Dynamic, Not Static

Servers come and go. MCP-DS is designed for:

  • Runtime resolution: Agent says "I need X" → runtime queries registry → connects immediately
  • Health probing: Registry periodically checks that servers are actually reachable
  • Version pinning: Agent can request >=1.2, <2.0 and get the right version
  • Deprecation signaling: Registry marks servers as deprecated with migration hints

API Surface

GET  /v1/query?domain=storage&action=read_file&auth=oauth2
     → { servers: [{ uri, trust, auth, version, publisher }] }

GET  /v1/servers/{namespace}/{name}
     → { server card with full metadata }

GET  /v1/servers/{namespace}/{name}/versions
     → { versions: [{ version, published_at, checksum }] }

GET  /v1/resolve?capability=mcp://capability-id
     → [resolved server URIs with trust chains]

GET  /v1/trust/{namespace}/{name}@{version}
     → { signed attestations from registries, publishers, auditors }

Roadmap

PhaseWhatStatus
v0.1Server Card standard + basic query APISpec draft
v0.2Federated sync protocol between registriesPlanned
v0.3Trust chain spec (attestation format + verification)Planned
v1.0Production spec + reference implementation (registry + client SDK)TBD

This is a protocol spec project. Read spec/ for the detailed proposal.

Ver o original no GitHub

Bom para

Relacionados