MCP Create: On-Demand MCP Server Orchestration

Overview

MCP Create is a lightweight orchestration layer for the Model Context Protocol (MCP). It provisions, runs, and manages short-lived MCP server instances on demand so you can expose isolated model contexts for testing, per-request compute, or multi-tenant deployments. Instead of running a single, static MCP server, MCP Create dynamically spawns instances that are automatically configured and garbage-collected when they expire.

This approach is useful when you need fine-grained isolation between model contexts, want to horizontally scale model endpoints without manual intervention, or need ephemeral environments for CI, experimentation, or per-user sessions. MCP Create integrates with container runtimes (Docker / containerd) and can be deployed locally, on VMs, or orchestrated in cluster environments.

Features

• On-demand instance provisioning for MCP servers
• Automatic lifecycle management (TTL and garbage collection)
• Simple REST API and/or CLI for creating, listing, and removing instances
• Environment-driven configuration with sensible defaults
• Support for container-based runtimes and integration points for cloud scaling
• Health checks and basic observability hooks

Installation / Configuration

Prerequisites:

• Docker (or another container runtime)
• Git
• Optional: kubectl / Helm or cloud CLI for production deployments

Clone the repository and run a local instance:

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

Run with Docker Compose (example):

# start services
docker compose up -d

# view logs
docker compose logs -f mcp-create

Example .env configuration (create a file named .env in the project root):

# .env
PORT=8080
INSTANCE_IMAGE=ghcr.io/your-org/mcp-server:latest
INSTANCE_TTL_SECONDS=3600
MAX_INSTANCES=50

Common environment variables

Basic Docker run (single-process demo):

docker run --env-file .env -p 8080:8080 ghcr.io/tesla0225/mcp-create:latest

For production, deploy MCP Create behind a reverse proxy or load balancer, and connect it to your container runtime or orchestration platform.

Available Tools

MCP Create typically exposes the following components:

• CLI tool: lightweight commands to create, list, and delete instances from your terminal.
• REST API: endpoints to programmatically request new MCP server instances, check status, and terminate instances.
• Health & metrics endpoints: basic /health and /metrics endpoints for integration with monitoring systems.
• Webhook hooks: optional callbacks for instance creation/termination events.

Example API endpoints (illustrative):

• POST /instances — create a new instance
• GET /instances — list active instances
• GET /instances/{id} — fetch instance details
• DELETE /instances/{id} — terminate an instance
• GET /health — health check

Example request to create an instance:

curl -X POST http://localhost:8080/instances \
  -H "Content-Type: application/json" \
  -d '{
    "model": "my-model:latest",
    "cpus": 0.5,
    "memory": "512m",
    "ttl": 1800
  }'

Example JSON response:

{
  "id": "inst_012345",
  "url": "http://10.0.0.12:5003",
  "expires_at": "2026-04-09T12:45:00Z"
}

Use Cases

• Per-request isolation for multi-tenant LLM hosting

  • Create a short-lived MCP server for each tenant request with their private context, then automatically tear it down when the session ends.

• Ephemeral dev and test environments

  • Spawn throwaway MCP servers that mirror production settings for integration tests or live debugging without affecting shared resources.

• Load-based scaling and burst handling

  • During traffic spikes, create additional MCP instances with predefined images and TTLs to absorb load, then let them expire to reduce cost.

• Reproducible experiments

  • Launch instances pinned to a specific model version for a reproducible evaluation run. Track instance metadata (commit, model tag) and let the orchestration handle cleanup.

Concrete example: CI pipeline creates an MCP instance, runs a suite of inference tests against it, collects logs and metrics, then issues a DELETE request to free the instance once tests complete.

Notes and Next Steps

• Security: Run MCP Create behind an authenticated proxy or enable API authentication to prevent abuse. Limit image sources and enforce image signing for production.
• Scaling: For large-scale deployments, integrate with a cluster scheduler (Kubernetes) or autoscaling group and use the orchestration platform’s native scheduling primitives.
• Observability: Expose metrics (Prometheus) and structured logs for each instance to enable debugging and billing.

Repository and issues: https://github.com/tesla0225/mcp-create

This tool is intended as a building block. Extend the basic orchestration with custom policies, model image registries, and tenant isolation to match your operational requirements.