The final architecture: a business's complete AI stack

┌─────────────────────────────────────────────────────────┐
│                       USER                               │
└────────────────────────┬────────────────────────────────┘
                         │
┌────────────────────────▼────────────────────────────────┐
│               FRONTEND (Layer 1)                        │
│  v0.app / Webflow / Next.js / Telegram Bot              │
│  What's here: UI, forms, dashboards, mobile layout      │
└────────────────────────┬────────────────────────────────┘
                         │
┌────────────────────────▼────────────────────────────────┐
│               API GATEWAY (Layer 2)                     │
│  Cloudflare Workers / FastAPI / Express                 │
│  What's here: routing, auth, rate limiting, logging     │
└─────────┬──────────────┬──────────────┬─────────────────┘
          │              │              │
┌─────────▼──────┐ ┌─────▼──────┐ ┌────▼──────────────────┐
│  AI (Layer 3)  │ │ DATA (L.4) │ │ PAYMENTS (Layer 5)    │
│  Claude API    │ │ Supabase   │ │ Stripe                │
│  Embeddings   │ │ PostgreSQL │ │ Subscriptions         │
│  Vector DB    │ │ Redis cache│ │ Webhooks              │
└────────────────┘ └────────────┘ └───────────────────────┘
          │
┌─────────▼────────────────────────────────────────────────┐
│           INTEGRATION LAYER (cross-cutting)              │
│  n8n / Zapier: connecting everything to everything      │
│  CRM → Marketing → Support → Analytics                  │
└──────────────────────────────────────────────────────────┘

// worker.js: basic structure
export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    
    // Routing
    if (url.pathname === '/api/generate') {
      return handleGenerate(request, env);
    }
    
    if (url.pathname === '/api/webhook/stripe') {
      return handleStripeWebhook(request, env);
    }
    
    return new Response('Not found', { status: 404 });
  }
};

async function handleGenerate(request, env) {
  // Auth check
  const apiKey = request.headers.get('X-API-Key');
  if (!await validateKey(apiKey, env)) {
    return new Response('Unauthorized', { status: 401 });
  }
  
  // Rate limiting with KV
  const count = await env.RATE_LIMITS.get(apiKey) || 0;
  if (count > 100) {  // 100 requests per hour
    return new Response('Rate limit exceeded', { status: 429 });
  }
  await env.RATE_LIMITS.put(apiKey, String(parseInt(count) + 1), {expirationTtl: 3600});
  
  // Call Claude
  const body = await request.json();
  const result = await callClaude(body.prompt, env.ANTHROPIC_API_KEY);
  
  return Response.json({ result });
}

def route_to_model(task_type: str, complexity: str) -> str:
    """
    Cut costs by routing each task to the right model.
    """
    # Prices per 1 million tokens (input / output) as of October 2026; current ones: ../actual.html
    routing = {
        ("classification", "simple"): "claude-haiku-4-5",      # $1 / $5
        ("summarization", "simple"): "claude-haiku-4-5",
        ("generation", "standard"): "claude-sonnet-5-5",        # $2 / $10
        ("generation", "complex"): "claude-sonnet-5-5",
        ("reasoning", "critical"): "claude-opus-5-5",           # $4 / $20
        ("architecture", "critical"): "claude-opus-5-5",
    }
    return routing.get((task_type, complexity), "claude-sonnet-5-5")

# Example
model = route_to_model("classification", "simple")
# → claude-haiku-4-5 (the lightest and cheapest in the lineup)

Supabase (PostgreSQL): main storage
├── users (accounts, settings)
├── conversations (chat history)  
├── documents (uploaded files)
└── analytics (events, metrics)

pgvector (Supabase's vector extension): semantic search
├── embeddings for RAG
└── finding similar documents

Redis (Upstash): fast cache
├── rate limiting
├── sessions
└── results of frequent requests

New customer in Stripe
        ↓ webhook
      n8n workflow:
        ├── Create a record in Supabase
        ├── Send a welcome email (Gmail/SendGrid)
        ├── Add to the CRM (HubSpot/Notion)
        ├── Notification to Slack or Telegram (for you)
        └── Start the onboarding sequence

import os
import requests

def notify_teams_channel(webhook_url: str, message: str, facts: dict = None):
    """Send a notification to a Microsoft Teams channel via a Workflows webhook (Adaptive Card)."""
    body = [{"type": "TextBlock", "text": message, "weight": "Bolder", "wrap": True}]
    if facts:
        body.append({
            "type": "FactSet",
            "facts": [{"title": k, "value": v} for k, v in facts.items()]
        })

    payload = {
        "type": "message",
        "attachments": [{
            "contentType": "application/vnd.microsoft.card.adaptive",
            "content": {
                "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
                "type": "AdaptiveCard",
                "version": "1.2",
                "body": body
            }
        }]
    }

    response = requests.post(webhook_url, json=payload)
    return response.status_code in (200, 202)

# Example: notification that an AI analysis is complete
notify_teams_channel(
    webhook_url=os.environ["TEAMS_WEBHOOK_URL"],
    message="✅ AI analysis of the financial reports is complete",
    facts={"Documents processed": "47", "Time": "3.2 min", "Anomalies found": "2"}
)

import os
import anthropic
import requests
from msal import ConfidentialClientApplication

def get_sharepoint_documents(site_id: str, folder: str) -> list:
    """Get documents from SharePoint via the Graph API."""
    app = ConfidentialClientApplication(
        client_id=os.environ["AZURE_CLIENT_ID"],
        client_credential=os.environ["AZURE_CLIENT_SECRET"],
        authority=f"https://login.microsoftonline.com/{os.environ['AZURE_TENANT_ID']}"
    )
    
    token = app.acquire_token_for_client(
        scopes=["https://graph.microsoft.com/.default"]
    )
    
    headers = {"Authorization": f"Bearer {token['access_token']}"}
    
    # Get the files in the folder
    url = f"https://graph.microsoft.com/v1.0/sites/{site_id}/drives/root:/{folder}:/children"
    response = requests.get(url, headers=headers)
    
    files = response.json().get("value", [])
    return [{"name": f["name"], "url": f["@microsoft.graph.downloadUrl"]} 
            for f in files if f.get("file")]

def answer_from_sharepoint(question: str, site_id: str) -> str:
    """Claude answers a question using SharePoint documents."""
    docs = get_sharepoint_documents(site_id, "Knowledge Base")
    
    # Load the document contents
    context = ""
    for doc in docs[:5]:  # Top 5 most recent
        content = requests.get(doc["url"]).text[:2000]
        context += f"\n---{doc['name']}---\n{content}"
    
    client = anthropic.Anthropic()
    return "".join(b.text for b in client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=1000,
        messages=[{
            "role": "user",
            "content": f"Company documents:\n{context}\n\nQuestion: {question}"
        }]
    ).content if b.type == "text")