sparesparrow mcp project orchestrator

A comprehensive project orchestration tool for managing Model Context Protocol (MCP) projects, templates, prompts, and Mermaid diagrams.

• Template Management

  • Project templates for quick project setup
  • Component templates for modular development
  • Variable substitution and validation
  • Template discovery and versioning

• Prompt Management

  • System and user prompt templates
  • Variable substitution
  • Prompt categorization and versioning
  • Easy prompt discovery and reuse

• Mermaid Diagram Generation

  • Flowchart generation
  • Sequence diagram generation
  • Class diagram generation
  • SVG and PNG rendering
  • Diagram validation

• AWS MCP Integration

  • AWS service access (S3, EC2, Lambda, CloudFormation, IAM)
  • AWS best practices enforcement
  • Cost optimization recommendations
  • Security and compliance guidance
  • See AWS_MCP.md for details

The package is not published on PyPI; install it from GitHub:

pip install "git+https://github.com/sparesparrow/mcp-project-orchestrator.git"

For AWS integration support:

pip install "mcp-project-orchestrator[aws] @ git+https://github.com/sparesparrow/mcp-project-orchestrator.git"

Or, for development, from a clone:

git clone https://github.com/sparesparrow/mcp-project-orchestrator.git
cd mcp-project-orchestrator
pip install -e .

This repository provides a Conan v2 package exposing the Python environment and CLI. In ai-servis's conanfile.py add:

def requirements(self):
    self.requires("mcp-project-orchestrator/0.1.0@sparesparrow/stable")

Then activate the run environment so mcp-orchestrator is on PATH and the package is on PYTHONPATH:

conan profile detect --force
conan create . --user=sparesparrow --channel=stable
conan install mcp-project-orchestrator/0.1.0@sparesparrow/stable -g VirtualRunEnv
./conanrun.sh mcp-orchestrator --help

from mcp_project_orchestrator.templates import TemplateManager

# Initialize template manager
manager = TemplateManager("path/to/templates")

# List available templates
templates = manager.list_templates()
print(templates)

# Apply a project template
manager.apply_template("fastapi-project", {
    "project_name": "my-api",
    "project_description": "My FastAPI project",
    "author_name": "John Doe",
    "author_email": "john@example.com"
})

The setup script reads config/project_orchestration.json to enable/disable features and set ports and tool options.

Run the setup:

chmod +x scripts/setup_orchestrator.sh
scripts/setup_orchestrator.sh

Edit config/project_orchestration.json to control scaffolding:

{
  "enable": {
    "cursorConfigs": true,
    "pythonMcp": true,
    "tsMcp": true,
    "cppMcp": true,
    "mcpClient": true,
    "backgroundAgent": true,
    "githubActions": true,
    "devcontainer": true,
    "awsTerraform": true,
    "webAndMcp": true,
    "cppConan": true,
    "esp32": true,
    "android": true
  }
}

• Set items to false to skip generating those components.
• Ports and URLs are respected across .cursor/webhooks, .cursor/agents, Dockerfile EXPOSE, and compose.yaml.

from mcp_project_orchestrator.prompts import PromptManager

# Initialize prompt manager
manager = PromptManager("path/to/prompts")

# List available prompts
prompts = manager.list_prompts()
print(prompts)

# Render a prompt with variables
rendered = manager.render_prompt("system-prompt", {
    "name": "User",
    "project": "MCP"
})
print(rendered)

from mcp_project_orchestrator.mermaid import MermaidGenerator, MermaidRenderer

# Initialize generators
generator = MermaidGenerator()
renderer = MermaidRenderer()

# Generate a flowchart
flowchart = generator.generate_flowchart(
    nodes=[
        ("A", "Start"),
        ("B", "Process"),
        ("C", "End")
    ],
    edges=[
        ("A", "B", ""),
        ("B", "C", "")
    ]
)

# Render to SVG
renderer.render(flowchart, "flowchart.svg")

mcp-project-orchestrator/
├── src/
│   └── mcp_project_orchestrator/
│       ├── templates/
│       │   ├── __init__.py
│       │   ├── base.py
│       │   ├── project.py
│       │   ├── component.py
│       │   └── manager.py
│       ├── prompts/
│       │   ├── __init__.py
│       │   ├── template.py
│       │   └── manager.py
│       └── mermaid/
│           ├── __init__.py
│           ├── generator.py
│           └── renderer.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── test_templates.py
│   ├── test_prompts.py
│   └── test_mermaid.py
├── docs/
├── examples/
├── .github/
│   └── workflows/
│       └── ci.yml
├── pyproject.toml
├── Containerfile
└── README.md

1. Clone the repository:

git clone https://github.com/sparesparrow/mcp-project-orchestrator.git
cd mcp-project-orchestrator

1. Install dependencies:

poetry install

1. Run tests:

poetry run pytest

1. Run linting:

poetry run ruff check .
poetry run mypy src/mcp_project_orchestrator

1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

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

• Model Context Protocol - The foundation for this project
• Mermaid - For diagram generation
• Poetry - For dependency management
• Ruff - For linting
• mypy - For type checking

Enhanced with OpenSSL project templates and Cursor AI configuration.

mcp-orchestrator create-openssl-project \
  --project-name my-secure-app \
  --deployment-target fips-government

mcp-orchestrator deploy-cursor --project-type openssl

• openssl-consumer: Standard OpenSSL application
• openssl-fips: FIPS 140-3 government deployment