Enterprise Template Generator

Enterprise Template Generator MCP Server

A comprehensive MCP (Model Context Protocol) server for enterprise software template generation, built with clean domain-driven design principles and focused on workflow automation for digitalization processes.

🚀 Features

Core Capabilities

Domain-Driven Design: Clean architecture with entities, value objects, and application services
Jinja2 Template Engine: Powerful template rendering with custom enterprise filters
FastMCP Integration: Modern MCP server with comprehensive tool set
Enterprise Validation: Swedish/EU compliance support (GDPR, Swedish Data Protection Act)
Workflow Automation: Specialized templates for platform/process migration

Template Categories

Workflow Automation: Platform migration, process digitalization
MCP Generator: Templates for creating new MCP servers
Data Science: Data analysis and ML workflow templates
Finance Analytics: Economic and financial analysis applications
Engineering ML: ML engineering and technical development
Infrastructure: Infrastructure as Code templates
Security: Security implementation templates
Compliance: Regulatory compliance templates

Enterprise Requirements Support

GDPR Compliance: Data minimization, right to erasure, privacy by design
Swedish Regulations: Data Protection Act, banking secrecy laws
Security: Zero Trust architecture, encryption, access control
Performance: <100ms response times, horizontal scaling
Resilience: Offline mode, automatic failover, 99.95% uptime SLA

🏗️ Architecture

mcp-enterprise-templates/
├── src/
│   ├── server.py                 # FastMCP server implementation
│   ├── domain/                   # Domain-driven design core
│   │   ├── entities/            # Template, Workflow entities
│   │   ├── value_objects/       # TemplateVariable, ValidationRule, etc.
│   │   └── services/            # Domain services
│   ├── application/             # Application services
│   │   └── template_service.py  # Template management
│   ├── infrastructure/          # External integrations
│   └── templates/               # Jinja2 templates
├── tests/                       # TDD test suite
└── docs/                       # Documentation

🛠️ Installation

Clone and Setup
git clone <repository> cd mcp-template python3 -m venv venv source venv/bin/activate pip install -r requirements.txt
Run Tests
pytest tests/ -v
Test the Server
python test_server.py

⚙️ Configuration

Local Development

Run the MCP Server Directly
# Activate virtual environment source venv/bin/activate # Run the server python -m src.server
Environment Variables
export MCP_PORT=8000 # Server port (default: 8000) export MCP_HOST=localhost # Server host (default: localhost) export LOG_LEVEL=INFO # Logging level (DEBUG, INFO, WARNING, ERROR) export TEMPLATE_DIR=/custom/path # Custom template directory (optional)

MCP Configuration for Cline

Add this server to your Cline MCP settings (~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json):

{
  "mcpServers": {
    "enterprise-templates": {
      "command": "python",
      "args": ["-m", "src.server"],
      "cwd": "/home/chris/src/mcp-template",
      "env": {
        "PYTHONPATH": "/home/chris/src/mcp-template"
      }
    }
  }
}

Or use a wrapper script:

{
  "mcpServers": {
    "enterprise-templates": {
      "command": "/home/chris/src/mcp-template/run_server.sh"
    }
  }
}

Docker Configuration

Create Dockerfile (if not exists):
FROM python:3.11-alpine WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY src/ ./src/ COPY templates/ ./templates/ ENV PYTHONPATH=/app ENV MCP_PORT=8000 EXPOSE 8000 CMD ["python", "-m", "src.server"]
Build and Run:
# Build image docker build -t mcp-enterprise-templates . # Run container docker run -d \ --name enterprise-templates \ -p 8000:8000 \ -e LOG_LEVEL=INFO \ mcp-enterprise-templates

Docker Compose Setup

Create docker-compose.yml:

version: '3.8'

services:
  mcp-server:
    build: .
    container_name: enterprise-templates
    ports:
      - "8000:8000"
    environment:
      - MCP_PORT=8000
      - LOG_LEVEL=INFO
      - PYTHONPATH=/app
    volumes:
      - ./templates:/app/templates
      - ./data:/app/data
    restart: unless-stopped

  # Optional: Couchbase for persistence
  couchbase:
    image: couchbase:latest
    ports:
      - "8091-8094:8091-8094"
      - "11210:11210"
    environment:
      - COUCHBASE_ADMINISTRATOR_USERNAME=admin
      - COUCHBASE_ADMINISTRATOR_PASSWORD=password

Run with:

docker-compose up -d

Systemd Service (Production Linux)

Create /etc/systemd/system/mcp-enterprise-templates.service:

[Unit]
Description=Enterprise Template Generator MCP Server
After=network.target

[Service]
Type=simple
User=mcp
Group=mcp
WorkingDirectory=/opt/mcp-template
Environment="PATH=/opt/mcp-template/venv/bin"
Environment="PYTHONPATH=/opt/mcp-template"
Environment="MCP_PORT=8000"
Environment="LOG_LEVEL=INFO"
ExecStart=/opt/mcp-template/venv/bin/python -m src.server
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Enable and start:

sudo systemctl enable mcp-enterprise-templates
sudo systemctl start mcp-enterprise-templates
sudo systemctl status mcp-enterprise-templates

Kubernetes Deployment

Create k8s-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-enterprise-templates
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mcp-enterprise-templates
  template:
    metadata:
      labels:
        app: mcp-enterprise-templates
    spec:
      containers:
      - name: mcp-server
        image: mcp-enterprise-templates:latest
        ports:
        - containerPort: 8000
        env:
        - name: MCP_PORT
          value: "8000"
        - name: LOG_LEVEL
          value: "INFO"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: mcp-enterprise-templates
spec:
  selector:
    app: mcp-enterprise-templates
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8000
  type: LoadBalancer

Deploy:

kubectl apply -f k8s-deployment.yaml

🚀 Quick Start Guide

Install and Configure
# Clone repository git clone <repository> cd mcp-template # Setup Python environment python3 -m venv venv source venv/bin/activate pip install -r requirements.txt
Add to Cline MCP Settings
- Open VS Code
- Access Cline settings
- Add the configuration JSON shown above
- Restart Cline to load the MCP server
Verify Installation
# Test locally python test_server.py # Check if MCP tools are available in Cline # You should see tools like: # - create_template # - render_template # - list_templates
Create Your First Workflow
- Use the create_template tool to define a new process
- Provide process name, goal, trigger, and steps
- Use render_template to generate documentation

🔧 Troubleshooting

Common Issues

Server not starting
- Check Python version (3.8+ required)
- Verify all dependencies: pip install -r requirements.txt
- Check port availability: lsof -i :8000
MCP tools not appearing in Cline
- Verify JSON configuration syntax
- Check file paths are absolute
- Restart VS Code/Cline
- Check Cline logs for errors
Template rendering errors
- Ensure all required variables are provided
- Check template syntax (Jinja2)
- Verify variable types match template expectations
Docker issues
- Ensure Docker daemon is running
- Check port mappings
- Verify volume mounts for templates

Debug Mode

Enable debug logging:

export LOG_LEVEL=DEBUG
python -m src.server

Check logs for detailed error messages and stack traces.

🔧 MCP Tools

The server provides the following MCP tools:

Template Management

create_template - Create new enterprise templates
get_template - Retrieve template details
list_templates - List templates with filtering
update_template - Update existing templates
delete_template - Remove templates
clone_template - Clone existing templates

Template Operations

render_template - Generate code from templates
validate_template_variables - Validate template inputs
search_templates - Search templates by content

System Information

get_template_stats - System statistics
get_supported_variable_types - Available variable types
get_supported_validation_rules - Available validation rules
get_template_categories - Supported categories

📝 Usage Example

Creating a Workflow Template

# Create a platform migration template
template = await create_template({
    "name": "Database Migration Workflow",
    "description": "Comprehensive database migration with validation",
    "category": "workflow_automation",
    "template_content": "# Migration: {{ project_name }}...",
    "variables": [
        {
            "name": "project_name",
            "type": "string",
            "required": True
        }
    ],
    "validation_rules": [
        {
            "name": "gdpr_compliance",
            "rule_type": "compliance",
            "compliance_type": "gdpr"
        }
    ]
})

Rendering Templates

# Render template with variables
result = await render_template({
    "template_id": "template-uuid",
    "variables": {
        "project_name": "Customer Migration",
        "source_db": "MySQL",
        "target_db": "PostgreSQL"
    }
})

🏢 Enterprise Features

Compliance & Security

GDPR: Data processing agreements, lawful basis validation
Swedish Data Act: Data residency requirements
ISO 27001: Security controls and access management
Zero Trust: Continuous verification, least privilege

Performance & Reliability

High Performance: <100ms response times
Scalability: Horizontal scaling support
Resilience: Offline mode, automatic failover
Monitoring: Comprehensive logging and metrics

Swedish Enterprise Integration

Language Support: Swedish and English
Payment Systems: Swish, Bankgirot integration
Identity Providers: BankID, Freja eID support
Government APIs: Integration with Swedish public services

🧪 Testing

The project follows Test-Driven Development (TDD):

# Run all tests
pytest tests/ -v

# Run with coverage
pytest tests/ --cov=src --cov-report=html

# Run specific test
pytest tests/test_template_service.py::TestTemplateService::test_create_template -v

🚀 Deployment

Docker Deployment

# Build secure container
docker build -f docker/Dockerfile -t mcp-enterprise-templates .

# Run with environment variables
docker run -e MCP_PORT=8000 -p 8000:8000 mcp-enterprise-templates

Kubernetes Deployment

# Deploy to Kubernetes
kubectl apply -f infrastructure/kubernetes/

📊 Hackathon Requirements

✅ Offline Mode & Failover: Automatic failover with data center shutdown support
✅ FastMCP: Modern MCP server implementation
✅ Jinja2 Templates: Reusable enterprise templates
✅ Python: Clean, well-structured Python codebase
✅ TDD: Comprehensive test suite
✅ Virtual Environment: Proper dependency management
✅ Enterprise Ready: Swedish/EU compliance, security, performance

🤝 Contributing

Fork the repository
Create a feature branch
Write tests for new functionality
Implement the feature
Ensure all tests pass
Submit a pull request

📄 License

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

🏆 Hackathon Demo

This MCP server demonstrates:

Enterprise-grade architecture with domain-driven design
Workflow automation for digitalization processes
Swedish/EU compliance built-in
Resilience features including offline mode and failover
Template generation for faster enterprise software development

Perfect for enterprise developers who need to generate better software faster while maintaining compliance and security standards.

This server cannot be installed

security - not tested

license - not found

quality - not tested

How are these scores calculated?

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

Enables generation of enterprise-grade software templates with built-in GDPR/Swedish compliance validation, workflow automation for platform migrations, and comprehensive template management through domain-driven design principles.

Related MCP Servers

MCP Server for eSignatures
esignaturescom
A
security
A
license
A
quality
Facilitates contract and template management for eSignatures, enabling users to create, send, update, and manage contracts and templates with customizable options through a user-friendly interface.
Last updated -
13
26
Python
MIT License
DocGen MCP Server
rjadhavJT
A
security
A
license
A
quality
Automates the creation of standardized documentation by extracting information from source files and applying templates, with integration capabilities for GitHub, Google Drive, and Perplexity AI.
Last updated -
3
3
TypeScript
MIT License
WordPress Code Review MCP Server
miniOrangeDev
A
security
A
license
A
quality
A lightweight, configurable server that fetches coding guidelines, security rules, and validation patterns from external sources to help development teams maintain code quality standards in WordPress projects.
Last updated -
3
5
TypeScript
MIT License
Angular MCP Toolkit
ub-dev-7
-
security
A
license
-
quality
Provides 11 powerful tools for Angular development with enterprise-grade templates, scaffolding capabilities, and project generation features for modern Angular 20.0.x applications.
Last updated -
TypeScript
MIT License

View all related MCP servers