Building a Multi-Model AI Routing System: A Complete Technical Guide

Cost = (60% + 30% + 10%) × $1.20 input = $1.20/M tokens input 

Cost = (60% × $0.12) + (30% × $1.20) + (10% × $10.00) = $0.072 + $0.36 + $1.00 = $1.432/M tokens input 

Actual cost savings: 40-70% depending on your workload distribution 

┌─────────────┐ │ Application │ └──────┬──────┘ │ ▼ ┌─────────────────────┐ │ Request Analyzer │ ← Classify task complexity └──────┬──────────────┘ │ ▼ ┌─────────────────────┐ │ Routing Engine │ ← Select optimal model └──────┬──────────────┘ │ ▼ ┌─────────────────────┐ │ Provider Gateway │ ← Execute & handle failures └─────────────────────┘ 

interface RequestAnalysis { complexity: 'simple' | 'medium' | 'complex'; estimatedTokens: number; requiresReasoning: boolean; requiresCreativity: boolean; } function analyzeRequest(prompt: string, context?: string): RequestAnalysis { const tokenCount = estimateTokens(prompt + (context || '')); // Simple heuristics const hasComplexKeywords = /analyz|reason|explain|creative|design/i.test(prompt); const hasStructuredOutput = /json|format|structure/i.test(prompt); const isShortPrompt = tokenCount < 500; if (isShortPrompt && !hasComplexKeywords) { return { complexity: 'simple', estimatedTokens: tokenCount, requiresReasoning: false, requiresCreativity: false }; } if (hasComplexKeywords || tokenCount > 2000) { return { complexity: 'complex', estimatedTokens: tokenCount, requiresReasoning: true, requiresCreativity: /creative|design|story/i.test(prompt) }; } return { complexity: 'medium', estimatedTokens: tokenCount, requiresReasoning: hasStructuredOutput, requiresCreativity: false }; } 

interface ModelConfig { id: string; provider: string; costPerMToken: { input: number; output: number }; capabilities: { maxTokens: number; supportsStreaming: boolean; averageLatency: number; }; complexityScore: number; // 1-10 } const modelRegistry: ModelConfig[] = [ { id: 'deepseek-v3.2', provider: 'deepseek', costPerMToken: { input: 0.12, output: 0.23 }, capabilities: { maxTokens: 64000, supportsStreaming: true, averageLatency: 800 }, complexityScore: 3 }, { id: 'gpt-5.4', provider: 'openai', costPerMToken: { input: 1.20, output: 4.80 }, capabilities: { maxTokens: 128000, supportsStreaming: true, averageLatency: 1200 }, complexityScore: 7 }, { id: 'claude-opus-5.5', provider: 'anthropic', costPerMToken: { input: 10.00, output: 50.00 }, capabilities: { maxTokens: 200000, supportsStreaming: true, averageLatency: 1500 }, complexityScore: 10 } ]; function selectModel(analysis: RequestAnalysis, maxCost?: number): ModelConfig { const complexityMap = { simple: 3, medium: 6, complex: 9 }; const requiredScore = complexityMap[analysis.complexity]; // Filter models that meet requirements let candidates = modelRegistry.filter(m => m.complexityScore >= requiredScore && m.capabilities.maxTokens >= analysis.estimatedTokens ); // Apply cost constraints if specified if (maxCost) { candidates = candidates.filter(m => m.costPerMToken.input <= maxCost ); } // Select cheapest capable model return candidates.sort((a, b) => a.costPerMToken.input - b.costPerMToken.input )[0]; } 

interface ProviderResponse { content: string; model: string; tokensUsed: { input: number; output: number }; cost: number; } async function callProvider( model: ModelConfig, prompt: string, options: { temperature?: number; maxTokens?: number } = {} ): Promise<ProviderResponse> { const maxRetries = 3; let lastError: Error; for (let attempt = 0; attempt < maxRetries; attempt++) { try { const response = await fetch(`https://api.${model.provider}.com/v1/chat/completions`, { method: 'POST', headers: { 'Authorization': `Bearer ${process.env[`${model.provider.toUpperCase()}_API_KEY`]}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ model: model.id, messages: [{ role: 'user', content: prompt }], temperature: options.temperature || 0.7, max_tokens: options.maxTokens || 2000 }) }); if (!response.ok) { throw new Error(`Provider error: ${response.status}`); } const data = await response.json(); return { content: data.choices[0].message.content, model: model.id, tokensUsed: { input: data.usage.prompt_tokens, output: data.usage.completion_tokens }, cost: calculateCost(data.usage, model.costPerMToken) }; } catch (error) { lastError = error; console.warn(`Attempt ${attempt + 1} failed:`, error.message); if (attempt < maxRetries - 1) { await sleep(Math.pow(2, attempt) * 1000); // Exponential backoff } } } throw new Error(`All retries failed: ${lastError.message}`); } function calculateCost( usage: { prompt_tokens: number; completion_tokens: number }, costPerMToken: { input: number; output: number } ): number { return ( (usage.prompt_tokens / 1_000_000) * costPerMToken.input + (usage.completion_tokens / 1_000_000) * costPerMToken.output ); } 

export async function routeRequest( prompt: string, options: { context?: string; maxCost?: number; forceModel?: string; temperature?: number; } = {} ): Promise<ProviderResponse> { // Step 1: Analyze request const analysis = analyzeRequest(prompt, options.context); console.log('Request analysis:', analysis); // Step 2: Select model (or use forced model) const model = options.forceModel ? modelRegistry.find(m => m.id === options.forceModel)! : selectModel(analysis, options.maxCost); console.log('Selected model:', model.id); // Step 3: Call provider with retry logic try { const response = await callProvider(model, prompt, { temperature: options.temperature, maxTokens: analysis.estimatedTokens * 2 // Buffer for output }); console.log(`Cost: $${response.cost.toFixed(6)}`); return response; } catch (error) { // Step 4: Fallback to next available model console.error('Primary model failed, attempting fallback...'); const fallbackModel = selectFallbackModel(model, analysis); return await callProvider(fallbackModel, prompt, options); } } function selectFallbackModel( failedModel: ModelConfig, analysis: RequestAnalysis ): ModelConfig { // Select next cheapest model with higher complexity score return modelRegistry .filter(m => m.id !== failedModel.id && m.complexityScore >= failedModel.complexityScore ) .sort((a, b) => a.costPerMToken.input - b.costPerMToken.input)[0]; } 

const result = await routeRequest( 'Classify this email as spam or not spam: "Get rich quick with crypto!"' ); // → Uses DeepSeek-V3.2 ($0.12/M tokens) // → Cost: ~$0.000024 for 200 tokens 

const result = await routeRequest( 'Write a product description for a smart home thermostat with energy-saving features.' ); // → Uses GPT-5.4 ($1.20/M tokens) // → Cost: ~$0.00144 for 1200 tokens 

const result = await routeRequest( 'Analyze this research paper and explain the methodology, limitations, and potential real-world applications.', { context: researchPaperText } ); // → Uses Claude-Opus-5.5 ($10.00/M tokens) // → Cost: ~$0.08 for 8000 tokens 

const result = await routeRequest( 'Explain quantum computing in simple terms.', { maxCost: 0.50 } // Max $0.50 per million tokens ); // → Automatically selects DeepSeek-V3.2 // → Ensures cost stays under budget 

interface RoutingMetrics { totalRequests: number; costSavings: number; averageLatency: number; modelDistribution: Record<string, number>; } class MetricsCollector { private metrics: RoutingMetrics = { totalRequests: 0, costSavings: 0, averageLatency: 0, modelDistribution: {} }; track(response: ProviderResponse, analysis: RequestAnalysis) { this.metrics.totalRequests++; // Calculate what it would have cost with premium model const premiumCost = ( (response.tokensUsed.input / 1_000_000) * 10.00 + (response.tokensUsed.output / 1_000_000) * 50.00 ); this.metrics.costSavings += (premiumCost - response.cost); // Track model usage this.metrics.modelDistribution[response.model] = (this.metrics.modelDistribution[response.model] || 0) + 1; } getReport(): string { const avgSavingsPerRequest = this.metrics.costSavings / this.metrics.totalRequests; const savingsPercentage = (avgSavingsPerRequest / 0.08) * 100; // Assuming $0.08 baseline return ` Routing Performance Report ========================== Total Requests: ${this.metrics.totalRequests} Total Savings: $${this.metrics.costSavings.toFixed(2)} Savings per Request: $${avgSavingsPerRequest.toFixed(4)} (${savingsPercentage.toFixed(1)}%) Model Distribution: ${Object.entries(this.metrics.modelDistribution) .map(([model, count]) => ` ${model}: ${count} (${(count/this.metrics.totalRequests*100).toFixed(1)}%)`) .join('\n')} `.trim(); } } 

import { createHash } from 'crypto'; const cache = new Map<string, ProviderResponse>(); function getCacheKey(prompt: string,Source：https://dev.to/rolltok/building-a-multi-model-ai-routing-system-a-complete-technical-guide-3251
My favorites