MCP-Maker Enterprise Platform

A comprehensive, enterprise-grade platform for creating, managing, and deploying Model Context Protocol (MCP) servers at scale.

🚀 Quick Start

Prerequisites

• Docker Desktop (latest version)
• Docker Compose (latest version)
• Git (for version control)
• VS Code or IntelliJ Community (recommended IDEs)

Installation

1. Clone the repository:

   git clone <repository-url>
   cd mcp-creator

2. Run the setup script:

   ./scripts/setup.sh

3. Access the platform:

   • Frontend: http://localhost:4200
   • Backend API: http://localhost:8080
   • Monitoring: http://localhost:3000 (Grafana)

🏗️ Architecture

Services Overview

Service	Port	Description
Frontend	4200	Angular application
Backend	8080	Spring Boot API
Nginx	80	Reverse proxy
PostgreSQL	5432	Primary database
Redis	6379	Caching layer
Kafka	9092	Message queue
Prometheus	9090	Metrics collection
Grafana	3000	Monitoring dashboard
Kibana	5601	Log analysis
Jaeger	16686	Distributed tracing

Technology Stack

• Frontend: Angular 19, TypeScript 5.x, SCSS, Angular Material
• Backend: Spring Boot 3.x, Java 21 LTS, Spring AI, Spring Security, Spring Cloud
• Database: PostgreSQL 15 with extensions, Liquibase migrations
• Cache: Redis 7
• Message Queue: Apache Kafka
• Monitoring: Prometheus, Grafana, ELK Stack, Jaeger
• Containerization: Docker, Docker Compose
• Reverse Proxy: Nginx

🛠️ Development

Development Commands

# Start all services
./scripts/dev.sh start

# View logs
./scripts/dev.sh logs [service]

# Open shell in service
./scripts/dev.sh shell [service]

# Check service health
./scripts/dev.sh health

# Connect to database
./scripts/dev.sh db

# Connect to Redis
./scripts/dev.sh redis

# List Kafka topics
./scripts/dev.sh kafka

# Stop all services
./scripts/dev.sh stop

# Clean up everything
./scripts/dev.sh clean

Service Management

# Start specific service
docker-compose up -d [service]

# Restart service
docker-compose restart [service]

# View service logs
docker-compose logs -f [service]

# Scale service
docker-compose up -d --scale [service]=3

📊 Monitoring & Observability

Grafana Dashboards

Access Grafana at http://localhost:3000 (admin/admin) to view:

• System Overview: CPU, memory, disk usage
• Application Metrics: Request rates, response times, error rates
• Database Performance: Query performance, connection pools
• Kafka Metrics: Message throughput, consumer lag
• Custom MCP Metrics: Server deployments, template usage

Prometheus Metrics

Access Prometheus at http://localhost:9090 to query metrics:

• Spring Boot Actuator: Application health and metrics
• JVM Metrics: Memory usage, garbage collection
• Custom Metrics: Business-specific metrics
• Infrastructure Metrics: Container and system metrics

Log Analysis

Access Kibana at http://localhost:5601 to analyze logs:

• Application Logs: Spring Boot application logs
• Access Logs: Nginx access and error logs
• System Logs: Container and system logs
• Custom Logs: MCP-specific logging

Distributed Tracing

Access Jaeger at http://localhost:16686 to trace requests:

• Request Flow: End-to-end request tracing
• Performance Analysis: Identify bottlenecks
• Error Tracking: Trace error propagation
• Service Dependencies: Understand service interactions

🗄️ Database

PostgreSQL Setup

The database is automatically initialized with:

• Users: User management and authentication
• Organizations: Multi-tenant support
• Templates: MCP server templates
• Configurations: MCP server configurations
• Deployments: Deployment tracking
• Audit Logs: Comprehensive audit trail

Database Access

# Connect via Docker
./scripts/dev.sh db

# Or directly
docker-compose exec postgres psql -U mcp_user -d mcp_maker

Default Credentials

• Database: mcp_maker
• Username: mcp_user
• Password: mcp_password
• Admin User: admin / admin123

🔧 Configuration

Environment Variables

Key environment variables for customization:

# Database
POSTGRES_DB=mcp_maker
POSTGRES_USER=mcp_user
POSTGRES_PASSWORD=mcp_password

# Redis
REDIS_PASSWORD=your_redis_password

# Kafka
KAFKA_BROKER_ID=1
KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181

# Monitoring
GRAFANA_ADMIN_PASSWORD=admin
PROMETHEUS_RETENTION=200h

Custom Configuration

1. Nginx: Edit docker/nginx/nginx.conf
2. Prometheus: Edit docker/prometheus/prometheus.yml
3. Grafana: Add dashboards to docker/grafana/dashboards/
4. Logstash: Edit docker/logstash/logstash.conf

🚀 Deployment

Production Deployment

For production deployment:

1. Update environment variables for production values
2. Configure SSL certificates in docker/nginx/ssl/
3. Set up external databases for high availability
4. Configure monitoring for production metrics
5. Set up backup strategies for data persistence

Scaling

# Scale backend services
docker-compose up -d --scale mcp-backend=3

# Scale frontend services
docker-compose up -d --scale mcp-frontend=2

# Use load balancer for multiple instances

🔒 Security

Security Features

• Authentication: OAuth 2.0 / JWT tokens
• Authorization: Role-based access control (RBAC)
• Network Security: Docker networks with isolation
• Data Encryption: TLS 1.3 for data in transit
• Audit Logging: Comprehensive audit trails
• Rate Limiting: API rate limiting and DDoS protection

Security Best Practices

1. Change default passwords in production
2. Use secrets management for sensitive data
3. Enable SSL/TLS for all communications
4. Regular security updates for all components
5. Monitor security events and audit logs

📚 API Documentation

Backend API

The backend provides REST APIs for:

• Authentication: User login, registration, token management
• Templates: MCP server template management
• Configurations: MCP server configuration management
• Deployments: MCP server deployment and management
• Monitoring: Health checks, metrics, and status

API Endpoints

GET    /api/health              # Health check
POST   /api/auth/login          # User authentication
GET    /api/templates           # List templates
POST   /api/templates           # Create template
GET    /api/configurations      # List configurations
POST   /api/configurations      # Create configuration
GET    /api/deployments         # List deployments
POST   /api/deployments         # Deploy MCP server

🧪 Testing

Running Tests

# Backend tests
cd backend
./mvnw test

# Frontend tests
cd frontend
npm test

# Integration tests
docker-compose -f docker-compose.test.yml up --abort-on-container-exit

Test Coverage

• Unit Tests: Individual component testing
• Integration Tests: Service integration testing
• End-to-End Tests: Full application testing
• Performance Tests: Load and stress testing

🤝 Contributing

Development Workflow

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests for new functionality
5. Run the test suite
6. Submit a pull request

Code Standards

• TypeScript 5.x: Strict mode enabled with latest features
• Java 21: Spring Boot best practices with modern Java features
• Angular 19: Standalone components and Signals
• Docker: Multi-stage builds with latest base images
• Documentation: Comprehensive README files

📞 Support

Getting Help

• Documentation: Check this README and inline comments
• Issues: Create GitHub issues for bugs and feature requests
• Discussions: Use GitHub discussions for questions
• Community: Join our community forum

Troubleshooting

Common issues and solutions:

1. Port conflicts: Check if ports are already in use
2. Memory issues: Increase Docker memory allocation
3. Database connection: Verify PostgreSQL is running
4. Service health: Check service logs for errors

📄 License

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

🙏 Acknowledgments

• Spring Boot team for the excellent framework
• Angular team for the powerful frontend framework
• Docker team for containerization technology
• Prometheus and Grafana teams for monitoring solutions
• Open source community for all the amazing tools and libraries

---

Happy coding! 🚀