MCP Platform¶

Production-ready Model Context Protocol (MCP) server deployment and management platform.

MCP Platform is a comprehensive, enterprise-grade solution for deploying, managing, and scaling MCP servers with ease. Designed for developers and teams who want to focus on AI integration—not infrastructure headaches. Get started in minutes with Docker-powered deployments, a powerful CLI, and flexible configuration options.

Ready to dive in? Start with our Getting Started Guide.

Production-ready Model Context Protocol (MCP) server templates with zero-configuration deployment

Deploy, manage, and scale MCP servers instantly with Docker containers, comprehensive CLI tools, and flexible configuration options.

💬 Community¶

Join our Discord Community for support, discussions, and updates!

⚡ Getting Started

Install MCP Platform and deploy your first server in under 2 minutes
💻 CLI Reference

Complete command reference for the mcpp CLI tool
🌐 Gateway

Unified load balancer and proxy for accessing all MCP server instances
📦 Server Templates

Browse available templates with advanced configuration properties and deployment options
📖 Template.json Reference

Complete guide to template configuration including volume_mount, command_arg, and transport options
🛠️ Creating Templates

Step-by-step guide to creating custom MCP templates with best practices
📖 User Guide

In-depth guides for configuration, deployment, and management

⚡ What is MCP Platform?¶

MCP Platform is a self-hosted deployment system that enables rapid deployment, management, and scaling of Model Context Protocol servers on your own infrastructure.

Key Benefits¶

Traditional MCP Setup	With MCP Platform
❌ Complex server configuration	✅ One-command deployment
❌ Docker knowledge required	✅ Zero configuration needed
❌ Manual tool discovery	✅ Automatic tool detection
❌ Environment setup headaches	✅ Pre-built, tested containers
❌ No deployment management	✅ Full lifecycle management

Core Features¶

🔧 Zero Configuration: Deploy MCP servers with sensible defaults
🐳 Docker-Based: Containerized deployments for consistency and security
🛠️ Tool Discovery: Automatic detection of available tools and capabilities
📱 Interactive CLI: Streamlined command-line interface for all operations
🔄 Lifecycle Management: Deploy, configure, monitor, and cleanup with ease
🎯 Multiple Templates: Pre-built servers for GitHub, Zendesk, GitLab, and more
🌐 Gateway System: Unified load balancer and proxy for accessing all MCP instances

🌐 MCP Gateway¶

The MCP Gateway is a production-ready load balancer and proxy system that provides unified access to all your MCP server instances. Instead of connecting to each server individually, use the gateway for:

Single Endpoint: Access all templates through one URL
Load Balancing: Automatic request distribution across healthy instances
Health Monitoring: Continuous monitoring with automatic failover
High Availability: No single point of failure
Transport Agnostic: Works with both HTTP and stdio servers

# Start gateway with auto-discovery
mcpp gateway start --sync

# Access any template through unified endpoint
curl http://localhost:8080/mcp/filesystem/tools/list
curl http://localhost:8080/mcp/github/tools/call -d '{"name": "list_repos"}'

→ Learn more about the Gateway

📋 Available Templates¶

Template	Description	Status
demo	Simple demonstration server	✅ Available
github	GitHub repository management	✅ Available
gitlab	GitLab integration server	✅ Available
zendesk	Customer support integration	🚧 In Progress
filesystem	Secure file operations server	✅ Available
postgres	PostgreSQL database integration	🚧 In Progress
slack	Slack bot integration	🚧 In Progress

and many more in flight ✈

� What’s Inside¶

Welcome to the MCP Platform—where server deployment meets pure excitement! Here’s what makes this project a must-have for every AI builder:

⚡ Features (Mid-August 2025 Release)¶

🚀 Current Features¶

🖱️ One-Click Docker Deployment: Launch MCP servers instantly with pre-built templates—no hassle, just pure speed.
🔎 Smart Tool Discovery: Automatically finds and showcases every tool your server can offer. No more guesswork!
💻 Slick CLI Management: Command-line magic for easy, powerful control over all deployments.
🤝 Bring Your Own MCP Server: Plug in your own MCP server and run it on our network—even with limited features!
🐳 Effortless Docker Image Integration: Add any existing MCP Docker image to the templates library with minimal setup and unlock all the platform’s cool benefits.
⚡ Boilerplate Template Generator: Instantly create new MCP server projects with a CLI-powered generator—kickstart your next big idea!
🛠️ Multiple Ways to Set Configuration: Flex your setup with config via JSON, YAML, environment variables, CLI config, or CLI override options—total flexibility for every workflow!

🌈 Planned Features¶

🦸 MCP Sidekick (Coming Soon): Your friendly AI companion, making every MCP server compatible with any AI tool or framework.

Ready to dive in? Check out our Getting Started Guide!

�🌟 MCP Platform - Managed Cloud Solution¶

Looking for enterprise deployment without infrastructure management? MCP Platform offers:

✨ One-click deployment - Deploy any MCP server template instantly
🛡️ Enterprise security - SOC2, GDPR compliance with advanced security controls
📊 Real-time monitoring - Performance metrics, usage analytics, and health dashboards
🔧 Custom development - We build proprietary MCP servers for your specific needs
💼 Commercial support - 24/7 enterprise support with SLA guarantees
🎯 Auto-scaling - Dynamic resource allocation based on demand
🔐 Team management - Multi-user access controls and audit logging

Ready for production? Get started with MCP Platform →

Open Source Self-Hosted Deployment¶

This repository provides comprehensive tools for self-managing MCP server deployments on your own infrastructure.

🚀 Key Features¶

🎯 Zero Configuration Deployment - Deploy templates with a single command
🔍 Advanced Tool Discovery - Automatic detection of MCP server capabilities using official MCP protocol
📦 Pre-built Templates - Production-ready templates for file operations, databases, APIs, and more
🔧 Flexible Configuration - Multi-source configuration with environment variables, CLI options, and files
🐳 Docker-First Architecture - Container-based deployments with proper lifecycle management
📋 Rich CLI Interface - Beautiful command-line interface with comprehensive help and examples
🧪 Template Development Tools - Complete toolkit for creating and testing custom templates
📊 Monitoring & Management - Real-time status monitoring, log streaming, and health checks
🔗 Integration Examples - Ready-to-use code for Claude Desktop, VS Code, Python, and more

🎯 Quick Start¶

Installation¶

# Install from PyPI (recommended)
pip install mcp-platform

# Verify installation
mcpp --version

Deploy Your First Template¶

# List available templates
mcpp list

# Deploy demo server
mcpp deploy demo

# Discover available tools
mcpp> tools demo

# Get integration examples
mcpp connect demo --llm claude

Integration with Claude Desktop¶

# Get container name
mcpp list

# Update Claude Desktop config
mcpp connect demo --llm claude

Claude Desktop Configuration:

{
  "mcpServers": {
    "demo": {
      "command": "docker",
      "args": ["exec", "-i", "CONTAINER_NAME", "python", "-m", "src.server"]
    }
  }
}

📚 Documentation¶

🚀 Getting Started¶

Installation Guide - Setup and initial configuration
Quick Start Tutorial - Deploy your first MCP server
Configuration - Understanding templates, deployments, and tools

📖 User Guide¶

CLI Reference - Complete command reference
Monitoring - Monitor your deployments
Stdio Tool Execution - Interactive tool execution for stdio MCP servers
Monitoring & Management - Production deployment management

🛠️ CLI Reference¶

Command Overview - Complete CLI documentation
deploy - Deploy HTTP transport templates with configuration options
run-tool - Execute tools from stdio MCP servers
~~tools~~ - DEPRECATED: Use interactive CLI instead
~~discover-tools~~ - DEPRECATED: Use interactive CLI instead
connect - Generate integration examples for LLMs
config - View template configuration options
list - List templates and deployments
logs - Monitor deployment logs
interactive - Interactive CLI for deployment management

🔧 Development¶

Creating Templates - Build custom MCP server templates
Template Development - Advanced template development
Tool Discovery System - Understanding tool discovery architecture
Testing & Validation - Test templates and deployments
Contributing - Contribute to the project

🏗️ System Architecture¶

Architecture Overview - System design and components
Development Setup - Setting up development environment
API Reference - Complete API documentation

🎯 Use Cases¶

File Operations¶

# Deploy secure file server
mcpp deploy filesystem \
  --config security__allowed_dirs='["/data", "/workspace"]' \
  --config security__read_only=false

# Connect to Claude Desktop for file operations
mcpp connect filesystem --llm claude

Database Integration¶

# Deploy PostgreSQL MCP server
mcpp deploy postgres-server \
  --config database__host=localhost \
  --config database__name=mydb \
  --env POSTGRES_PASSWORD=secret

# Generate Python integration code
mcpp connect postgres-server --llm python

API Integration¶

# Deploy REST API integration server
mcpp deploy api-server \
  --config api__base_url=https://api.example.com \
  --config api__auth_token=$API_TOKEN

# Test with cURL
mcpp connect api-server --llm curl

🔍 Tool Discovery¶

Automatic MCP Protocol Discovery:

# Discover tools from any MCP-compliant Docker image
mcpp> tools--image mcp/filesystem /tmp

# Rich formatted output shows all capabilities:
✅ Discovered 11 tools via docker_mcp_stdio
- read_file: Read complete file contents
- write_file: Create or overwrite files
- list_directory: List directory contents
- create_directory: Create directories
- ... and 7 more tools

Integration Ready:

# Get ready-to-use integration code
mcpp i
mcpp> tools demo --format json
exit
mcpp> connect demo --llm vscode

📊 Available Templates¶

Template	Description	Use Cases
demo	Basic greeting and echo server	Learning, testing, examples
filesystem	Secure filesystem operations	Document processing, file management
postgres-server	PostgreSQL database integration	Data analysis, query execution
api-server	REST API client with auth	External service integration
mongodb-server	MongoDB document operations	NoSQL data operations
redis-server	Redis cache and pub/sub	Caching, real-time messaging

🛠️ System Requirements¶

Operating System: Linux, macOS, Windows (with WSL2)
Docker: Version 20.10+ (required for container deployments)
Python: Version 3.9+ (for CLI and development)
Memory: 512MB minimum, 2GB recommended
Storage: 1GB minimum for templates and container images

🚦 Production Deployment¶

Security Considerations¶

# Deploy with security hardening
mcpp deploy filesystem \
  --config security__read_only=true \
  --config security__max_file_size=10 \
  --config logging__enable_audit=true \
  --env MCP_ALLOWED_DIRS='["/secure/data"]'

Monitoring Setup¶

# Health check monitoring
mcpp list --format json | jq '.summary'

# Log monitoring
mcpp logs filesystem --follow --since 1h

Backup and Recovery¶

# Export deployment configuration
mcpp status filesystem --format json > backup.json

# Cleanup and redeploy
mcpp cleanup filesystem
mcpp deploy filesystem --config-file backup.json

🤝 Community & Support¶

📖 Documentation: Comprehensive guides and API reference
🐛 Issue Tracker: GitHub Issues
💬 Discussions: GitHub Discussions
� Community Slack: Join mcp-platform workspace
�📧 Enterprise Support: Contact us for commercial support

🗺️ Roadmap¶

Kubernetes Backend: Native Kubernetes deployment support
Template Marketplace: Community-driven template sharing
GraphQL Integration: GraphQL API server templates
Metrics & Alerting: Prometheus/Grafana integration
Multi-tenant Support: Isolated deployments for teams
Auto-scaling: Dynamic resource allocation

📄 License¶

This project is licensed under the MIT License - see the LICENSE file for details.

Get started today: Choose between our managed cloud platform for instant deployment or self-hosted deployment for full control.

Install dependencies¶

pip install -e .

#### Basic Usage

```bash
# List available templates
mcpp list

# Deploy a template
mcpp deploy filesystem

# View logs
mcpp logs filesystem

Show Configuration Options¶

# View configuration options for any template
mcpp deploy filesystem --show-config

# Deploy with custom configuration
mcpp deploy filesystem --config read_only_mode=true

# Deploy with config file
mcpp deploy filesystem --config-file config.json

Available Templates¶

Our templates are automatically discovered and validated using the TemplateDiscovery utility to ensure only working implementations are listed. This keeps the documentation up-to-date as new templates are added.

Use mcpp list to see all currently available templates, or visit the Templates section for detailed documentation.

Popular Templates: - filesystem - Secure filesystem access for AI assistants - demo - Demonstration server with greeting tools - github - GitHub API integration for repository access - database - Database connectivity for SQL operations

Architecture¶

The system uses a simple architecture designed for self-hosted deployments:

┌─────────────┐    ┌──────────────────┐    ┌─────────────────────┐
│   CLI Tool  │────│ Template         │────│ Docker Backend      │
│             │    │ Discovery        │    │                     │
│ • Commands  │    │ • Load metadata  │    │ • Container deploy  │
│ • Config    │    │ • Schema validation │  │ • Volume management │
│ • Display   │    │ • Config mapping  │    │ • Health monitoring │
└─────────────┘    └──────────────────┘    └─────────────────────┘

Key Components: - CLI Interface - Rich command-line interface (mcpp) - Template Discovery - Automatic detection and validation of templates - Docker Backend - Container-based deployment with volume management - Configuration System - Multi-source configuration with type conversion

Configuration System¶

Templates support flexible configuration from multiple sources:

Configuration precedence (highest to lowest): 1. Environment variables (--env KEY=VALUE) 2. CLI configuration (--config KEY=VALUE) 3. Configuration files (--config-file config.json) 4. Template defaults

Example configuration:

# Using CLI options
mcpp deploy filesystem \
  --config read_only_mode=true \
  --config max_file_size=50 \
  --config log_level=debug

# Using environment variables
mcpp deploy filesystem \
  --env MCP_READ_ONLY=true \
  --env MCP_MAX_FILE_SIZE=50

# Using config file
mcpp deploy filesystem --config-file production.json

Template Development¶

Create custom MCP server templates:

# Interactive template creation
mcpp create my-custom-server

# Follow prompts to configure:
# - Template metadata
# - Configuration schema
# - Docker setup
# - Documentation

Each template includes: - template.json - Metadata and configuration schema - Dockerfile - Container build instructions - README.md - Template documentation - docs/index.md - Documentation site content - src/ - Implementation code

Documentation¶

Templates - Available templates and their configuration
Getting Started - Installation and first deployment
Guides - Advanced usage and template development
Development - Technical architecture and development

Community¶

GitHub Issues - Bug reports and feature requests
Discussions - Community questions and sharing
Contributing - See our contribution guidelines

Commercial Services¶

Need help with custom MCP servers or enterprise deployment?

MCP Platform offers: - Custom MCP server development - Enterprise hosting and support - Professional services and consulting

📧 Contact us: tooling@dataeverything.ai

License¶