⚡ Quick Deploy (One-Liner)

Start the registry immediately with default settings:

docker compose up -d

Did this save you time? Give us a Star on GitHub — it helps others discover this registry!

Configuration:

• Set MCP_SANDBOX_PROVIDER=LOCAL in .env file if you want to disable the sandbox (not recommended for production).
• See Configuration Guide for full details.

[!TIP] Tip for Private Deployment: This registry contains 4547+ public MCP servers. If you only need a specific subset for your private environment, you can prune the packages/ directory. 📖 See Package Management Guide for details.

That's it! Your self-hosted MCP registry is now running with:

• 🌐 HTTP API with OpenAPI documentation
• 🛡️ Secure Sandbox execution for AI agent tools
• 🔍 Full-text search (Meilisearch)

🎉 Access Your Private MCP Registry

• 🌐 Local Web Interface: http://localhost:3003
• 📚 Swagger API Docs: http://localhost:3003/swagger
• 🔍 Search & Execute 4547+ MCP Servers remotely
• 🤖 Integrate with your AI agents, chatbots, and LLM applications

🌐 Remote Tool Execution Example

Execute any MCP tool via HTTP API - perfect for AI automation, chatbot integrations, and serverless deployments:

curl -X POST http://localhost:3003/api/v1/packages/run \
  -H "Content-Type: application/json" \
  -d '{
    "packageName": "@modelcontextprotocol/server-everything",
    "toolKey": "echo",
    "inputData": {
      "message": "Hello from ToolSDK MCP Registry!"
    },
    "envs": {}
  }'

🔌 MCP Gateway (Streamable HTTP Proxy)

The registry also acts as an MCP Gateway — any registered package can be accessed as a standard Streamable HTTP endpoint, even if the original server is STDIO-only.

Endpoint: POST /mcp/<packageName>

Pass environment variables via x-mcp-env-* headers:

curl -X POST http://localhost:3003/mcp/@modelcontextprotocol/server-github \
  -H "Content-Type: application/json" \
  -H "x-mcp-env-GITHUB_PERSONAL_ACCESS_TOKEN: ghp_your_token" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

The server returns a mcp-session-id header — include it in subsequent requests to reuse the session (sessions expire after 30 min).

This is useful for:

• Protocol Bridging — Expose local STDIO servers as remote HTTP endpoints
• Centralized Access — Give AI agents a single HTTP gateway to all MCP tools
• Client Compatibility — Connect from any MCP client that supports Streamable HTTP

Alternative: Use as Registry SDK (Data Only)

If you only need to access the list of MCP servers programmatically (without execution or gateway features), you can use the NPM package.

npm install @toolsdk.ai/registry

Usage

Perfect for building your own directory or analysis tools:

import mcpServerLists from '@toolsdk.ai/registry/indexes/packages-list.json';

Access via Public API (No Installation Required)

Fetch the complete MCP server registry programmatically:

curl https://toolsdk-ai.github.io/toolsdk-mcp-registry/indexes/packages-list.json

// JavaScript/TypeScript - Fetch API
const mcpServers = await (
  await fetch('https://toolsdk-ai.github.io/toolsdk-mcp-registry/indexes/packages-list.json')
).json();

// Use for AI agent tool discovery, LLM integrations, etc.
console.log(mcpServers);

# Python - For AI/ML projects
import requests

mcp_servers = requests.get(
    'https://toolsdk-ai.github.io/toolsdk-mcp-registry/indexes/packages-list.json'
).json()

# Perfect for LangChain, CrewAI, AutoGen integrations

Why ToolSDK MCP Registry?

ToolSDK MCP Registry is an enterprise-grade gateway for Model Context Protocol (MCP) servers. It solves the challenge of securely discovering and executing AI tools in production environments.

Key Features

• Federated Registry - Unified search across local private servers and the official @modelcontextprotocol/registry.
• Unified Interface - Access local STDIO tools and remote StreamableHTTP servers via a single, standardized HTTP API.
• Secure Sandbox - Execute untrusted tools in isolated environments (supports E2B, Daytona, Sandock).
• OAuth 2.1 Proxy - Built-in OAuth 2.1 implementation to handle complex authentication flows for your agents. Integration Guide
• Private & Self-Hosted - Full control over your data and infrastructure with Docker deployment.
• Developer-Friendly - OpenAPI/Swagger documentation and structured JSON configs.

Use Cases

• Enterprise AI Gateway - Centralize tool access for all your internal LLM applications.
• Secure Tool Execution - Run community MCP servers without risking your local environment.
• Protocol Adaptation - Connect remote agents (via HTTP API) to local CLI tools (via STDIO).
• Unified Discovery - One API to search and manage thousands of tools.

Architecture

graph TD
    subgraph ClientSide ["Client Side"]
        LLM["🤖 AI Agent / LLM"]
        User["👤 User / Developer"]
    end

    subgraph DockerEnv ["🐳 Self-Hosted Infrastructure"]
        
        subgraph RegistryCore ["Registry Core"]
            API["🌐 Registry API"]
            Search["🔍 Meilisearch"]
            DB["📚 Registry Data"]
            OAuth["🔐 OAuth Proxy"]
        end

        subgraph RuntimeEnv ["Runtime Environment"]
            Local["💻 Local Exec"]
            Sandbox["🛡️ Secure Sandbox"]
            MCPServer["⚙️ MCP Server"]
        end
    end

    User -->|Search Tools| API
    LLM -->|Execute Tool| API
    LLM -->|Auth Flow| OAuth
    API <-->|Query Index| Search
    API -->|Read Metadata| DB
    API -->|Run Tool| Local
    API -->|Run Tool| Sandbox
    Local -->|Execute| MCPServer
    Sandbox -->|Execute| MCPServer

What You Get

This open-source project provides:

• Structured Registry - 4547+ MCP servers with metadata
• Unified Gateway - HTTP API to query and execute tools remotely
• Auto-Generated Docs - Always up-to-date README and API documentation

✅ Validated Packages = One-Line Integration (ToolSDK)

Some packages in this registry are marked as validated: true.

[!NOTE] What does validated: true mean for you?

• You can load the MCP package directly via our ToolSDK NPM client and get ready-to-use tool adapters (e.g. Vercel AI SDK tools) without writing your own tool schema mapping.
• The registry index includes the discovered tools metadata for validated packages, so you can pick a toolKey and call it immediately.

Where is this flag stored?

• See indexes/packages-list.json entries (e.g. `{"validated": t