MCP Create Server
The MCP Create Server is a dynamic management service that allows you to create, run, and interact with MCP servers. Key capabilities include:
Server Creation: Dynamically create MCP servers from templates using TypeScript or Python
Server Management: List running servers, delete existing servers, and update/restart server code
Tool Execution: Execute specific tools on child servers and get lists of available tools
Process Monitoring: Ensures security with sandboxing and resource limits
Flexible Ecosystem: Supports TypeScript (with Python planned) and integrates with Claude Desktop
Provides containerized deployment of MCP servers through Docker, enabling isolated execution environments for dynamically created servers.
Leverages Node.js runtime for executing MCP servers, with specific requirements for Node.js 18 or higher to support the server functionality.
Offers template-based creation of Python MCP servers, enabling development and execution of Python-based Model Context Protocol implementations.
Supports creation of MCP servers using TypeScript, with templates and runtime execution capabilities for TypeScript-based server implementations.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@MCP Create Server create a new TypeScript MCP server from template"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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
Related MCP server: MCPMan
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-createManual 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 startIntegration 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: stringtoolName: stringargs: 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
License
MIT
Available Tools
5 toolscreate-server-from-templateC
Create a new MCP server from a template.
以下のテンプレートコードをベースに、ユーザーの要求に合わせたサーバーを実装してください。 言語に応じて適切なテンプレートを選択し、必要に応じて機能を追加・変更してください。
TypeScriptテンプレート:
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
CallToolRequestSchema,
ListToolsRequestSchema
} from "@modelcontextprotocol/sdk/types.js";
const server = new Server({
name: "dynamic-test-server",
version: "1.0.0"
}, {
capabilities: {
tools: {}
}
});
// ここでツールを実装してください
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [{
name: "echo",
description: "Echo back a message",
inputSchema: {
type: "object",
properties: {
message: { type: "string" }
},
required: ["message"]
}
}]
};
});
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name === "echo") {
// TypeScriptの型を適切に扱うため、型アサーションを使用
const message = request.params.arguments.message as string;
// または any を使う: const message: any = request.params.arguments.message;
return {
content: [
{
type: "text",
text: `Echo: ${message}`
}
]
};
}
throw new Error("Tool not found");
});
// Server startup
const transport = new StdioServerTransport();
server.connect(transport);Pythonテンプレート:
import asyncio
from mcp.server import Server
from mcp.server.stdio import stdio_server
app = Server("dynamic-test-server")
@app.list_tools()
async def list_tools():
return [
{
"name": "echo",
"description": "Echo back a message",
"inputSchema": {
"type": "object",
"properties": {
"message": {"type": "string"}
},
"required": ["message"]
}
}
]
@app.call_tool()
async def call_tool(name, arguments):
if name == "echo":
return [{"type": "text", "text": f"Echo: {arguments.get('message')}"}]
raise ValueError(f"Tool not found: {name}")
async def main():
async with stdio_server() as streams:
await app.run(
streams[0],
streams[1],
app.create_initialization_options()
)
if __name__ == "__main__":
asyncio.run(main())注意事項:
TypeScript実装時は、引数の型を適切に扱うために型アサーション(as string)を使用するか、 明示的に型を宣言してください(例:const value: string = request.params.arguments.someValue)。
複雑な型を扱う場合は、interface や type を定義して型安全性を確保することをお勧めします。
ユーザーの要求に応じて上記のテンプレートを参考にカスタマイズしてください。その際、基本的な構造を維持しつつ、ツール名や機能を変更できます。
Inputs: language (required), code, dependencies.
delete-serverC
Delete a server
Inputs: serverId (required).
execute-toolC
Execute a tool on a server
Inputs: serverId (required), toolName (required), args.
get-server-toolsC
Get the tools available on a server
Inputs: serverId (required).
list-serversB
List all running servers
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Most tools have distinct purposes: create, delete, list, get tools, and execute. However, 'execute-tool' could potentially overlap with server-specific tools, but its description clarifies it's for executing tools on servers, making it reasonably distinct. The set covers different aspects of server management without significant ambiguity.
All tools follow a consistent verb-noun pattern with hyphens: create-server-from-template, delete-server, execute-tool, get-server-tools, list-servers. The naming is predictable and uniform throughout the set, making it easy for agents to understand the action and target.
With 5 tools, the count is appropriate for a server management domain, covering core operations like creation, deletion, listing, and tool interaction. It's slightly lean but reasonable; adding a tool for server status or configuration might enhance completeness, but the current scope is well-defined.
The tool set covers basic server lifecycle (create, delete, list) and tool interaction (get tools, execute), but has notable gaps. Missing operations include updating server configurations, stopping/starting servers, or monitoring server status, which are common in server management. Agents might encounter dead ends when needing to modify existing servers beyond deletion.
Maintenance
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
Marketplace and infrastructure for MCP servers and skills: deploy, host, monetize, analytics.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
- AlicenseAqualityDmaintenanceA lightweight framework for building and running Model Context Protocol (MCP) servers using FastMCP, providing tools for development, debugging, and server management.4MIT
- AlicenseNot gradedqualityDmaintenanceA Model Context Protocol server manager that acts as a proxy/multiplexer, enabling connections to multiple MCP servers simultaneously and providing JavaScript code execution with access to all connected MCP tools. Supports both stdio and HTTP transports with OAuth authentication, batch tool invocation, and dynamic server management.21 npmMIT
- AlicenseBqualityDmaintenanceDynamic MCP server for Node.js enabling runtime tool creation, management, and execution in isolated sandboxes (Docker or Node).819 npm1MIT
- AlicenseNot gradedqualityDmaintenanceAn enhanced dynamic MCP server management service that creates, runs, and manages Model Context Protocol servers with multi-language support and strict parameter validation.MIT