What does MCP Create MCP Server do?

It allows you to create and manage multiple MCP servers dynamically from a single parent server, with the ability to execute tools on them and manage their lifecycle.

How do I install MCP Create MCP Server?

You can install it via Docker using `docker build -t mcp-create .` and `docker run -it --rm mcp-create`, or configure it in Claude Desktop by adding the server configuration to your mcpServers settings.

MCP Connector

Manage Dynamic MCP Servers

Name: MCP Create MCP Server
Availability: OnlineOnly
Author: tesla0225

MCP server that dynamically creates, runs, and manages other Model Context Protocol servers as child processes, with TypeScript support and tool execution.

Connect

Works with docker github

tesla0225

Own this? Claim it

Maintainer of this project? Claim this page to edit the listing.

Spark score

out of 100

Updated May 2025

Fresher alternatives ↓

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

Create MCP servers from templates

Execute tools on running MCP servers

List and delete MCP servers

Update and restart server code

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/vb-mcp-create | bash

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

Ensured installation and integration examples are presented clearly. Use this when you need to dynamically create and manage multiple MCP servers from a single parent server, execute tools on child servers, or update and restart server code without manual redeployment.

What it does

Big Job: Create and manage multiple MCP servers dynamically from a single parent server.

Small Job: Dynamically create TypeScript MCP servers from templates, execute tools on them, and manage their lifecycle-all through a single parent MCP server.

Install via Docker (recommended):

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

Or configure in Claude Desktop:

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

Create a server and execute tools:

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

Provides five tools: create-server-from-template, execute-tool, get-server-tools, delete-server, and list-servers. Supports TypeScript only.

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.

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