MCP Server Installer for One-Click Deployments

Overview

The MCP Server Installer provides a one-click way to deploy Model Context Protocol (MCP) server instances. It automates the common steps needed to provision, configure, and run an MCP-compliant server locally, on a single VM, or inside a Kubernetes cluster. The installer reduces manual setup so teams can focus on model integration and scaling instead of low-level orchestration.

This tool is useful when you want repeatable MCP deployments across environments (developer laptop, CI, staging, production), or want a simple entry point for CI/CD pipelines to create ephemeral MCP instances. It supports Docker Compose and Helm/Kubernetes workflows, exposes health and metrics endpoints, and includes sensible defaults for production-oriented settings such as logging, TLS, and autoscaling hooks.

Features

• One-command installer script for VM or local Docker deployments
• Helm chart for Kubernetes / cloud-native installations
• Preconfigured Docker Compose for quick local testing
• Environment-based configuration with a YAML config file and env vars
• Automated provisioning of TLS, TLS termination optional
• Health checks, metrics (Prometheus), and logs collection endpoints
• Autoscaling integration hooks (HPA/Cluster Autoscaler friendly)
• Templates for CI/CD ephemeral environments and rollback support
• Lightweight web UI for basic instance management and logs

Installation / Configuration

Clone the installer repository and run the installer for your target environment.

Quick start (Docker Compose, local):

git clone https://github.com/anaisbetts/mcp-installer.git
cd mcp-installer

# Start a local MCP server using Docker Compose
docker compose up -d

Start with the included shell installer (VM / single host):

# Run the automated installer (will ask for sudo for systemd/docker setup)
./install.sh --target host

Kubernetes / Helm install:

# Add the chart (if using a packaged chart) or use the local chart
helm repo add mcp https://example.com/charts
helm repo update

# Install to namespace `mcp`
helm install mcp-server mcp/mcp-server \
  --namespace mcp --create-namespace \
  --set replicaCount=3 \
  --set ingress.enabled=true

Basic configuration file (mcp-config.yaml):

server:
  host: 0.0.0.0
  port: 8080
logging:
  level: info
tls:
  enabled: false
metrics:
  prometheus: true
models:
  - name: example-model
    endpoint: http://localhost:9000
autoscaling:
  enabled: true
  targetCPUUtilizationPercentage: 70

Environment variables (examples):

export MCP_CONFIG=/etc/mcp/mcp-config.yaml
export MCP_LOG_LEVEL=debug
export MCP_TLS_CERT=/etc/mcp/tls/cert.pem
export MCP_TLS_KEY=/etc/mcp/tls/key.pem

Configuration tips:

• Use the YAML config for environment-agnostic settings and override sensitive values via env vars or secrets.
• When deploying to Kubernetes, mount secrets for TLS and model credentials rather than embedding them in the YAML.

Available Tools or Resources

• CLI: ./mcpctl — control lifecycle (start, stop, status, logs)
• Docker Compose templates: docker-compose.yml for single-node testing
• Helm chart: templates for Deployments, Services, Ingress, HPA
• Health endpoints:
  • /healthz — basic liveness
  • /readyz — readiness checks including model endpoints
  • /metrics — Prometheus-formatted metrics
• Logging: structured JSON logs, stdout by default; option to forward to Elasticsearch/Logstash
• Example model adapters: simple adapters for common runtimes (TorchServe, Triton)
• CI/CD samples: GitHub Actions workflow for ephemeral MCP instances during test runs

Use Cases

1. Developer local testing

   • Run a local Docker Compose instance to validate integration with a model adapter and iterate quickly.
   • Example: docker compose up -d + point your SDK at http://localhost:8080 to test request/response and model context propagation.

2. Ephemeral CI environments

   • Spin up a temporary MCP instance inside CI to run integration tests against a deterministic environment, then tear it down.
   • Example: Use mcpctl in a GitHub Actions job to install, run tests, and uninstall at the end.

3. Staging/Production deployments on Kubernetes

   • Use the Helm chart to deploy a multi-replica MCP service with HPA for autoscaling, Prometheus scraping, and ingress TLS.
   • Example: helm install mcp-server mcp/mcp-server --set replicaCount=3 --set autoscaling.enabled=true.

4. Multi-tenant model hosting

   • Instantiate multiple MCP instances or namespaces for tenant isolation, each with its own configuration and monitoring.
   • Use centralized dashboards to route traffic and manage quotas per instance.

5. Scaling model-backed APIs

   • Hook the installer’s autoscaling settings into cluster autoscaler logic to scale worker nodes when model inference load increases.
   • Metrics emitted by /metrics include request rates and model latency to inform scaling decisions.

Configuration Reference

If you need more advanced examples (custom adapters, cloud-init scripts, or Helm values), refer to the repository: https://github.com/anaisbetts/mcp-installer.