MCP-Creator-MCP 🚀

A meta-MCP server that democratizes MCP server creation through AI-guided workflows and intelligent templates.

Transform vague ideas into production-ready MCP servers with minimal cognitive overhead and maximum structural elegance.

🎯 Vision

Creating MCP servers should be as simple as describing what you want. MCP Creator bridges the gap between idea and implementation, providing intelligent guidance, proven templates, and streamlined workflows.

Related MCP server: MCP Maker

✨ Core Features

• 🤖 AI-Guided Creation: Get intelligent suggestions and best practices tailored to your use case

• 📚 Template Library: Curated collection of proven MCP server patterns

• 🔄 Workflow Engine: Save and reuse creation workflows for consistent results

• 🎨 Gradio Interface: User-friendly web interface for visual server management

• 🔧 Multi-Language Support: Python, Gradio, and expanding language ecosystem

• 📊 Built-in Monitoring: Server health checks and operational visibility

• 🛡️ Best Practices: Automated validation and security recommendations

🚀 Quick Start

Prerequisites

• Python 3.10 or higher

• uv package manager

• Claude Desktop (for MCP integration)

Installation

# Clone and set up the project
git clone https://github.com/angrysky56/mcp-creator-mcp.git
cd mcp-creator-mcp

# Create and activate virtual environment
uv venv --python 3.12 --seed
source .venv/bin/activate

# Install dependencies
uv add -e .

# Configure environment
cp .env.example .env
# Edit .env with your API keys (see Configuration section)

Basic Usage

Option 1: As an MCP Server (Recommended)

1. Configure Claude Desktop:

   # Copy the example config
   cp example_mcp_config.json ~/path/to/claude_desktop_config.json
   # Edit paths and API keys as needed

2. Start using in Claude Desktop:

   • Restart Claude Desktop

   • Use tools like create_mcp_server, list_templates, get_ai_guidance

Option 2: Standalone Interface

# Launch the Gradio interface
uv run gradio_interface.py

# Or use the CLI
uv run mcp-creator-gui

📖 Configuration

Environment Variables

Create a .env file with your settings:

# AI Model Providers (at least one required for AI guidance)
ANTHROPIC_API_KEY=your_anthropic_key_here
OPENAI_API_KEY=your_openai_key_here
OLLAMA_BASE_URL=http://localhost:11434

# MCP Creator Settings
DEFAULT_OUTPUT_DIR=./mcp_servers
LOG_LEVEL=INFO

# Gradio Interface
GRADIO_SERVER_PORT=7860
GRADIO_SHARE=false

Claude Desktop Integration

1. Edit your Claude Desktop config (usually at ~/.config/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "mcp-creator": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/mcp-creator-mcp",
        "run",
        "python",
        "main.py"
      ],
      "env": {
        "ANTHROPIC_API_KEY": "your_key_here"
      }
    }
  }
}

2. Restart Claude Desktop

🛠️ Usage Examples

Creating Your First MCP Server

# In Claude Desktop, ask:
"Create an MCP server called 'weather_helper' that provides weather data and forecasts"

# Or use the tool directly:
create_mcp_server(
    name="weather_helper",
    description="Provides weather data and forecasts",
    language="python",
    template_type="basic",
    features=["tools", "resources"]
)

Getting AI Guidance

# Ask for specific guidance:
get_ai_guidance(
    topic="security",
    server_type="database"
)

# Or access guidance resources:
# Use resource: mcp-creator://guidance/sampling

Managing Templates

# List available templates
list_templates()

# Filter by language
list_templates(language="python")

🏗️ Architecture

Core Principles

• Simplicity: Each component has a single, clear responsibility

• Predictability: Consistent patterns reduce cognitive load

• Extensibility: Modular design enables easy customization

• Reliability: Comprehensive error handling and graceful degradation

Component Overview

├── src/mcp_creator/
│   ├── core/              # Core server functionality
│   │   ├── config.py      # Clean configuration management
│   │   ├── template_manager.py  # Template system
│   │   └── server_generator.py # Server creation engine
│   ├── workflows/         # Workflow management
│   ├── ai_guidance/       # AI assistance system
│   └── utils/             # Shared utilities
├── templates/             # Template library
├── ai_guidance/           # Guidance content
└── mcp_servers/          # Generated servers (default)

📚 Template System

Available Templates

• Python Basic: Clean, well-structured foundation

• Python with Resources: Database and API integration patterns

• Python with Sampling: AI-enhanced server capabilities

• Gradio Interface: Interactive UI with MCP integration

Creating Custom Templates

Templates use Jinja2 with clean abstractions:

# Template structure
templates/languages/{language}/{template_name}/
├── metadata.json          # Template configuration
├── template.py.j2        # Main template file
└── README.md.j2          # Documentation template

🔄 Workflow System

Saving Workflows

save_workflow(
    name="Database MCP Server",
    description="Complete database integration workflow",
    steps=[
        {
            "id": "collect_requirements",
            "type": "input",
            "config": {"fields": ["db_type", "connection_string"]}
        },
        {
            "id": "security_review",
            "type": "ai_guidance",
            "config": {"topic": "database_security"}
        },
        {
            "id": "generate_server",
            "type": "generation",
            "config": {"template": "python:database"}
        }
    ]
)

🔧 Development

Project Structure

The codebase follows clean architecture principles:

• Separation of Concerns: Each module has a single responsibility

• Dependency Injection: Components are loosely coupled

• Error Boundaries: Graceful failure handling throughout

• Type Safety: Comprehensive type hints and validation

Adding New Templates

1. Create template directory: templates/languages/{lang}/{name}/

2. Add metadata.json with template configuration

3. Create template.{ext}.j2 with Jinja2 template

4. Test with the template manager

Contributing

1. Fork the repository

2. Create a feature branch with descriptive name

3. Follow the existing code patterns and style

4. Add tests for new functionality

5. Submit a pull request with clear description

🛡️ Security & Best Practices

Built-in Protections

• Input Validation: All user inputs are validated and sanitized

• Process Management: Proper cleanup prevents resource leaks

• Error Handling: Graceful failure with helpful messages

• Logging: Comprehensive operational visibility

Recommended Practices

• Use environment variables for sensitive data

• Implement rate limiting for production deployments

• Regular security audits of generated servers

• Monitor server performance and resource usage

🐛 Troubleshooting

Common Issues

Server won't start:

# Check dependencies
uv add -e .

# Verify configuration
cat .env

# Check logs
tail -f logs/mcp-creator.log

Claude Desktop integration:

# Verify config file syntax
python -m json.tool claude_desktop_config.json

# Check server connectivity
python main.py --test

Template errors:

# List available templates
uv run python -c "from src.mcp_creator import TemplateManager; print(TemplateManager().list_templates())"

📊 Monitoring & Operations

Health Checks

The server provides built-in health monitoring:

• Resource usage tracking

• Error rate monitoring

• Performance metrics

• Template validation

Logging

All operations are logged to stderr (MCP compliance):

# View logs in real-time
python main.py 2>&1 | tee mcp-creator.log

🚀 What's Next?

• Multi-language expansion: TypeScript, Go, Rust templates

• Cloud deployment: Integration with major cloud platforms

• Collaboration features: Team workflows and template sharing

• Advanced AI: Enhanced code generation and optimization

• Marketplace: Community template and workflow ecosystem

📝 License

MIT License - see LICENSE for details.

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

💬 Support

• Issues: GitHub Issues

• Discussions: GitHub Discussions

• Documentation: Wiki

Built with ❤️ for the MCP community

MCP Creator makes sophisticated AI integrations accessible to everyone, from hobbyists to enterprise teams.