# Don't use Claude Opus for everything — it's expensive
# Route tasks to the right model

MODEL_ROUTING = {
 # Cheap tasks: use cheap models ($0.15-0.30/1M input)
 "text_classification": "gpt-5-mini",
 "sentiment_analysis": "gpt-5-mini", 
 "keyword_extraction": "gemini-2.5-flash-lite",
 "simple_qa": "claude-haiku-4-5",
 
 # Medium tasks: use balanced models ($1-3/1M input)
 "content_generation": "claude-sonnet-4-5",
 "summarization": "claude-sonnet-4-5",
 "code_explanation": "deepseek-v3.2", # Very cheap, surprisingly good
 
 # Complex tasks only: use powerful models ($10-15/1M input)
 "complex_reasoning": "claude-opus-4-6",
 "code_review": "claude-opus-4-6",
 "legal_analysis": "gpt-5-2",
}

def route_to_model(task_type: str) -> str:
 return MODEL_ROUTING.get(task_type, "claude-sonnet-4-5") # Safe default

from openai import OpenAI
from typing import Optional

client = OpenAI(
 api_key="your-crazyrouter-key",
 base_url="https://crazyrouter.com/v1"
)

class BudgetAwareAI:
 """AI client with automatic cost controls."""
 
 def __init__(self, monthly_budget_usd: float = 30.0):
 self.monthly_budget = monthly_budget_usd
 self.spent_this_month = 0.0
 
 # Approximate cost per 1M tokens (in USD)
 self.model_costs = {
 "gpt-5-mini": {"input": 0.15, "output": 0.6},
 "gemini-2.5-flash-lite": {"input": 0.1, "output": 0.4},
 "deepseek-v3.2": {"input": 0.27, "output": 1.1},
 "claude-haiku-4-5": {"input": 0.8, "output": 4.0},
 "claude-sonnet-4-5": {"input": 3.0, "output": 15.0},
 "claude-opus-4-6": {"input": 15.0, "output": 75.0},
 }
 
 def estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
 costs = self.model_costs.get(model, {"input": 5.0, "output": 15.0})
 return (input_tokens * costs["input"] + output_tokens * costs["output"]) / 1_000_000
 
 def complete(
 self,
 messages: list,
 model: str = "claude-sonnet-4-5",
 max_tokens: int = 1024,
 fallback_model: Optional[str] = "gpt-5-mini"
 ) -> str:
 # Check budget
 budget_remaining = self.monthly_budget - self.spent_this_month
 estimated_cost = self.estimate_cost(model, 2000, max_tokens) # rough estimate
 
 if budget_remaining < estimated_cost and fallback_model:
 print(f"Budget low, falling back to {fallback_model}")
 model = fallback_model
 
 response = client.chat.completions.create(
 model=model,
 messages=messages,
 max_tokens=max_tokens
 )
 
 # Track actual cost
 usage = response.usage
 actual_cost = self.estimate_cost(
 model, usage.prompt_tokens, usage.completion_tokens
 )
 self.spent_this_month += actual_cost
 
 return response.choices[0].message.content

# Usage
ai = BudgetAwareAI(monthly_budget_usd=30.0)

result = ai.complete(
 messages=[{"role": "user", "content": "Summarize this article: ..."}],
 model="claude-sonnet-4-5"
)

User Request
 ↓
Vercel Edge Function (free tier: 100K requests/day)
 ↓
Rate Limiting (Upstash Redis — free tier: 10K requests/day)
 ↓ 
Crazyrouter AI API (pay per use)
 ↓
Supabase DB (free tier: 500MB)
 ↓
Response to User

// pages/api/generate-post.ts (Next.js)
import { OpenAI } from 'openai';
import { createClient } from '@supabase/supabase-js';
import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

const client = new OpenAI({
 apiKey: process.env.CRAZYROUTER_API_KEY!,
 baseURL: 'https://crazyrouter.com/v1',
});

const supabase = createClient(
 process.env.SUPABASE_URL!,
 process.env.SUPABASE_SERVICE_KEY!
);

const ratelimit = new Ratelimit({
 redis: Redis.fromEnv(),
 limiter: Ratelimit.slidingWindow(10, '1 h'), // 10 posts/hour per user
});

export default async function handler(req, res) {
 const { userId, topic, tone, wordCount } = req.body;
 
 // Rate limiting (protect against abuse)
 const { success } = await ratelimit.limit(userId);
 if (!success) {
 return res.status(429).json({ error: 'Rate limit exceeded' });
 }
 
 // Check user's monthly quota
 const { data: user } = await supabase
 .from('users')
 .select('posts_generated, plan')
 .eq('id', userId)
 .single();
 
 const limits = { free: 5, pro: 100, business: 1000 };
 if (user.posts_generated >= limits[user.plan]) {
 return res.status(402).json({ error: 'Monthly limit reached — upgrade to continue' });
 }
 
 // Select model based on plan (cost optimization)
 const model = user.plan === 'business' ? 'claude-opus-4-6' :
 user.plan === 'pro' ? 'claude-sonnet-4-5' : 
 'gpt-5-mini'; // Free users get cheaper model
 
 try {
 const stream = await client.chat.completions.create({
 model,
 messages: [
 {
 role: 'system',
 content: `You are an expert content writer. Write in a ${tone} tone.`
 },
 {
 role: 'user',
 content: `Write a ${wordCount}-word blog post about: ${topic}`
 }
 ],
 stream: true,
 max_tokens: Math.ceil(wordCount * 1.5),
 });
 
 res.setHeader('Content-Type', 'text/event-stream');
 
 let fullContent = '';
 for await (const chunk of stream) {
 const delta = chunk.choices[0]?.delta?.content || '';
 fullContent += delta;
 res.write(`data: ${JSON.stringify({ content: delta })}\n\n`);
 }
 
 // Track usage
 await supabase
 .from('users')
 .update({ posts_generated: user.posts_generated + 1 })
 .eq('id', userId);
 
 // Save generated post
 await supabase.from('posts').insert({
 user_id: userId,
 topic,
 content: fullContent,
 model_used: model,
 });
 
 res.write('data: [DONE]\n\n');
 res.end();
 
 } catch (error) {
 return res.status(500).json({ error: 'Generation failed' });
 }
}

Free: 5 AI generations/month → Show the value
Pro ($19/month): 100 generations → Main revenue
Business ($99/month): 1,000 generations + API access

Break-even analysis:
- API costs at Pro tier (100 gen × ~500 tokens avg): ~$0.75/user
- Infrastructure per user (Vercel, Supabase): ~$0.30/user 
- Total cost: ~$1.05/user/month
- Revenue: $19/user/month
- Margin: ~94% at scale

def generate_with_limits(
 prompt: str,
 plan: str,
 max_tokens_by_plan: dict = {
 "free": 500,
 "pro": 2000,
 "business": 8000
 }
) -> str:
 """Apply output limits based on user's plan."""
 
 max_tokens = max_tokens_by_plan.get(plan, 500)
 model = "gpt-5-mini" if plan == "free" else "claude-sonnet-4-5"
 
 response = client.chat.completions.create(
 model=model,
 messages=[{"role": "user", "content": prompt}],
 max_tokens=max_tokens # Hard limit — protects your costs
 )
 
 return response.choices[0].message.content

import json
from datetime import datetime

class CostTracker:
 def __init__(self, db_client):
 self.db = db_client
 
 async def log_usage(
 self, 
 user_id: str, 
 model: str,
 input_tokens: int,
 output_tokens: int
 ):
 # Model pricing (approximate)
 prices = {
 "gpt-5-mini": (0.15, 0.60),
 "claude-sonnet-4-5": (3.0, 15.0),
 "claude-opus-4-6": (15.0, 75.0),
 }
 
 inp, out = prices.get(model, (3.0, 15.0))
 cost = (input_tokens * inp + output_tokens * out) / 1_000_000
 
 await self.db.table("usage_logs").insert({
 "user_id": user_id,
 "model": model,
 "input_tokens": input_tokens,
 "output_tokens": output_tokens,
 "cost_usd": cost,
 "created_at": datetime.utcnow().isoformat()
 })
 
 # Alert if daily spend exceeds threshold
 daily_spend = await self.get_daily_spend()
 if daily_spend > 5.0: # $5/day alert
 await self.send_alert(f"Daily AI spend: ${daily_spend:.2f}")