I Built an AI That Designs MLOps Infrastructure (Without Letting AI Generate YAML)

A developer built DeployCraft AI, a tool that designs MLOps infrastructure by generating deterministic deployment blueprints from high-level inputs. The system uses a rules engine and Jinja2 templates to produce reproducible YAML manifests, while AI is limited to explaining architectural decisions and acting as a reviewer. The project is available as a live demo on Hugging Face and open-source on GitHub.

If you've ever started an AI project, you've probably asked yourself questions like: Should I deploy on Kubernetes or Cloud Run? Do I need Redis? Which database fits this workload? How should I structure CI/CD? What monitoring stack should I use? Choosing an architecture is often harder than writing the application itself. I wanted to see if AI could help with those decisions while keeping the generated infrastructure deterministic and reliable. That idea became DeployCraft AI. The Goal The application asks for a few high-level inputs: Application Framework Cloud Provider Deployment Target Database Vector Database Cache Monitoring Authentication Traffic Budget High Availability Instead of generating code from a prompt, it builds a structured deployment blueprint. The output includes: ✅ Architecture reasoning ✅ Architecture score ✅ Mermaid diagram ✅ Docker Compose / Kubernetes / Cloud Run manifests ✅ GitHub Actions workflow ✅ Security report ✅ Monitoring recommendations ✅ Cost estimation ✅ Downloadable ZIP package The Most Important Design Decision One thing I intentionally didn't do: I never let the LLM generate deployment manifests. Instead, I separated the project into three layers. Configuration │ ▼ Rules Engine │ ▼ Blueprint ┌───────────────┐ │ │ ▼ ▼ Generators AI Advisor │ │ ▼ ▼ YAML Explanations Everything infrastructure-related is deterministic. The rules layer decides: which services exist networking environment variables autoscaling storage deployment topology No AI involved. Template-Based Infrastructure Once the blueprint is built, Jinja2 templates generate: Docker Compose Kubernetes manifests Cloud Run YAML GitHub Actions workflow This means every deployment file is reproducible. AI Only Explains The LLM receives the architecture and answers questions like: Why Cloud Run? Why PostgreSQL? Why Redis? What are the risks? How could this scale? The AI becomes an architecture reviewer rather than an infrastructure generator. I found this separation makes the outputs much more trustworthy. Some Interesting Challenges A few things that took more work than expected: Supporting multiple deployment targets Each target needs different templates while sharing the same architecture model. Making AI output reliable LLMs occasionally fail or return unexpected responses. Instead of crashing the application, I implemented graceful fallbacks so the UI always remains usable. Architecture scoring Rather than asking AI for a score, the application evaluates: Security Scalability Reliability Cost Efficiency Observability using deterministic rules. Packaging everything Instead of displaying lots of text, the application bundles every generated artifact into a downloadable ZIP. Tech Stack Python Gradio Hugging Face Inference API Jinja2 Docker Kubernetes Google Cloud Run GitHub Actions What I Learned This project reinforced something I've been thinking about for a while: AI doesn't need to replace software engineering. It becomes much more useful when it's responsible for reasoning, while deterministic code remains responsible for correctness. That balance made the application significantly more reliable. Try It 🌐 Live Demo: https://huggingface.co/spaces/Upshivam786/deploycraft-ai https://huggingface.co/spaces/Upshivam786/deploycraft-ai 💻 GitHub: https://github.com/Upshivam786/DeployCraft-AI/tree/main https://github.com/Upshivam786/DeployCraft-AI/tree/main I'd appreciate any feedback or suggestions from people working in DevOps, Cloud Engineering, or MLOps.