@toolsdk.ai/registry 1.0.115 → 1.0.117

package/README.md

@@ -9,25 +9,53 @@
 ![How many MCP Servers in Awesome MCP Registry](https://img.shields.io/badge/MCP_Servers-4108-blue)
 ![awesome-mcp-registry License](https://img.shields.io/badge/LICENSE-MIT-ff69b4)
 
-An open, high-quality, well-structured and developer-friendly list of 4108+ MCP servers.
+🚀 **Open-source**, **production-ready**, and **developer-friendly** registry for 4108+ Model Context Protocol (MCP) servers, plugins, and AI agent tools.
+
+Perfect for **AI automation**, **chatbot development**, **LLM integrations**, and **enterprise AI deployments**.
 
 ---
 
 </div>
 
-The **Awesome MCP Registry** acts as a central database for MCP servers and packages.  
+## 🌟 Why Awesome MCP Registry?
+
+**Awesome MCP Registry** is the most comprehensive, self-hosted registry for Model Context Protocol (MCP) servers and AI agent tools. Built for developers, teams, and enterprises who need full control over their AI infrastructure.
 
-You can use it to:
+### 🎯 Key Features
 
-- ⚡ Build and host your own MCP projects with ease  
-- 🔒 Deploy a fully **private registry** for your team or organization  
-- 🚀 **Execute MCP tools remotely** in a secure sandbox environment  
+- 🔐 **Private & Self-Hosted** - Deploy your own secure MCP registry with Docker in minutes
+- 🤖 **4108+ AI Tools** - Largest curated collection of MCP servers for Claude, LLMs, and AI agents
+- ⚡ **Remote Execution** - Run MCP tools in isolated sandbox environments via REST API
+- 🔍 **Powerful Search** - Fast, full-text search powered by Meilisearch
+- 📦 **NPM Integration** - Use as a TypeScript/Node.js SDK in your projects
+- 🛠️ **Developer-Friendly** - OpenAPI/Swagger documentation, structured JSON configs
+- 🐳 **Docker Ready** - Production-grade deployment with Docker Compose
+- 🔌 **Plugin System** - Extensible architecture for custom integrations
 
-This registry leverages structured JSON configs to generate:  
+### 💡 Use Cases
 
-- `README.md`  
-- [npm package](https://www.npmjs.com/package/@toolsdk.ai/registry)  
-- [packages-list.json](https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json)  
+- 🏢 **Enterprise AI Teams** - Deploy private MCP registry for your organization
+- 🤖 **AI Agent Development** - Build and test AI agents with verified MCP tools
+- 💬 **Chatbot Builders** - Integrate LLM-powered chatbots with MCP servers
+- 🔧 **Developer Tools** - Access automation tools, APIs, and integrations
+- 🚀 **CI/CD Automation** - Execute MCP tools in your deployment pipelines
+
+---
+
+## 📦 What You Get
+
+This open-source registry provides:
+
+- 📚 **Structured Database** - 4108+ validated MCP servers with metadata
+- 🔗 **Multiple Formats** - JSON, npm package, and generated documentation
+- 🌐 **REST API** - Query and execute tools remotely
+- 📖 **Auto-Generated Docs** - Always up-to-date README and API documentation
+
+**Available as:**
+
+- 📄 `README.md` - Human-readable documentation
+- 📦 [npm package](https://www.npmjs.com/package/@toolsdk.ai/registry) - TypeScript/JavaScript SDK
+- 🔗 [packages-list.json](https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json) - Raw data API  
 
 ---
 
@@ -78,75 +106,118 @@ This registry leverages structured JSON configs to generate:
 
 ## 🚀 Quick Start
 
-### 🐳 Docker Self-Hosting
+### 🐳 Self-Hosted MCP Registry with Docker
+
+Deploy your own **private MCP registry** in 5 minutes! Get a production-ready AI agent tool registry with full-text search, REST API, and secure sandbox execution.
 
-Deploy your **private MCP Registry** in 5 minutes with Docker! Take full control of your MCP servers with search functionality and secure sandbox execution.
+Perfect for **AI developers**, **LLM teams**, and **enterprises** building with Claude, Anthropic, and other AI platforms.
 
-#### Quick Deploy (2 Steps)
+#### ⚡ Quick Deploy (2 Steps)
 
-**Step 1: Get and Set API Key**
+**Step 1: Configure Sandbox Environment**
 
-- Get your Sandock API Key from https://sandock.ai
+- Get your Sandock API Key from https://sandock.ai (for secure remote code execution)
 - Edit `.env` and set: `SANDOCK_API_KEY=your-api-key-here`
 
-**Step 2: Start services**
+**Step 2: Launch with Docker Compose**
 
 ```bash
 docker compose up -d
 ```
 
-#### 🎉 Access Your Private Registry
+That's it! Your self-hosted MCP registry is now running with:
+- 🔍 **Full-text search** (Meilisearch)
+- 🌐 **REST API** with OpenAPI documentation
+- 🛡️ **Sandbox execution** for AI agent tools
+
+#### 🎉 Access Your Private AI Tool Registry
 
 - 🌐 **Web Interface**: http://localhost:3003
-- 📚 **API Documentation**: http://localhost:3003/swagger  
-- 🔍 **Search & Execute** MCP tools remotely
+- 📚 **Swagger API Docs**: http://localhost:3003/swagger  
+- 🔍 **Search & Execute** 4108+ MCP tools remotely
+- 🤖 **Integrate** with your AI agents, chatbots, and LLM applications
+
+#### 💻 Remote Tool Execution Example
 
-#### Usage Example
+Execute any MCP tool via REST API - perfect for AI automation, chatbot integrations, and serverless deployments:
 
 ```bash
-# Execute a tool remotely
 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, ToolSDK MCP Registry"
+      "message": "Hello from Awesome MCP Registry!"
     },
     "envs": {}
   }'
 ```
 
-> For more details about Docker Self-Hosting, see the [DEVELOPMENT documentation](./docs/DEVELOPMENT.md#4--quick-start-with-docker).
+**Use Cases:**
+- 🤖 Build AI agents with remote tool execution
+- 💬 Power chatbots with MCP server integrations
+- 🚀 Create serverless AI workflows
+- 🔧 Automate tasks with LLM-powered tools
+
+> 📖 For advanced deployment options and configuration, see the [DEVELOPMENT documentation](./docs/DEVELOPMENT.md#4--quick-start-with-docker).
 
 <a id="install-via-package-manager"></a>
 
-### Install via package manager:
+### 📦 Install as NPM Package (TypeScript/Node.js SDK)
+
+Use the MCP Registry as a TypeScript/JavaScript SDK in your AI agent, chatbot, or LLM integration projects:
 
 ```bash
 npm install @toolsdk.ai/registry
 ```
 
-### Use it on your JavaScript / Typescript project:
+#### Use in TypeScript/JavaScript Projects
+
+Perfect for AI agent development, chatbot builders, and LLM tool integrations:
 
 ```ts
 import mcpServerLists from '@toolsdk.ai/registry/indexes/packages-lists.json';
 ```
 
-### Fetch all MCP Servers lists via cURL:
+#### 🌐 Access via Public API (No Installation Required)
+
+Fetch the complete MCP server registry programmatically - ideal for AI applications, integrations, and automation:
 
 ```bash
 curl https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json
 ```
 
 ```ts
-// JavaScript TypeScript
-console.log(await(await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json')).json());
+// JavaScript/TypeScript - Fetch API
+const mcpServers = await (
+  await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json')
+).json();
+
+// Use for AI agent tool discovery, LLM integrations, etc.
+console.log(mcpServers);
+```
+
+```python
+# Python - For AI/ML projects
+import requests
+
+mcp_servers = requests.get(
+    'https://toolsdk-ai.github.io/awesome-mcp-registry/indexes/packages-list.json'
+).json()
+
+# Perfect for LangChain, CrewAI, AutoGen integrations
 ```
 
 <a id="submit-new-mcp-servers"></a>
 
-## 📦 Submit new MCP servers:
+## 🤝 Contribute Your MCP Server
+
+Help grow the world's largest open-source MCP registry! Share your AI tools, plugins, and integrations with the community.
+
+### How to Submit
+
+**1. Create JSON Config** - Simple, structured format:
 
 ```json
 {
@@ -166,17 +237,34 @@ console.log(await(await fetch('https://toolsdk-ai.github.io/awesome-mcp-registry
 }
 ```
 
-[Fork this repo](https://github.com/toolsdk-ai/awesome-mcp-registry/fork), and create a new file called `your-new-mcp-server.json` under [packages/uncategorized](./packages/uncategorized) folder.
+**2. Submit via Pull Request**
+
+- [Fork this repository](https://github.com/toolsdk-ai/awesome-mcp-registry/fork)
+- Create `your-mcp-server.json` in [packages/uncategorized](./packages/uncategorized)
+- Submit a PR and join 4108+ MCP servers!
+
+**3. Get Discovered**
+
+Your MCP server will be:
+- ✅ Listed in the registry
+- 🔍 Searchable via REST API
+- 📦 Available in npm package
+- 🌐 Featured on our website
 
-For more detail please see [the guide](./docs/guide.md).
+📖 **Detailed Guide**: [Contributing Documentation](./docs/guide.md)
+
+---
 
 <a id="mcp-servers"></a>
 
-## MCP Servers
+## 📋 MCP Servers Directory
+
+**4108+ AI Agent Tools, LLM Integrations & Automation Servers**
 
-✅: Validated and runnable tools (709)
+- ✅ **Validated & Tested** (709) - Production-ready MCP servers
+- ⚙️ **Community Contributed** (3399) - Requires configuration
 
-❌: Cannot be run by the MCP client (with mock environments variables (3399))
+Browse by category: Developer Tools, AI Agents, Databases, Cloud Platforms, APIs, and more!
 
 
 

package/dist/domains/sandbox/clients/daytona-client.js

@@ -5,6 +5,22 @@ import { getDirname } from "../../../shared/utils/file-util";
 import { extractLastOuterJSON } from "../../../shared/utils/string-util";
 import { PackageRepository } from "../../package/package-repository";
 import { generateMCPTestCode } from "../sandbox-utils";
+// Singleton Daytona client shared across all instances to prevent memory leaks
+let sharedDaytonaClient = null;
+function getDaytonaClient() {
+    if (!sharedDaytonaClient) {
+        const config = getDaytonaConfig();
+        const daytonaConfig = {
+            apiKey: config.apiKey,
+        };
+        if (config.apiUrl) {
+            daytonaConfig.apiUrl = config.apiUrl;
+        }
+        sharedDaytonaClient = new Daytona(daytonaConfig);
+        console.log("[DaytonaSandboxClient] Shared Daytona client initialized");
+    }
+    return sharedDaytonaClient;
+}
 /**
  * Daytona Sandbox Client
  * Implements SandboxClient interface for Daytona provider
@@ -27,14 +43,8 @@ export class DaytonaSandboxClient {
         }
         this.initializing = (async () => {
             try {
-                const config = getDaytonaConfig();
-                const daytonaConfig = {
-                    apiKey: config.apiKey,
-                };
-                if (config.apiUrl) {
-                    daytonaConfig.apiUrl = config.apiUrl;
-                }
-                const daytona = new Daytona(daytonaConfig);
+                // Use shared singleton Daytona client instead of creating new one per initialization
+                const daytona = getDaytonaClient();
                 const declarativeImage = Image.base("node:20")
                     .runCommands("npm install -g pnpm", "mkdir -p /workspace", "cd /workspace && npm init -y", "cd /workspace && pnpm add @modelcontextprotocol/sdk")
                     .workdir("/workspace");

package/dist/domains/sandbox/clients/sandock-client.d.ts

@@ -13,7 +13,9 @@ export declare class SandockSandboxClient implements SandboxClient {
     initialize(): Promise<void>;
     private executeShellCommand;
     private executeCode;
+    private cleanupTempFileAsync;
     listTools(packageKey: string): Promise<Tool[]>;
     executeTool(packageKey: string, toolName: string, argumentsObj: Record<string, unknown>, envs?: Record<string, string>): Promise<unknown>;
     destroy(): Promise<void>;
+    private destroySandboxAsync;
 }

package/dist/domains/sandbox/clients/sandock-client.js

@@ -5,6 +5,21 @@ import { getDirname } from "../../../shared/utils/file-util";
 import { extractLastOuterJSON } from "../../../shared/utils/string-util";
 import { PackageRepository } from "../../package/package-repository";
 import { generateMCPTestCode } from "../sandbox-utils";
+// Singleton HTTP client shared across all instances to prevent memory leaks
+let sharedSandockClient = null;
+function getSandockClient() {
+    if (!sharedSandockClient) {
+        const config = getSandockConfig();
+        sharedSandockClient = createSandockClient({
+            baseUrl: config.apiUrl,
+            headers: {
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+        });
+        console.log("[SandockSandboxClient] Shared HTTP client initialized");
+    }
+    return sharedSandockClient;
+}
 /**
  * Sandock Sandbox Client
  * Implements SandboxClient interface for Sandock provider
@@ -16,13 +31,8 @@ export class SandockSandboxClient {
         const __dirname = getDirname(import.meta.url);
         const packagesDir = path.join(__dirname, "../../../../packages");
         this.packageRepository = new PackageRepository(packagesDir);
-        const config = getSandockConfig();
-        this.client = createSandockClient({
-            baseUrl: config.apiUrl,
-            headers: {
-                Authorization: `Bearer ${config.apiKey}`,
-            },
-        });
+        // Use shared singleton client instead of creating new one per instance
+        this.client = getSandockClient();
     }
     async initialize() {
         if (this.sandboxId) {
@@ -35,17 +45,16 @@ export class SandockSandboxClient {
         this.initializing = (async () => {
             try {
                 // Create sandbox with pre-built MCP image
-                const createResponse = await this.client.POST("/api/sandbox", {
+                const { data, error } = await this.client.POST("/api/sandbox", {
                     body: {
                         image: "seey/sandock-mcp:latest",
                         workdir: "/mcpspace",
                     },
                 });
-                if (!createResponse.data) {
-                    const errorMsg = "error" in createResponse ? JSON.stringify(createResponse.error) : "Unknown error";
-                    throw new Error(`Failed to create sandbox: ${errorMsg}`);
+                if (error) {
+                    throw new Error(`Failed to create sandbox: ${JSON.stringify(error)}`);
                 }
-                this.sandboxId = createResponse.data.data.id;
+                this.sandboxId = data.data.id;
                 console.log(`[SandockSandboxClient] Sandbox created successfully: ${this.sandboxId}`);
             }
             catch (error) {
@@ -62,7 +71,7 @@ export class SandockSandboxClient {
         if (!this.sandboxId) {
             throw new Error("Sandbox not initialized. Call initialize() first.");
         }
-        const response = await this.client.POST("/api/sandbox/{id}/shell", {
+        const { data, error } = await this.client.POST("/api/sandbox/{id}/shell", {
             params: {
                 path: {
                     id: this.sandboxId,
@@ -72,12 +81,11 @@ export class SandockSandboxClient {
                 cmd,
             },
         });
-        if (!response.data) {
-            const errorMsg = "error" in response ? JSON.stringify(response.error) : "Unknown error";
-            throw new Error(`Shell command failed: ${errorMsg}`);
+        if (error) {
+            throw new Error(`Shell command failed: ${JSON.stringify(error)}`);
         }
-        const stdout = response.data.data.stdout || "";
-        const stderr = response.data.data.stderr || "";
+        const stdout = data.data.stdout || "";
+        const stderr = data.data.stderr || "";
         if (stderr.trim()) {
             console.log(`[SandockSandboxClient] stderr: ${stderr}`);
         }
@@ -100,22 +108,40 @@ export class SandockSandboxClient {
             },
         });
         const output = await this.executeShellCommand(`cd /mcpspace && node ${tempFile}`);
-        // Asynchronously clean up temp file without blocking result return
-        this.client
-            .DELETE("/api/sandbox/{id}/fs", {
-            params: {
-                path: { id: this.sandboxId },
-                query: { path: tempFile },
-            },
-        })
-            .catch((error) => {
-            console.warn("[SandockSandboxClient] Warning: Could not delete temp file:", error);
+        // Fire-and-forget: cleanup temp file in background without blocking result return
+        // The cleanup will complete asynchronously, and logs will appear when it does
+        this.cleanupTempFileAsync(tempFile, this.sandboxId).catch((err) => {
+            // This should never happen due to internal error handling, but just in case
+            console.error("[SandockSandboxClient] Unexpected error in cleanupTempFileAsync:", err);
         });
         return {
             exitCode: 0,
             result: output,
         };
     }
+    async cleanupTempFileAsync(tempFile, sandboxId) {
+        if (!sandboxId) {
+            console.warn("[SandockSandboxClient] Sandbox ID is null, skipping temp file cleanup");
+            return;
+        }
+        try {
+            const { error } = await this.client.DELETE("/api/sandbox/{id}/fs", {
+                params: {
+                    path: { id: sandboxId },
+                    query: { path: tempFile },
+                },
+            });
+            if (error) {
+                console.warn(`[SandockSandboxClient] Warning: Could not delete temp file ${tempFile}:`, error);
+            }
+            else {
+                console.log(`[SandockSandboxClient] Temp file ${tempFile} deleted successfully`);
+            }
+        }
+        catch (cleanupError) {
+            console.warn(`[SandockSandboxClient] Error during temp file cleanup for ${tempFile}:`, cleanupError);
+        }
+    }
     async listTools(packageKey) {
         const mcpServerConfig = this.packageRepository.getPackageConfig(packageKey);
         const testCode = generateMCPTestCode(mcpServerConfig, "listTools");
@@ -146,33 +172,47 @@ export class SandockSandboxClient {
         if (!this.sandboxId) {
             return;
         }
-        const sandboxIdToStop = this.sandboxId;
+        const sandboxIdToDelete = this.sandboxId;
         this.sandboxId = null; // Clear immediately to avoid duplicate calls
-        // Asynchronously clean up sandbox without blocking result return
-        this.client
-            .POST("/api/sandbox/{id}/stop", {
-            params: {
-                path: {
-                    id: sandboxIdToStop,
+        // Fire-and-forget: destroy sandbox in background without blocking
+        // The cleanup will complete asynchronously, and logs will appear when it does
+        this.destroySandboxAsync(sandboxIdToDelete).catch((err) => {
+            // This should never happen due to internal error handling, but just in case
+            console.error("[SandockSandboxClient] Unexpected error in destroySandboxAsync:", err);
+        });
+    }
+    async destroySandboxAsync(sandboxId) {
+        try {
+            // Delete sandbox completely using the fs delete API with root path
+            // This removes all files and effectively shuts down the sandbox
+            const { error } = await this.client.DELETE("/api/sandbox/{id}/fs", {
+                params: {
+                    path: { id: sandboxId },
+                    query: { path: "/" },
                 },
-            },
-        })
-            .then((response) => {
-            if (!response.data && "error" in response) {
-                console.warn(`[SandockSandboxClient] Warning: Could not stop sandbox: ${JSON.stringify(response.error)}`);
+            });
+            if (error) {
+                // Check if error is "not found" (already deleted)
+                const errorStr = JSON.stringify(error);
+                if (errorStr.includes("not found") || errorStr.includes("404")) {
+                    console.log(`[SandockSandboxClient] Sandbox ${sandboxId} already deleted (not found on platform)`);
+                }
+                else {
+                    console.warn(`[SandockSandboxClient] Warning: Could not delete sandbox ${sandboxId}: ${errorStr}`);
+                }
             }
             else {
-                console.log("[SandockSandboxClient] Sandbox stopped successfully");
+                console.log(`[SandockSandboxClient] Sandbox ${sandboxId} deleted successfully`);
             }
-        })
-            .catch((err) => {
+        }
+        catch (err) {
             const errorMessage = err.message;
             if (errorMessage.includes("not found") || errorMessage.includes("404")) {
-                console.log("[SandockSandboxClient] Sandbox already stopped (not found on platform)");
+                console.log(`[SandockSandboxClient] Sandbox ${sandboxId} already deleted (not found on platform)`);
             }
             else {
-                console.warn("[SandockSandboxClient] Warning: Could not stop sandbox:", errorMessage);
+                console.warn(`[SandockSandboxClient] Warning: Could not delete sandbox ${sandboxId}: ${errorMessage}`);
             }
-        });
+        }
     }
 }

package/dist/domains/sandbox/sandbox-utils.js

@@ -17,10 +17,11 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 
 async function runMCP() {
   let client;
+  let transport;
   try {
     const packageName = "${mcpServerConfig.packageName}";
 
-    const transport = new StdioClientTransport({
+    transport = new StdioClientTransport({
       command: "pnpx",
       args: ["--silent", packageName],
       env: {
@@ -69,6 +70,13 @@ async function runMCP() {
         console.error("Error closing MCP client:", closeError);
       }
     }
+    if (transport) {
+      try {
+        await transport.close();
+      } catch (transportError) {
+        console.error("Error closing transport:", transportError);
+      }
+    }
   }
 }
 
@@ -100,6 +108,13 @@ runMCP();
         console.error("Error closing MCP client:", closeError);
       }
     }
+    if (transport) {
+      try {
+        await transport.close();
+      } catch (transportError) {
+        console.error("Error closing transport:", transportError);
+      }
+    }
   }
 }
 

package/dist/shared/utils/mcp-client-util.js

@@ -32,6 +32,13 @@ async function createMcpClient(mcpServerConfig, transport) {
         catch (e) {
             console.warn(`${packageName} mcp client close failure.`, e);
         }
+        // Close transport to release child process and file descriptors
+        try {
+            await transport.close();
+        }
+        catch (e) {
+            console.warn(`${packageName} mcp transport close failure.`, e);
+        }
     };
     return { client, transport, closeConnection };
 }

package/package.json

@@ -1,8 +1,38 @@
 {
   "name": "@toolsdk.ai/registry",
-  "version": "1.0.115",
+  "version": "1.0.117",
   "description": "An Open, Structured, and Standard Registry for MCP Servers and Packages.",
-  "keywords": [],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "mcp-registry",
+    "ai",
+    "llm",
+    "ai-agent",
+    "agent",
+    "ai-tools",
+    "claude",
+    "anthropic",
+    "chatbot",
+    "automation",
+    "registry",
+    "package-registry",
+    "self-hosted",
+    "private-registry",
+    "docker",
+    "typescript",
+    "nodejs",
+    "plugin",
+    "integration",
+    "sdk",
+    "openapi",
+    "rest-api",
+    "sandbox",
+    "remote-execution",
+    "search",
+    "developer-tools"
+  ],
   "license": "MIT",
   "author": "",
   "type": "module",