feat: complete production-quality Model Router AI traffic control platform

2026-08-31 17:33:38 +05:30
commit 4e6f742272
66 changed files with 8969 additions and 0 deletions
@@ -0,0 +1,269 @@
+import sys
+import os
+import asyncio
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+
+# Set UTF-8 encoding support for Windows terminals
+if sys.platform.startswith("win"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
+
+from app.config.settings import get_settings
+from app.analyzer.heuristics import analyze_request_heuristics
+from app.router.engine import route_request
+from app.storage.database import init_db, AsyncSessionLocal
+from app.storage.models import ModelRecord, RoutingPolicyRecord
+from app.api.routes import db_model_to_meta
+from app.fallback.handler import execute_with_fallback
+from sqlalchemy import select
+
+app = typer.Typer(help="Model Router: Intelligent LLM Request Routing Platform")
+console = Console(safe_box=True)
+settings = get_settings()
+
+
+@app.command()
+def doctor():
+    """Run environment, connectivity, and dependency health checks."""
+    console.print(Panel.fit("[bold cyan]Model Router Diagnostics (modelrouter doctor)[/bold cyan]"))
+    
+    # 1. Python Check
+    py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    console.print(f" [green][OK][/green] Python: [bold]{py_ver}[/bold]")
+    
+    # 2. Database Check
+    try:
+        asyncio.run(init_db())
+        console.print(" [green][OK][/green] SQLite Database: [bold]Initialized & Ready[/bold]")
+    except Exception as exc:
+        console.print(f" [red][FAIL][/red] Database Error: {exc}")
+
+    # 3. Ollama Connectivity Check
+    ollama_ok = False
+    try:
+        r = httpx.get(f"{settings.OLLAMA_BASE_URL}/api/tags", timeout=1.5)
+        if r.status_code == 200:
+            models = [m.get("name") for m in r.json().get("models", [])]
+            console.print(f" [green][OK][/green] Ollama (Local): [bold]Connected[/bold] ({len(models)} local models found)")
+            ollama_ok = True
+    except Exception:
+        pass
+    if not ollama_ok:
+        console.print(f" [yellow][!][/yellow] Ollama (Local): [dim]Not running on {settings.OLLAMA_BASE_URL} (Optional, local fallback available)[/dim]")
+
+    # 4. Mock Engine
+    console.print(" [green][OK][/green] Mock Engine: [bold]Ready (Zero API keys required)[/bold]")
+
+    # 5. External Providers
+    if settings.OPENAI_API_KEY:
+        console.print(" [green][OK][/green] OpenAI Provider: [bold]API Key Configured in .env[/bold]")
+    else:
+        console.print(" [yellow][!][/yellow] OpenAI Provider: [dim]Not configured (Optional)[/dim]")
+
+    if settings.ANTHROPIC_API_KEY:
+        console.print(" [green][OK][/green] Anthropic Provider: [bold]API Key Configured in .env[/bold]")
+    else:
+        console.print(" [yellow][!][/yellow] Anthropic Provider: [dim]Not configured (Optional)[/dim]")
+
+    if settings.GEMINI_API_KEY:
+        console.print(" [green][OK][/green] Gemini Provider: [bold]API Key Configured in .env[/bold]")
+    else:
+        console.print(" [yellow][!][/yellow] Gemini Provider: [dim]Not configured (Optional)[/dim]")
+
+    console.print("\n[bold green]Ready for local-first intelligent routing![/bold green]\n")
+
+
+@app.command()
+def models():
+    """List all registered candidate models and their capability scores."""
+    async def _list():
+        await init_db()
+        async with AsyncSessionLocal() as db:
+            res = await db.execute(select(ModelRecord).order_by(ModelRecord.tier, ModelRecord.name))
+            records = res.scalars().all()
+            
+            table = Table(title="Model Router Registry", border_style="bright_blue")
+            table.add_column("Model ID", style="cyan", no_wrap=True)
+            table.add_column("Tier", style="magenta")
+            table.add_column("Provider", style="green")
+            table.add_column("Context", style="yellow")
+            table.add_column("Quality", style="blue")
+            table.add_column("Speed", style="cyan")
+            table.add_column("Cost / 1K In/Out", style="white")
+
+            for m in records:
+                cost_str = f"${m.cost_per_input_token*1000:.4f} / ${m.cost_per_output_token*1000:.4f}" if m.cost_per_input_token > 0 else "Free ($0)"
+                table.add_row(
+                    m.id,
+                    m.tier,
+                    m.provider,
+                    f"{m.context_window:,}",
+                    f"{m.quality_score*100:.0f}%",
+                    f"{m.speed_score*100:.0f}%",
+                    cost_str,
+                )
+            console.print(table)
+
+    asyncio.run(_list())
+
+
+@app.command()
+def route(
+    prompt: str = typer.Argument(..., help="Prompt text to route"),
+    policy: str = typer.Option("balanced", "--policy", "-p", help="Routing policy to use"),
+):
+    """Analyze prompt and explain why the optimal model was selected (Dry Run)."""
+    async def _route():
+        await init_db()
+        analysis = analyze_request_heuristics(prompt)
+        
+        async with AsyncSessionLocal() as db:
+            res_m = await db.execute(select(ModelRecord).filter_by(is_active=True))
+            models = [db_model_to_meta(m) for m in res_m.scalars().all()]
+            
+            res_p = await db.execute(select(RoutingPolicyRecord).filter_by(id=policy))
+            pol = res_p.scalar_one_or_none()
+            weights = {
+                "quality_weight": pol.quality_weight if pol else 0.35,
+                "cost_weight": pol.cost_weight if pol else 0.25,
+                "speed_weight": pol.speed_weight if pol else 0.20,
+                "capability_weight": pol.capability_weight if pol else 0.15,
+                "reliability_weight": pol.reliability_weight if pol else 0.05,
+            }
+
+            decision = route_request(
+                analysis=analysis,
+                available_models=models,
+                policy_weights=weights,
+                policy_name=policy,
+            )
+
+            console.print(Panel.fit(
+                f"[bold white]Prompt:[/bold white] \"{prompt}\"\n"
+                f"[bold cyan]Task Type:[/bold cyan] {analysis.task_type.value} | [bold cyan]Complexity:[/bold cyan] {analysis.complexity_label.value} ({analysis.complexity:.2f})\n"
+                f"[bold green]Selected Model:[/bold green] [bold yellow]{decision.selected_model_name}[/bold yellow] ({decision.selected_model})\n"
+                f"[bold magenta]Confidence:[/bold magenta] {decision.confidence * 100:.0f}%\n"
+                f"[bold blue]Estimated Latency:[/bold blue] {decision.estimated_latency_ms:.0f}ms | [bold blue]Estimated Cost:[/bold blue] ${decision.estimated_cost_usd:.6f}",
+                title="ROUTING DECISION",
+                border_style="bright_blue",
+            ))
+
+            console.print("[bold cyan]Why this model?[/bold cyan]")
+            for r in decision.reasons:
+                console.print(f"  [green]+[/green] {r}")
+
+            if decision.rejected_candidates:
+                console.print("\n[bold red]Rejected Candidates:[/bold red]")
+                for cid, reason in decision.rejected_candidates.items():
+                    console.print(f"  [dim]- {cid}: {reason}[/dim]")
+
+    asyncio.run(_route())
+
+
+@app.command()
+def run(
+    prompt: str = typer.Argument(..., help="Prompt to route and execute"),
+    policy: str = typer.Option("balanced", "--policy", "-p", help="Routing policy to use"),
+):
+    """Route request and execute inference through the chosen provider."""
+    async def _run():
+        await init_db()
+        analysis = analyze_request_heuristics(prompt)
+        
+        async with AsyncSessionLocal() as db:
+            res_m = await db.execute(select(ModelRecord).filter_by(is_active=True))
+            models = [db_model_to_meta(m) for m in res_m.scalars().all()]
+            
+            decision = route_request(
+                analysis=analysis,
+                available_models=models,
+                policy_weights={"quality_weight": 0.35, "cost_weight": 0.25, "speed_weight": 0.20, "capability_weight": 0.15, "reliability_weight": 0.05},
+                policy_name=policy,
+            )
+
+            console.print(f"[bold cyan]Routing to:[/bold cyan] {decision.selected_model} via provider: {decision.provider}...")
+            
+            resp, fallback_used, orig_m, fb_reason = await execute_with_fallback(
+                prompt=prompt,
+                selected_model_id=decision.selected_model,
+                selected_provider_id=decision.provider,
+                all_models=models,
+            )
+
+            console.print(Panel(
+                resp.content,
+                title=f"RESPONSE from {resp.model} ({'FALLBACK: ' + orig_m if fallback_used else 'PRIMARY'})",
+                subtitle=f"Latency: {resp.provider_latency_ms:.0f}ms | Tokens: {resp.total_tokens}",
+                border_style="green" if not fallback_used else "yellow",
+            ))
+
+    asyncio.run(_run())
+
+
+@app.command()
+def traffic(limit: int = 10):
+    """View recent routed traffic log."""
+    async def _traffic():
+        await init_db()
+        from app.storage.models import RequestRecord
+        from sqlalchemy import desc
+        async with AsyncSessionLocal() as db:
+            res = await db.execute(select(RequestRecord).order_by(desc(RequestRecord.timestamp)).limit(limit))
+            records = res.scalars().all()
+            
+            table = Table(title="Recent Routed Traffic Feed", border_style="bright_blue")
+            table.add_column("Time", style="dim")
+            table.add_column("Task", style="cyan")
+            table.add_column("Selected Model", style="green")
+            table.add_column("Latency", style="yellow")
+            table.add_column("Cost", style="magenta")
+            table.add_column("Prompt Sample", style="white")
+
+            for r in records:
+                t_str = r.timestamp.strftime("%H:%M:%S") if r.timestamp else "N/A"
+                table.add_row(
+                    t_str,
+                    r.task_type,
+                    r.selected_model,
+                    f"{r.total_latency_ms:.0f}ms",
+                    f"${r.estimated_cost:.5f}",
+                    r.prompt[:40] + ("..." if len(r.prompt) > 40 else ""),
+                )
+            console.print(table)
+
+    asyncio.run(_traffic())
+
+
+@app.command()
+def analytics():
+    """Display system-wide routing performance and cost savings analytics."""
+    async def _analytics():
+        await init_db()
+        from app.analytics.service import get_system_analytics
+        async with AsyncSessionLocal() as db:
+            data = await get_system_analytics(db)
+            console.print(Panel.fit(
+                f"[bold cyan]Total Routed Requests:[/bold cyan] {data['total_requests']}\n"
+                f"[bold green]Average Latency:[/bold green] {data['avg_latency_ms']}ms (Routing overhead: {data['avg_routing_latency_ms']}ms)\n"
+                f"[bold yellow]Total Cost:[/bold yellow] ${data['total_cost_usd']:.6f}\n"
+                f"[bold magenta]Cost Saved vs Baseline:[/bold magenta] ${data['savings']['cost_saved_usd']:.6f} ({data['savings']['savings_percentage']}%)\n"
+                f"[bold blue]Fallback Rate:[/bold blue] {data['fallback_rate_percent']}%\n",
+                title="MODEL ROUTER ANALYTICS OVERVIEW",
+                border_style="bright_blue",
+            ))
+
+    asyncio.run(_analytics())
+
+
+if __name__ == "__main__":
+    app()