Skip to main content
Glama

mcp-anything

CI npm License: MIT Node >= 20

One MCP server that can discover and call (almost) any MCP server in the world.

mcp-anything demo: searching the MCP ecosystem from the terminal

mcp-anything is a meta-MCP server: instead of configuring dozens of MCP servers in your host (Claude Desktop, Claude Code, Cursor, ...), you configure exactly one. It indexes the official MCP registry locally and exposes five small meta-tools that let the model search for servers, inspect them, and call their tools on the fly — without ever loading thousands of tool schemas into the context window.

Host / LLM
    │  (5 meta-tools, constant context cost)
    ▼
mcp-anything ──── local BM25 index ◄──┬── official MCP registry   (moderated, richest metadata)
    │        (cross-source dedupe,    ├── PulseMCP    (~22k servers, stars & downloads)
    │         popularity-boosted      ├── npm         (~67k packages tagged mcp)
    │         ranking)                └── Glama       (~75k indexed servers)
    │
    │  security policy: SSRF guard · stdio allowlist · secrets injection · timeouts
    ▼
downstream MCP servers   (streamable-http / sse / stdio via npx·uvx)

Why

  • Discovery: thousands of MCP servers exist; your host only knows the ones you hand-configured.

  • Context: loading many servers burns your context window. Meta-tools keep the cost constant — the model searches for capabilities in two phases (search → inspect → call), the same pattern Anthropic's Tool Search uses.

  • One config: a single entry in your MCP client config instead of one per server.

Related MCP server: Smart MCP Proxy

Quickstart

# Run directly (Node >= 20):
npx mcp-anything sync     # first-time index download (~few seconds)
npx mcp-anything serve    # start the meta-MCP server on stdio

Claude Code

claude mcp add anything -- npx -y mcp-anything serve

Claude Desktop / other hosts

{
  "mcpServers": {
    "anything": {
      "command": "npx",
      "args": ["-y", "mcp-anything", "serve"]
    }
  }
}

Then just ask your model things like "find an MCP server that can query Postgres and list its tools" — it will use the meta-tools by itself.

HTTP mode & hosted discovery

mcp-anything serve --http                    # streamable HTTP on :8080 (POST /mcp)
mcp-anything serve --http --discovery-only   # safe for public hosting: search/describe only

A public instance with execution enabled would be an open proxy — never host a full instance publicly. The Dockerfile defaults to discovery-only for exactly this reason. A hosted discovery instance lets any MCP client search the ecosystem; actually connecting and calling tools is what the local install is for.

CLI

mcp-anything sync             # refresh the registry index
mcp-anything search "weather" # search the index from your terminal
mcp-anything serve            # stdio MCP server (default command)

The meta-tools

Tool

What it does

search_mcp_servers

Keyword search (BM25 + fuzzy) over the indexed registry. Returns candidates with a connectability verdict.

describe_mcp_server

Full registry metadata: transports, packages, required env vars / secrets, policy verdict.

list_mcp_tools

Connects live (per policy) and lists the server's actual tools with JSON schemas.

call_mcp_tool

Executes one tool on a downstream server. Sessions are pooled and reused.

sync_registry

Forces an index refresh (otherwise auto-refreshed on TTL expiry).

Security model

Connecting an LLM to arbitrary servers from a public registry is dangerous by default. mcp-anything ships with conservative defaults and makes every relaxation explicit:

  • Remote servers (streamable-http / sse): allowed, but private/loopback/link-local addresses (including cloud metadata endpoints like 169.254.169.254) and plain http: are blocked — an SSRF guard for registry entries that point into your network. Opt out with remote.allowPrivateNetwork (useful for local development only).

  • Stdio servers (spawning npx / uvx processes): disabled by default. Running a package from a public registry is arbitrary code execution on your machine. Enable it only with an explicit per-package allowlist.

  • Secrets: API keys are never indexed or exposed to the model. You map them per server in your config; they are injected at connect time (headers for remote, env for stdio).

  • Untrusted output: results and tool descriptions from downstream servers are labeled as third-party data so the model treats them as data, not instructions. This reduces prompt-injection risk; it does not eliminate it — see SECURITY.md.

  • Limits: connect/call timeouts, response-size truncation, bounded session pool.

Configuration

~/.config/mcp-anything/config.json (or --config <path>, or MCP_ANYTHING_CONFIG):

{
  "registryUrl": "https://registry.modelcontextprotocol.io",
  "sources": ["official"],
  "qualityFilter": true,
  "cacheTtlHours": 24,
  "maxServers": 10000,
  "policy": {
    "remote": {
      "enabled": true,
      "allowPrivateNetwork": false,
      "headers": {
        "io.github.example/github": { "Authorization": "Bearer ghp_..." }
      }
    },
    "stdio": {
      "enabled": false,
      "allowPackages": ["@modelcontextprotocol/server-filesystem"],
      "env": {
        "io.github.example/postgres": { "DATABASE_URL": "postgres://..." }
      }
    },
    "limits": {
      "callTimeoutMs": 60000,
      "connectTimeoutMs": 20000,
      "maxSessions": 8,
      "maxResultChars": 100000
    }
  }
}

Every field is optional; the defaults above (minus the example headers/env) are what you get with no config at all. registryUrl accepts any registry implementing the official REST API — including a private/self-hosted one.

Index sources — going wide

sources controls how much of the ecosystem gets indexed:

Source

Scale

What it adds

official (default)

thousands

Moderated entries with the richest metadata (transports, env vars, versions)

pulsemcp

~22k

Broad catalog + GitHub stars & download counts (feeds ranking)

npm

~67k tagged packages

The largest raw pool of stdio servers, with monthly downloads

glama

~75k

The widest index (best-effort adapter)

{ "sources": ["official", "pulsemcp", "npm"] }

Entries appearing in several catalogs are deduplicated by normalized repository URL and package identifier; the most-trusted source wins the identity, metadata is backfilled from the others, and stars/downloads accumulate. Ranking then combines BM25 relevance with a log-scaled popularity boost (and a bonus for official-registry entries), so search_mcp_servers surfaces the maintained implementation of a capability rather than the hundredth abandoned clone. qualityFilter (default on) drops entries with no way to connect and no usable description — with wide sources, more is only better if the junk stays out of the top-5. A failed source degrades gracefully: the sync keeps whatever the other sources returned and reports the failure.

Design notes

  • Lexical search, not embeddings. Fully local, zero API cost, no index build step — and for tool discovery, keyword search with fuzzy matching performs comparably in practice (Anthropic's Tool Search made the same call with BM25/regex).

  • Sessions, not stateless calls. MCP is session-oriented (initialize handshake, capability negotiation). Downstream connections are pooled and reused across calls with LRU eviction.

  • Graceful degradation. If the registry is unreachable, the last-synced cache keeps working.

Prior art & positioning

This space is active: MetaMCP and other gateways aggregate servers you configure; Composio's Rube routes to its own curated catalog; hosts are growing native tool-search. mcp-anything's niche is the open combination: the public registry as the catalog, a local-first single binary, and an explicit security policy — no cloud account, no curation lock-in, self-hostable against a private registry.

Roadmap

  • Live health checks and result-quality signals in ranking

  • Per-tool (not just per-server) search by indexing tools/list of popular servers

  • OAuth flow passthrough for remote servers that require it

  • Container/Wasm sandboxing for stdio servers as an alternative to allowlisting

  • Multiple registries with federation and dedupe

  • Optional streamable-http serving mode (for shared/team deployment)

Development

npm install
npm test              # unit + end-to-end (mock registry + real downstream MCP server)
npm run typecheck
npm run build
node scripts/smoke.mjs  # spawns the built CLI as a real stdio MCP server

See CONTRIBUTING.md. Licensed MIT.

Available Tools

5 tools
call_mcp_toolCall a tool on an MCP serverA

Execute a specific tool on a downstream MCP server with the given arguments. Use list_mcp_tools first to get the exact tool name and input schema.

Inputs: tool (required), server (required), arguments.

describe_mcp_serverDescribe an MCP serverA

Show a server's full registry metadata: transports (remote endpoints / installable packages), required environment variables and secrets, and whether the current security policy allows connecting to it.

Inputs: name (required).

list_mcp_toolsList a server's tools (live)A

Connect to an MCP server (per security policy) and list its actual tools with their input schemas. Connection is reused for subsequent call_mcp_tool calls.

Inputs: server (required).

search_mcp_serversSearch MCP serversA

Search the MCP registry index for servers matching a task description (keyword search over names and descriptions). Returns candidate servers with their connectability. Follow up with describe_mcp_server / list_mcp_tools.

Inputs: query (required), limit.

sync_registryRefresh the registry indexA

Re-download the MCP registry index (otherwise refreshed automatically when the cache TTL expires).

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 5 tools

    Disambiguation5/5

    Each tool has a clearly distinct role: registry search, metadata inspection, live tool listing, tool execution, and registry refresh. There is no overlap between search, describe, list, call, or sync.

    Naming Consistency5/5

    All tool names follow a consistent lowercase snake_case verb_noun pattern: search_mcp_servers, describe_mcp_server, list_mcp_tools, call_mcp_tool, sync_registry. The naming is predictable and readable.

    Tool Count5/5

    Five tools is well-scoped for a meta-server that handles discovery, inspection, connection, execution, and registry maintenance. Each tool earns its place with no redundancy.

    Completeness5/5

    The tool set covers the full workflow: discover servers, inspect metadata, list tools, call tools, and refresh the registry. There are no obvious missing operations for the stated purpose of interacting with the MCP registry.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      A meta-MCP server that acts as a universal gateway, allowing users to discover and execute tools from thousands of other MCP servers through semantic search. It dynamically loads servers on demand and provides standardized functions for searching, discovering, and running tools across the entire MCP ecosystem.
      6
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Federating gateway for AI agents to discover and call tools from multiple MCP servers with intelligent search and dynamic tool registration.
      39
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables centralized routing, discovery, namespacing, and execution of tools from multiple remote MCP servers over HTTP/SSE, aggregating them behind a unified MCP gateway with dynamic server management.
      -
    • A
      license
      A
      quality
      D
      maintenance
      Enables connecting multiple downstream MCP servers into a single gateway, with unified tool search, namespacing, and deferred loading to preserve context window.
      2
      6
      MIT