┌─────────────────────────────────────────────────────────────┐
│  COST-OPTIMIZED AI PIPELINE                                  │
│                                                              │
│  ┌─────────┐    ┌──────────────┐    ┌──────────────────┐   │
│  │ Clients  │───▶│ Cloudflare   │───▶│ Nginx (Reverse   │   │
│  │ (HTTPS)  │    │ (CDN + DDoS) │    │  Proxy + SSL)    │   │
│  └─────────┘    └──────────────┘    └────────┬─────────┘   │
│                                               │              │
│                    ┌──────────────────────────┤              │
│                    ▼                          ▼              │
│  ┌─────────────────────┐   ┌─────────────────────────┐     │
│  │ FastAPI Gateway      │   │ Redis Cache             │     │
│  │ (Auth + Rate Limit)  │   │ (Response caching)      │     │
│  └──────────┬──────────┘   └─────────────────────────┘     │
│             │                                                │
│    ┌────────┼────────┐                                      │
│    ▼        ▼        ▼                                      │
│  ┌─────┐ ┌─────┐ ┌─────┐                                   │
│  │GPU 1│ │GPU 2│ │GPU 3│  ← Hetzner Dedicated              │
│  │(LLM)│ │(LLM)│ │(Emb.)│   or K3s Cluster                │
│  └─────┘ └─────┘ └─────┘                                   │
│                                                              │
│  ┌─────────────────────────────────────┐                    │
│  │ Cloud Burst (Spot/Preemptible)      │                    │
│  │ Activated only when queue > 20      │                    │
│  └─────────────────────────────────────┘                    │
└─────────────────────────────────────────────────────────────┘

# Primary server: Hetzner GEX44 (RTX 4090, 24GB VRAM)
# Cost: €130/month (PKR 40,000)
# Handles: 2 concurrent LLM inference + embedding service

# Install K3s for orchestration
curl -sfL https://get.k3s.io | sh -

# Install NVIDIA container toolkit
sudo apt install nvidia-container-toolkit
sudo systemctl restart k3s

# redis.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
        - name: redis
          image: redis:7-alpine
          ports:
            - containerPort: 6379
          args: ["--maxmemory", "512mb", "--maxmemory-policy", "allkeys-lru"]

import redis
import hashlib
import json

cache = redis.Redis(host="redis", port=6379)

def get_cached_response(prompt: str, params: dict) -> dict | None:
    key = hashlib.sha256(
        json.dumps({"prompt": prompt, **params}, sort_keys=True).encode()
    ).hexdigest()
    cached = cache.get(key)
    if cached:
        return json.loads(cached)
    return None

def cache_response(prompt: str, params: dict, response: dict, ttl: int = 3600):
    key = hashlib.sha256(
        json.dumps({"prompt": prompt, **params}, sort_keys=True).encode()
    ).hexdigest()
    cache.setex(key, ttl, json.dumps(response))

FROM nvidia/cuda:12.1.0-runtime-ubuntu22.04 AS base

RUN apt-get update && apt-get install -y \
    python3.11 python3-pip curl \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .
EXPOSE 8000

HEALTHCHECK --interval=15s --timeout=5s --retries=3 \
    CMD curl -f http://localhost:8000/health || exit 1

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]

# llm-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm-api
spec:
  replicas: 2
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0    # Zero-downtime deploys
  selector:
    matchLabels:
      app: llm-api
  template:
    metadata:
      labels:
        app: llm-api
    spec:
      containers:
        - name: llm-api
          image: registry/llm-api:latest
          ports:
            - containerPort: 8000
          resources:
            requests:
              memory: "4Gi"
              nvidia.com/gpu: "1"
            limits:
              memory: "8Gi"
              nvidia.com/gpu: "1"
          env:
            - name: MODEL_PATH
              value: "/models/llama3-8b-q4"
            - name: REDIS_URL
              value: "redis://redis:6379"
            - name: CACHE_TTL
              value: "3600"
          volumeMounts:
            - name: models
              mountPath: /models
          readinessProbe:
            httpGet:
              path: /health
              port: 8000
            initialDelaySeconds: 60
            periodSeconds: 10
      volumes:
        - name: models
          hostPath:
            path: /data/models

# Batch 8 requests together instead of processing 1 at a time
# GPU processes batch almost as fast as single request
BATCH_SIZE = 8
BATCH_TIMEOUT_MS = 100  # Max wait before processing partial batch

# FP16 model: 14GB VRAM for 7B params → needs expensive GPU
# Q4 quantized: 4GB VRAM for 7B params → runs on cheap GPU

# Using GPTQ quantization
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Llama-3-8B-GPTQ",
    device_map="auto"
)

# Bad: Sending entire conversation history every request (10,000 tokens)
# Good: Summarize history + send only last 3 messages (2,000 tokens)

# System prompt optimization
SYSTEM_PROMPT = "You are an Urdu assistant. Be concise."  # 8 tokens
# vs.
SYSTEM_PROMPT = "You are an advanced AI assistant specialized in..."  # 50 tokens

# Over 100K requests/month, this saves significant compute

# Route simple requests to small models, complex to large
async def route_request(request):
    complexity = estimate_complexity(request.prompt)

    if complexity == "simple":
        return await small_model.generate(request)  # 1B model, fast
    elif complexity == "medium":
        return await medium_model.generate(request)  # 7B model
    else:
        return await large_model.generate(request)   # 70B model, expensive

PRE-DEPLOYMENT
□ Dockerfile tested locally with GPU access
□ Model weights downloaded to persistent volume
□ Redis cache tested
□ API key system working
□ Rate limiting configured per tier
□ Health check endpoint returning 200
□ .dockerignore excludes models, .env, __pycache__

DEPLOYMENT
□ K3s cluster running on Hetzner
□ NVIDIA device plugin installed
□ Deployment YAML applied
□ Service + Ingress configured
□ SSL certificate provisioned (Let's Encrypt)
□ Nginx proxy configured with AI-appropriate timeouts

POST-DEPLOYMENT
□ Monitoring dashboards live (Grafana)
□ Budget alerts set
□ Backup schedule configured
□ Load test passed (target throughput achieved)
□ Documentation for team/clients
□ Runbook for common incidents