ArchForge is an experimental AI-assisted system design engine that transforms natural language prompts into structured, production-inspired architecture diagrams.
It combines rule-based engineering, flow modeling, and LLM augmentation to generate system architectures with increasing realism and explainability.
👉 https://archforge.vercel.app
Provide a prompt like:
"scalable e-commerce platform with payments and analytics"
ArchForge generates:
- 🧩 System architecture diagram (React Flow)
- 🏗 Microservices & infrastructure breakdown
- 🔄 Multi-hop data flow pipelines
- 📦 Data storage and messaging topology
- 💡 AI + rule-based improvement suggestions
This project is not a perfect system design generator.
Generating diagrams is easy. Generating correct, production-grade system design is extremely hard.
ArchForge is an exploration of that problem space, not a final solution.
The system follows a multi-stage pipeline:
Input → Parser → Capability Mapping → Components → AI Enhancement
→ Flow Engine → Graph Builder → Validation → Visualization
Extracts capabilities from user intent:
- e-commerce
- analytics
- real-time
- messaging
Maps capabilities into architectural layers:
- Interaction
- Processing
- Data
- Integration
Creates deterministic baseline components:
- API Gateway
- Services
- Databases
- Queues
Hybrid system:
- Rule-based inference (deterministic)
- LLM-based augmentation (optional)
Supports:
- OpenAI
- Gemini
- Groq
- Ollama (local fallback)
Fail-safe:
If all AI fails → engine still produces architecture
Generates multi-hop execution pipelines:
Example:
Client → CDN → Gateway → Service → Cache → DB
→ Kafka → Worker → Data Warehouse
→ Response → Client
Includes:
- async flows
- event-driven pipelines
- feedback loops
- pipeline grouping
Enforces system design principles:
✔ Database per service ✔ No invalid connections ✔ Proper async boundaries ✔ No direct DW writes ✔ Cache usage rules
Implements:
- Planner → identifies architecture pattern
- Critic → detects flaws
- Fixer → attempts corrections
Creates structured graph:
- nodes (components)
- edges (flows)
- metadata (priority, type, layer)
Generates multiple views:
- Simple
- Detailed
- Layered
- Flow view
Not just connections — full execution pipelines
Ensures:
- DB-per-service
- async processing
- proper layering
Adds:
- payment services
- analytics pipelines
- search systems
Combines:
- deterministic logic
- LLM augmentation
- fallback safety
Each connection includes:
- type (request/event/async)
- reason (why it exists)
- React
- React Flow
- Tailwind CSS
- Node.js
- Express
- OpenAI / Gemini / Groq
- Ollama (local models)
- Graph-based rendering
- Layered architecture UI
(Add screenshots here)
- Not 100% architecturally accurate
- Some flows may still be overly generic
- Complex distributed patterns (Saga, CQRS) are partially modeled
- Visualization can become dense for large systems
- Can system design be automated?
- Where does AI fail in architecture reasoning?
- How to combine rules + AI effectively?
- How to validate system correctness programmatically?
- Better connection validation engine
- Stronger domain-specific architectures
- Cleaner graph layout (reduce edge overlap)
- More accurate async vs sync modeling
- Improved AI reasoning with structured prompts
- Collaboration & editing support
Contributions are welcome!
Ideas:
- Improve validation rules
- Add new domain templates
- Optimize flow engine
- Improve UI/UX
This project taught me that system design is not about diagrams — it's about constraints, trade-offs, and correctness.
MIT
Would love feedback from engineers working on large-scale systems.
Give it a star — it motivates further improvements!