🚀 Tech Stack Advisor

AI-Powered Multi-Agent System for Intelligent Tech Stack Recommendations

Status ⏳ Loading...
Agents -
Uptime -
Total Requests -
Daily Queries -
Daily Cost -
Budget Left -

🔑 API Key Settings (Optional) ▼

Budget remaining today: $-
Queries remaining: -
✓ Unlimited queries
✓ No rate limits
✓ Your key is never stored on my servers

My AI agents are analyzing your requirements...

📊 Database
🏗️ Infrastructure
💰 Cost Analysis
🔒 Security

💡 What You'll Receive

My AI-powered multi-agent system will analyze your project requirements and provide comprehensive, production-ready recommendations across four critical domains. Each specialized agent examines your needs from different perspectives to deliver actionable insights.

📊 Database Agent

Analyzes: Data volume, query patterns, consistency requirements

Provides: Database recommendations (PostgreSQL, MongoDB, etc.), schema design strategies, scaling approaches (sharding, replication), caching strategies, and connection pooling guidance

🏗️ Infrastructure Agent

Analyzes: Traffic patterns, scalability needs, deployment complexity

Provides: Cloud provider recommendations (AWS, GCP, Azure, Railway), architecture patterns (microservices, monolith, serverless), compute resources, deployment strategies, load balancing, and CDN setup

💰 Cost Agent

Analyzes: Infrastructure requirements, budget constraints, growth projections

Provides: Detailed cost breakdowns across providers, monthly/annual estimates, cost optimization strategies (reserved instances, spot instances), scaling cost projections (2x, 5x, 10x), and budget management recommendations

🔒 Security Agent

Analyzes: Data sensitivity, compliance requirements, threat landscape

Provides: Threat modeling (STRIDE analysis), security controls for each threat category, compliance guidance (GDPR, HIPAA, PCI-DSS, SOC2), encryption strategies, access control recommendations, and security monitoring setup

📚 Scale & Cost Reference Guide ▼

🎯 Infrastructure Scale Tiers

Tier DAU Threshold RPS Threshold Compute Deployment Architecture
STARTER < 1,000 < 10 1-2 small instances (2 vCPU, 4GB RAM) Single region, simple setup Monolith
GROWTH ≥ 1,000 ≥ 10 3-5 medium instances (4 vCPU, 8GB RAM) Single region with load balancing Monolith or modular
SCALE ≥ 50,000 ≥ 100 10-20 instances with auto-scaling Multi-AZ, caching layer Microservices or hybrid
ENTERPRISE ≥ 500,000 ≥ 1,000 50+ instances, kubernetes cluster Multi-region, global CDN Microservices with mesh
Note: Your application is assigned to a tier if it meets EITHER the DAU OR RPS threshold (whichever is higher).

💾 Database Scale Tiers

Tier DAU Threshold QPS Threshold Recommendation Features
SMALL < 10,000 < 100 Single instance with read replicas Basic setup, good for startups
MEDIUM ≥ 10,000 ≥ 100 Primary + read replicas, caching layer Load balancing, improved performance
LARGE ≥ 100,000 ≥ 1,000 Sharded setup, dedicated caching High availability, distributed data
ENTERPRISE ≥ 1,000,000 ≥ 10,000 Multi-region, auto-sharding, CDN Global scale, maximum performance
Note: Database tier is assigned based on EITHER the DAU OR QPS threshold (whichever is higher).

🔢 QPS Calculation Formula

Formula: QPS = max(10, DAU × 0.015 / 60)

Assumptions:

  • 1.5% of daily active users are concurrent at peak times
  • Each concurrent user makes ~10 requests per minute
  • Minimum QPS is set to 10 for small applications

Example: For 1,000,000 DAU → QPS = 1,000,000 × 0.015 / 60 = 250 QPS

💰 Cost Estimation Heuristics

Infrastructure Requirements by DAU:

DAU Range Instances Instance Type Storage (GB) Bandwidth (GB/month)
< 10,000 2 Small 50 100
10,000 - 99,999 4 Medium 200 500
100,000 - 499,999 10 Large 500 2,000
≥ 500,000 20 XLarge 1,000 5,000

💵 Provider Pricing (Monthly USD)

Component AWS GCP Azure Railway
Small instance $20 $18 $21 $10
Medium instance $35 $32 $38 $20
Large instance $70 $65 $75 $40
XLarge instance $140 $130 $145 $80
Storage (per GB) $0.10 $0.09 $0.11 $0.05
Bandwidth (per GB) $0.09 $0.08 $0.10 $0.05
Managed Database $50 $45 $55 $10
Load Balancer $20 $18 $22 Free
NAT Gateway $35 $30 $35 Free

🛠️ Additional Service Costs (Monthly USD)

Service Cost Enabled When
CDN (CloudFlare/CloudFront) $20 DAU > 10,000
Cache (Redis/Memcached) $15 DAU > 10,000
Monitoring (Basic) Free Always
Monitoring (Standard) $50 DAU > 50,000
Monitoring (Premium) $150 Optional
Backups $10 Always
Logging $10 Always
Secrets Management $5 Always
DNS $1 Always

Total Monthly Cost Formula:

Total = (Instances × Instance Price) + (Storage × $per_GB) + (Bandwidth × $per_GB) + Database + Load Balancer + NAT Gateway + Service Costs

🏗️ System Architecture & Algorithms ▼

📐 System Architecture Diagram

graph TB subgraph "Frontend Layer" UI[Web UI - HTML/CSS/JS
Chart.js + Mermaid.js] Auth[Authentication Pages
Login/Register/OAuth] Admin[Admin Dashboard
User Management] end subgraph "API Gateway Layer" FastAPI[FastAPI Backend :8000
Rate Limiting: 50-100 req/hr
JWT Authentication] CORS[CORS Middleware] RateLimit[SlowAPI Rate Limiter] end subgraph "Authentication & Session" JWT[JWT Token Manager
HS256, 24h expiry] OAuth[Google OAuth 2.0
CSRF Protection] Session[Session Store
30-min timeout] UserDB[(User Memory
Qdrant Collection)] end subgraph "LangGraph Orchestration" direction TB Parser[Context Parser
🔍 NLP Extraction:
- Regex: DAU, Budget
- Keywords: Scale, Workload
- Heuristics: QPS estimation] subgraph "Sequential Agent Pipeline" direction LR DB[Database Agent
🗄️ Tools:
- Vector Search
- Scale Estimator
Algorithm: Tier-based] Infra[Infrastructure Agent
☁️ Recommendations:
- Cloud Providers
- Architecture Patterns
- Mermaid Diagrams] Cost[Cost Agent
💰 Multi-Cloud Pricing:
- AWS/GCP/Azure
- Component Breakdown
Algorithm: Cost Model] Sec[Security Agent
🔒 Risk Assessment:
- Threat Modeling
- Compliance Check
Algorithm: Risk Scoring] end Synth[Result Synthesizer
Aggregate & Format] Parser --> DB --> Infra --> Cost --> Sec --> Synth end subgraph "Conversation Manager" Conv[Conversation Agent
💬 Multi-turn Dialogue
Algorithm: Iterative Context
Completion: 0-100%] ConvSession[(Conversation Sessions
In-Memory Store)] Conv -.-> ConvSession end subgraph "RAG System - Retrieval Augmented Generation" direction TB Embed[Embedding Model
sentence-transformers
all-MiniLM-L6-v2
384 dimensions
Latency: 2ms/query] VectorDB[(Qdrant Vector Database
Collections:
- tech_stack_knowledge 34 docs
- user_queries embeddings
- users credentials
- feedback
Distance: Cosine Similarity)] KB[Knowledge Base
📚 34 Curated Docs:
- databases.json 10
- infrastructure.json 12
- security.json 12] KB --> Embed Embed --> VectorDB end subgraph "LLM Integration" Claude[Anthropic Claude API
Model: claude-3-haiku
Temperature: 0.7
Max Tokens: 4096
Cost: ~$0.0015/query] Metrics[Token & Cost Tracking
Prometheus Metrics] Claude -.-> Metrics end subgraph "Storage & Memory" LongMem[(Long-Term Memory
Qdrant Semantic Search
Query History)] ShortMem[(Short-Term Memory
In-Memory Sessions
30-min timeout)] end subgraph "Monitoring & Observability" Logger[Structured Logging
Correlation IDs
JSON Format] Prom[Prometheus Metrics
HTTP/LLM/App Stats] Health[Health Check Endpoint
Agent Status] end %% User Flow UI --> FastAPI Auth --> FastAPI Admin --> FastAPI %% API Processing FastAPI --> CORS FastAPI --> RateLimit FastAPI --> JWT FastAPI --> OAuth FastAPI --> Session %% Main Recommendation Flow FastAPI --> Parser FastAPI --> Conv %% Agent Dependencies DB --> VectorDB Infra --> VectorDB Cost --> VectorDB Sec --> VectorDB DB --> Claude Infra --> Claude Cost --> Claude Sec --> Claude %% Memory Storage Synth --> LongMem Synth --> ShortMem FastAPI --> UserDB %% Monitoring FastAPI --> Logger FastAPI --> Prom FastAPI --> Health %% Styling classDef frontend fill:#667eea,stroke:#333,stroke-width:2px,color:#fff classDef api fill:#48bb78,stroke:#333,stroke-width:2px,color:#fff classDef agent fill:#ed8936,stroke:#333,stroke-width:2px,color:#fff classDef storage fill:#4299e1,stroke:#333,stroke-width:2px,color:#fff classDef llm fill:#9f7aea,stroke:#333,stroke-width:2px,color:#fff classDef monitor fill:#38b2ac,stroke:#333,stroke-width:2px,color:#fff class UI,Auth,Admin frontend class FastAPI,CORS,RateLimit api class Parser,DB,Infra,Cost,Sec,Synth,Conv agent class VectorDB,UserDB,LongMem,ShortMem,ConvSession,KB storage class Claude,Embed llm class Logger,Prom,Health,Metrics monitor
Architecture Highlights:
• Multi-Agent System: 5 specialized agents (Database, Infrastructure, Cost, Security, Conversation)
• RAG Pipeline: Semantic search with 384-dim embeddings (~30ms latency)
• Sequential Workflow: LangGraph orchestration with state management
• Authentication: JWT + Google OAuth 2.0 with CSRF protection
• Memory Management: Long-term (Qdrant) + Short-term (In-memory sessions)
• End-to-End Latency: 2-4 seconds (parsing 5ms + RAG 150ms + LLM 2-3s)

🧮 Key Algorithms & Techniques

1. Natural Language Processing (NLP) - Context Extraction

Location: backend/src/orchestration/workflow.py

Techniques Used:

  • Regex Pattern Matching: Extracts DAU (Daily Active Users) and budget from natural language queries
  • Keyword-Based Classification: Detects scale ("small", "medium", "large", "enterprise"), workload type ("real-time", "api", "batch"), and data sensitivity
  • Heuristic-Based Estimation: QPS = DAU × 0.015 / 60, Data Volume = DAU / 100 GB

Performance: 1-5ms per query

2. Retrieval-Augmented Generation (RAG) - Semantic Search

Location: backend/src/rag/vectorstore.py

Algorithm: Vector Similarity Search with Cosine Distance

Process Flow:

User Query → Text Embedding (384-dim) → Qdrant Vector Search → Cosine Similarity → Metadata Filtering → Top-K Retrieval

Model: sentence-transformers/all-MiniLM-L6-v2

Performance: ~30ms per RAG retrieval (embedding + search)

3. Database Scale Estimation - Tier-Based Heuristics

Location: backend/src/agents/database.py

Algorithm: Multi-factor tier classification

Decision Tree:

if DAU ≥ 1M or QPS ≥ 10K → Enterprise
elif DAU ≥ 100K or QPS ≥ 1K → Large
elif DAU ≥ 10K or QPS ≥ 100 → Medium
else → Small

Outputs: Tier, estimated connections, cache recommendation, sharding strategy, replication approach

Complexity: O(1) - constant time decision tree

4. Multi-Cloud Cost Estimation - Component-Based Pricing

Location: backend/src/agents/cost.py

Algorithm: Linear cost model with provider-specific multipliers

Formula:

Total Monthly Cost = Compute + Storage + Database + Bandwidth
Provider Multipliers: AWS (1.0x), GCP (1.09x), Azure (1.05x)

Complexity: O(1) - lookup table + simple arithmetic

5. Security Risk Assessment - Multi-Factor Scoring

Location: backend/src/agents/security.py

Algorithm: Weighted risk scoring with priority matrix

Risk Factors:

Risk Score = Data Sensitivity (40%) + Public Exposure (25%) + Compliance (20%) + Architecture Complexity (15%)
Risk Level: ≥70 = CRITICAL, ≥50 = HIGH, ≥30 = MEDIUM, else LOW

Threat Prioritization: CRITICAL (SQL injection, data exposure), HIGH (CSRF, XSS), MEDIUM (DDoS), LOW (info disclosure)

Complexity: O(n) where n = number of compliance requirements (typically < 5)

6. Conversation Management - Iterative Context Accumulation

Location: backend/src/agents/conversation.py

Algorithm: Contextual completion tracking with structured questioning

Completion Calculation:

Completion = app_type (40%) + dau/scale (40%) + key_features (20%)
Ready when completion ≥ 80%

Strategy: Prioritize missing critical fields → Provide structured options → Extract entities → Avoid redundancy

Complexity: O(k) where k = number of conversation turns (typically 2-5)

7. LangGraph Sequential Workflow - State Machine

Location: backend/src/orchestration/workflow.py

Pattern: Directed Acyclic Graph (DAG) with shared state

Execution Flow:

parse_query → database_agent → infrastructure_agent → cost_agent → security_agent → synthesize

State Management: Shared TypedDict state accumulates results from each agent

Complexity: O(n) where n = number of agents (currently 5, sequential execution)

8. Token & Cost Tracking - Real-Time Metrics

Location: backend/src/core/logging.py

Algorithm: Cumulative metrics with daily aggregation

Cost Calculation (Claude 3 Haiku):

Cost = (input_tokens × $0.00025 + output_tokens × $0.00125) / 1000
Average: ~$0.0015 per query (~6,250 tokens)

Metrics: Prometheus-format counters and gauges for tokens, cost, queries (per agent and daily totals)

Need Help or Have Feedback?

If something is not working as expected or you'd like to share your feedback, please email me at

ranjana.rajendran@gmail.com

© 2025 Ranjana Rajendran. All rights reserved.

Let's gather some more details