Multi-Model Strategies: Routing, Fallbacks, and Cost Tiers

from dataclasses import dataclass
from enum import Enum

class Complexity(Enum):
  SIMPLE = "simple"
  MODERATE = "moderate"  
  COMPLEX = "complex"

@dataclass
class RoutingDecision:
  complexity: Complexity
  model: str
  reason: str
  estimated_cost_per_1k: float

def classify_complexity(query: str) -> Complexity:
  """Simple heuristic-based classifier (replace with ML model in production)."""
  query_lower = query.lower()
  
  # Simple signals
  simple_patterns = ["is this", "does this", "yes or no", "classify", "extract the", "what is the"]
  if any(p in query_lower for p in simple_patterns) and len(query.split()) < 20:
      return Complexity.SIMPLE
  
  # Complex signals  
  complex_patterns = ["analyze", "compare", "explain why", "design", "write a", "reasoning", "evaluate"]
  word_count = len(query.split())
  if any(p in query_lower for p in complex_patterns) or word_count > 80:
      return Complexity.COMPLEX
  
  return Complexity.MODERATE

def route_query(query: str) -> RoutingDecision:
  """Route a query to the appropriate model tier."""
  complexity = classify_complexity(query)
  
  routing_map = {
      Complexity.SIMPLE: RoutingDecision(
          complexity=complexity,
          model="gpt-4o-mini",
          reason="Simple classification/extraction task",
          estimated_cost_per_1k=0.00015
      ),
      Complexity.MODERATE: RoutingDecision(
          complexity=complexity,
          model="gpt-4o",
          reason="Moderate complexity, standard model sufficient",
          estimated_cost_per_1k=0.0025
      ),
      Complexity.COMPLEX: RoutingDecision(
          complexity=complexity,
          model="gpt-4o",  # or claude-opus for specific use cases
          reason="Complex reasoning requires premium model",
          estimated_cost_per_1k=0.015
      ),
  }
  return routing_map[complexity]

# Test the router
test_queries = [
  "Is this email spam? 'Congratulations you won!'",
  "Summarize this 500-word article about renewable energy",
  "Analyze the trade-offs between microservices and monolith architectures for a 10-person startup",
]

for query in test_queries:
  decision = route_query(query)
  savings = (0.015 - decision.estimated_cost_per_1k) / 0.015 * 100
  print(f"Query: {query[:60]}...")
  print(f"  → {decision.model} ({decision.complexity.value})")
  print(f"  → Reason: {decision.reason}")
  print(f"  → Cost savings vs premium: {savings:.0f}%")
  print()