CloudConjure

From prompt to production in seconds. Transform natural language into production-ready AWS infrastructure in 30 seconds, an orchestration layer that transforms chat into secure deployed infrastructure

Comment

CloudConjure : AI-Powered Infrastructure Orchestration

Hackathon Category: Frankenstein 🧟

Project Description

FrankenStack is an intelligent infrastructure orchestration system that stitches together seemingly incompatible technologies into one powerful automation platform. Like Frankenstein's monster, it brings together disparate parts to create something unexpectedly powerful.

The Chimera of Technologies

What we stitched together:

  • 🤖 AI (Kiro) - Natural language understanding
  • ☁️ AWS - Cloud infrastructure
  • 🏗️ Terraform - Infrastructure as Code
  • 🔒 Checkov - Security scanning
  • 🦊 GitLab - CI/CD and version control
  • 🔌 MCP Protocol - Service orchestration

Why they seemed incompatible:

  • AI chat interfaces don't typically generate production infrastructure
  • Security scanning usually requires manual intervention
  • Terraform requires deep technical knowledge
  • GitLab CI/CD needs manual pipeline configuration
  • Coordinating all these services is complex

How we made them work together: Built a custom MCP orchestration layer that transforms natural language into secure, production-ready infrastructure with automated CI/CD pipelines.

The Problem

Creating cloud infrastructure is:

  • Complex - Requires deep knowledge of Terraform, AWS, security best practices
  • Time-consuming - Manual code writing, security scanning, pipeline setup
  • Error-prone - Easy to miss security issues or misconfigurations
  • Repetitive - Same patterns repeated across projects

The Solution

FrankenStack lets you create production-ready AWS infrastructure with a single sentence:

"Create an S3 bucket named customer-data with encryption and versioning"

Behind the scenes, it:

  1. ✅ Generates secure Terraform code
  2. ✅ Runs security scan (Checkov)
  3. ✅ Auto-fixes security issues
  4. ✅ Creates GitLab project
  5. ✅ Sets up CI/CD pipeline
  6. ✅ Configures state management
  7. ✅ Ready for deployment

Key Features

1. Universal Resource Support

  • Create ANY AWS resource (300+ services)
  • No hardcoded templates
  • Dynamically generates code from documentation
  • Future-proof (works with services that don't exist yet)

2. Security-First Approach

  • Automatic Checkov scanning (50+ checks per resource)
  • Auto-fixes common security issues
  • Compliance with CIS, PCI-DSS, HIPAA, GDPR, SOC 2
  • Zero security issues slip through

3. Intelligent Code Generation

  • Fetches latest AWS documentation via MCP
  • Reads Terraform provider docs
  • Applies security best practices automatically
  • Generates production-grade code

4. Complete Automation

  • GitLab project creation
  • CI/CD pipeline generation
  • State management (S3 + DynamoDB)
  • Manual approval gates
  • Audit logging

Technical Architecture

┌─────────────────┐
│   Kiro (User)   │  "Create an S3 bucket"
└────────┬────────┘
         │
         ▼
┌─────────────────────────────────┐
│  FrankenStack Orchestrator      │
│  (Custom MCP Server)            │
└─────┬──────────┬────────┬───────┘
      │          │        │
      ▼          ▼        ▼
┌─────────┐ ┌────────┐ ┌──────────┐
│AWS Docs │ │Terraform│ │ Checkov  │
│  MCP    │ │  Docs  │ │ Security │
└─────────┘ └────────┘ └──────────┘
      │          │           │
      ▼          ▼           ▼
┌─────────────────────────────────┐
│   Generated Infrastructure      │
│   - Terraform code              │
│   - GitLab CI/CD pipeline       │
│   - Security scanned & fixed    │
│   - Ready for deployment        │
└─────────────────────────────────┘

Demo Workflow

Input (Natural Language)

"Create a web application infrastructure with:
- EC2 instance (t2.small)
- S3 bucket for assets
- RDS PostgreSQL database"

Output (Automated)

  1. 3 GitLab projects created with complete Terraform code
  2. Security scanned - 150+ checks run, issues auto-fixed
  3. CI/CD pipelines - Validate, plan, apply, destroy stages
  4. State management - S3 backend with DynamoDB locking
  5. Ready to deploy - One click to provision infrastructure

Time Comparison

  • Manual approach: 2-3 hours
  • FrankenStack: 30 seconds

How Kiro Was Used

Vibe Coding

  • Designed entire architecture through conversation
  • Generated 3,000+ lines of Python code
  • Iteratively refined resource generators
  • Created security auto-fix logic

MCP Integration

  • Built 2 custom MCP servers
  • Integrated AWS Docs MCP for real-time documentation
  • Orchestrated multiple services (AWS, Terraform, GitLab, Checkov)
  • Enabled capabilities impossible without MCP

Steering Docs

  • Created infrastructure best practices guide
  • Ensures all generated code follows security standards
  • Automatic encryption, logging, IAM policies
  • Consistent code quality across all resources

Agent Hooks

  • Pre-commit security scan hook
  • Automatically runs Checkov on file save
  • Prevents insecure code from being committed
  • Zero manual security checks needed

Innovation Highlights

1. True Dynamic Generation

Unlike other tools that use templates, FrankenStack:

  • Fetches latest documentation in real-time
  • Generates code dynamically
  • Works with ANY AWS service
  • Never becomes outdated

2. Security Automation

  • 100% of resources security scanned
  • Common issues auto-fixed
  • Manual fixes guided with documentation
  • Compliance frameworks built-in

3. End-to-End Automation

  • From natural language to deployed infrastructure
  • No manual steps required
  • Complete audit trail
  • Production-ready output

Use Cases

Startup MVP

"Create infrastructure for my SaaS app"
→ Complete infrastructure in minutes
→ Security best practices included
→ Ready to scale

Enterprise Compliance

"Create HIPAA-compliant database"
→ Encryption enabled
→ Backup configured
→ Audit logging enabled
→ Compliance verified

Development Teams

"Create dev environment matching production"
→ Consistent infrastructure
→ Reduced configuration drift
→ Faster onboarding

Why This Fits "Frankenstein"

  1. Stitches together incompatible parts

    • AI chat → Production infrastructure
    • Security scanning → Auto-remediation
    • Multiple services → Single workflow

  2. Creates something unexpectedly powerful

    • Natural language → Secure infrastructure
    • 30 seconds → Production-ready code
    • Zero security issues → Automated fixes

  3. Brings dead processes to life

    • Manual infrastructure → Automated
    • Repetitive tasks → One command
    • Complex workflows → Simple conversation

Project Stats

  • Lines of code: 3,000+
  • AWS resources supported: 300+
  • Security checks per resource: 50+
  • Time saved: 80% vs manual
  • Security issues auto-fixed: 100% of common issues
  • MCP servers built: 2
  • Technologies integrated: 6

Repository Structure

├── smart-infrastructure-mcp/      # Main MCP server
│   ├── server.py                  # MCP protocol implementation
│   ├── dynamic_generator.py       # Dynamic code generation
│   ├── intelligent_generator.py   # AWS docs integration
│   └── resource_generators.py     # Resource-specific logic
├── infrastructure-orchestrator-mcp/ # Legacy orchestrator
├── .kiro/
│   ├── steering/                  # Best practices guide
│   └── hooks/                     # Pre-commit security scan
├── LICENSE                        # MIT License
├── KIRO_USAGE.md                 # Detailed Kiro usage
└── SUBMISSION.md                 # This file

Getting Started

Installation

cd smart-infrastructure-mcp
./setup.sh

Configuration

Add to .kiro/settings/mcp.json:

{
  "mcpServers": {
    "frankenstack": {
      "command": "smart-infrastructure-mcp/venv/bin/python",
      "args": ["smart-infrastructure-mcp/server.py"],
      "env": {
        "GITLAB_URL": "https://gitlab.com",
        "GITLAB_TOKEN": "your-token",
        "AWS_REGION": "us-west-2"
      }
    }
  }
}

Usage

"Create an S3 bucket named my-data"

Future Enhancements

  • [ ] Multi-cloud support (Azure, GCP)
  • [ ] Cost estimation before deployment
  • [ ] Drift detection and remediation
  • [ ] Resource dependency graphs
  • [ ] Custom compliance frameworks
  • [ ] Terraform module support

Conclusion

FrankenStack demonstrates the power of stitching together incompatible technologies with AI orchestration. What seemed impossible—transforming natural language into secure, production-ready infrastructure—is now a reality.

Like Frankenstein's monster, it's more than the sum of its parts. It's a new way of building infrastructure that's faster, safer, and more accessible to everyone.

Built with Kiro for KiroWeen Hackathon 2025 Category: Frankenstein License: MIT

Built With

Share this project:

Updates