MCP Connector

Manage Dynamic MCP Servers

MCP Create dynamically creates, runs, and manages child MCP servers from TypeScript templates as an MCP-of-MCPs.

Works with dockergithub

91
Spark score
out of 100
Updated May 2025
Source checked Sep 15, 2026
Version 1.0.0
Models
universal

Add to Favorites

Why it matters

Dynamically create, run, and manage Model Context Protocol (MCP) servers as child processes. This service provides a flexible ecosystem for MCP development and deployment.

Outcomes

What it gets done

01

Create MCP servers from templates

02

Execute tools on running MCP servers

03

List and delete MCP servers

04

Update and restart server code

Source

Get it from source

Spark does not host a copy of it.

Open source

Reports

Agent outcome reports

No reports yet

Capabilities

Tools your agent gets

create-server-from-template

Create an MCP server from a template

execute-tool

Execute a tool on the server

get-server-tools

Get a list of server tools

delete-server

Delete a server

list-servers

Get a list of running servers

Overview

MCP Create MCP Server

MCP Create is an MCP server that dynamically creates, runs, and manages other MCP servers as child processes from TypeScript templates. Use it when you need to spin up, test, and tear down MCP servers dynamically, with the caution due to any code-execution service.

What it does

MCP Create is a dynamic MCP server management service: it is itself an MCP server, but its job is to create, run, and manage other MCP servers as child processes, enabling a flexible ecosystem where new MCP servers can be spun up, updated, restarted, and torn down on demand rather than deployed as fixed, pre-built services.

When to use - and when NOT to

Use it when you want an AI assistant or automation to dynamically create a new MCP server from a template, execute a tool on one of the child servers it's managing, list what's currently running, or delete a server it no longer needs. It currently supports TypeScript only, with JavaScript and Python support planned for future releases, so it is not yet usable for creating servers in those languages. Because it executes arbitrary generated code to run child servers, the project's own security notes call for sandboxing, resource limits, process monitoring for runaway or zombie processes, and careful path validation to prevent directory traversal - treat it with the caution due to any code-execution service, not as a fully hardened production sandbox out of the box.

Capabilities

create-server-from-template creates a new MCP server from a template for a given language, currently typescript, returning a serverId and a status message. execute-tool runs a named tool on a specific child server by serverId, passing arguments and returning that tool's execution result. get-server-tools lists the tools available on a given server. delete-server removes a server by its serverId. list-servers returns the IDs of all currently running child servers, with no input required. A typical execute-tool call passes a serverId alongside a toolName and an args object, for example calling an echo tool with a message payload on a specific running server.

How to install

Docker is the recommended path:

docker build -t mcp-create .
docker run -it --rm mcp-create

For manual TypeScript installation:

git clone https://github.com/tesla0225/mcp-create.git
cd mcp-create
npm install
npm run build
npm start

For Claude Desktop, add it to claude_desktop_config.json running via Docker. It requires Node.js 18+, TypeScript, and depends on @modelcontextprotocol/sdk, Node's built-in child_process and fs/promises modules, and uuid for generating server IDs.

Who it's for

Developers building or experimenting with MCP tooling who need to spin up, test, and tear down MCP servers dynamically - for example generating and validating a server from a template, or orchestrating several child servers programmatically - rather than deploying each one as a separate, statically configured service. It is released under the MIT License.

Source README

MCP Create Server

A dynamic MCP server management service that creates, runs, and manages Model Context Protocol (MCP) servers dynamically. This service itself functions as an MCP server and launches/manages other MCP servers as child processes, enabling a flexible MCP ecosystem.

Create Server MCP server

Key Features

  • Dynamic creation and execution of MCP server code
  • Support for TypeScript only (JavaScript and Python support planned for future releases)
  • Tool execution on child MCP servers
  • Server code updates and restarts
  • Removal of unnecessary servers

Installation

Note: Docker is the recommended way to run this service

Docker Installation (Recommended)

# Build Docker image
docker build -t mcp-create .

# Run Docker container
docker run -it --rm mcp-create

Manual Installation (TypeScript Only)

# Clone repository
git clone https://github.com/tesla0225/mcp-create.git
cd mcp-create

# Install dependencies
npm install

# Build
npm run build

# Run
npm start

Integration with Claude Desktop

Add the following to your Claude Desktop configuration file (claude_desktop_config.json):

{
  "mcpServers": {
    "mcp-create": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "mcp-create"]
    }
  }
}

Available Tools

Tool Name Description Input Parameters Output
create-server-from-template Create MCP server from template language: string { serverId: string, message: string }
execute-tool Execute tool on server serverId: string
toolName: string
args: object
Tool execution result
get-server-tools Get list of server tools serverId: string { tools: ToolDefinition[] }
delete-server Delete server serverId: string { success: boolean, message: string }
list-servers Get list of running servers none { servers: string[] }

Usage Examples

Creating a New Server

{
  "name": "create-server-from-template",
  "arguments": {
    "language": "typescript"
  }
}

Executing a Tool

{
  "name": "execute-tool",
  "arguments": {
    "serverId": "ba7c9a4f-6ba8-4cad-8ec8-a41a08c19fac",
    "toolName": "echo",
    "args": {
      "message": "Hello, dynamic MCP server!"
    }
  }
}

Technical Specifications

  • Node.js 18 or higher
  • TypeScript (required)
  • Dependencies:
    • @modelcontextprotocol/sdk: MCP client/server implementation
    • child_process (Node.js built-in): Child process management
    • fs/promises (Node.js built-in): File operations
    • uuid: Unique server ID generation

Security Considerations

  • Code Execution Restrictions: Consider sandboxing as the service executes arbitrary code
  • Resource Limitations: Set limits on memory, CPU usage, number of files, etc.
  • Process Monitoring: Monitor and forcibly terminate zombie or runaway processes
  • Path Validation: Properly validate file paths to prevent directory traversal attacks

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.