La arquitectura final: el stack de IA completo de un negocio

┌─────────────────────────────────────────────────────────┐
│                      USUARIO                             │
└────────────────────────┬────────────────────────────────┘
                         │
┌────────────────────────▼────────────────────────────────┐
│               FRONTEND (Capa 1)                         │
│  v0.app / Webflow / Next.js / Bot de Telegram           │
│  Qué hay aquí: UI, formularios, paneles, versión móvil  │
└────────────────────────┬────────────────────────────────┘
                         │
┌────────────────────────▼────────────────────────────────┐
│               API GATEWAY (Capa 2)                      │
│  Cloudflare Workers / FastAPI / Express                 │
│  Qué hay aquí: ruteo, auth, rate limiting, registros    │
└─────────┬──────────────┬──────────────┬─────────────────┘
          │              │              │
┌─────────▼──────┐ ┌─────▼──────┐ ┌────▼──────────────────┐
│  IA (Capa 3)   │ │ DATOS (C.4)│ │ PAGOS (Capa 5)        │
│  Claude API    │ │ Supabase   │ │ Stripe                │
│  Embeddings    │ │ PostgreSQL │ │ Suscripciones         │
│  Vector DB     │ │ Redis cache│ │ Webhooks              │
└────────────────┘ └────────────┘ └───────────────────────┘
          │
┌─────────▼────────────────────────────────────────────────┐
│           CAPA DE INTEGRACIÓN (Transversal)              │
│  n8n / Zapier: conecta todo con todo                     │
│  CRM → Marketing → Soporte → Analítica                   │
└──────────────────────────────────────────────────────────┘

// worker.js: estructura básica
export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    
    // Ruteo
    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) {
  // Revisión de autenticación
  const apiKey = request.headers.get('X-API-Key');
  if (!await validateKey(apiKey, env)) {
    return new Response('Unauthorized', { status: 401 });
  }
  
  // Rate limiting con KV
  const count = await env.RATE_LIMITS.get(apiKey) || 0;
  if (count > 100) {  // 100 solicitudes por hora
    return new Response('Rate limit exceeded', { status: 429 });
  }
  await env.RATE_LIMITS.put(apiKey, String(parseInt(count) + 1), {expirationTtl: 3600});
  
  // Llamada a 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:
    """
    Optimizar el costo con un ruteo correcto.
    """
    # Precios por 1 millón de tokens (entrada / salida) a octubre de 2026; vigentes: ../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")

# Ejemplo de uso
model = route_to_model("classification", "simple")
# → claude-haiku-4-5 (el más ligero y barato de la línea)

Supabase (PostgreSQL): el almacenamiento principal
├── users (cuentas, configuración)
├── conversations (historial de chats)
├── documents (archivos subidos)
└── analytics (eventos, métricas)

pgvector (la extensión vectorial de Supabase): búsqueda semántica
├── embeddings para RAG
└── búsqueda de documentos parecidos

Redis (Upstash): caché rápida
├── rate limiting
├── sesiones
└── resultados de solicitudes frecuentes

Cliente nuevo en Stripe
        ↓ webhook
      workflow de n8n:
        ├── Crear un registro en Supabase
        ├── Enviar el correo de bienvenida (Gmail/SendGrid)
        ├── Agregarlo al CRM (HubSpot/Notion)
        ├── Avisarte a ti (Telegram, Slack o correo)
        └── Arrancar la secuencia de onboarding

import os
import requests

def notify_teams_channel(webhook_url: str, message: str, facts: dict = None):
    """Enviar un aviso a un canal de Microsoft Teams con un webhook de Workflows (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)

# Ejemplo: aviso de que terminó un análisis con IA
notify_teams_channel(
    webhook_url=os.environ["TEAMS_WEBHOOK_URL"],
    message="✅ Terminó el análisis con IA de los reportes",
    facts={"Documentos procesados": "47", "Tiempo": "3.2 min", "Anomalías encontradas": "2"}
)

import os
import anthropic
import requests
from msal import ConfidentialClientApplication

def get_sharepoint_documents(site_id: str, folder: str) -> list:
    """Obtener documentos de SharePoint con la 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']}"}
    
    # Obtener los archivos de la carpeta
    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 responde una pregunta usando los documentos de SharePoint."""
    docs = get_sharepoint_documents(site_id, "Knowledge Base")
    
    # Cargar el contenido de los documentos
    context = ""
    for doc in docs[:5]:  # Los 5 más recientes
        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"Documentos de la empresa:\n{context}\n\nPregunta: {question}"
        }]
    ).content if b.type == "text")