adaptive-memory-multi-model-router 2.14.46 → 2.14.47

package/examples/whatsapp-telegram-bridge.js

@@ -1,269 +0,0 @@
-#!/usr/bin/env node
-/**
- * WhatsApp ↔ Telegram Bridge Example
- * 
- * This example shows how to use a Telegram bot to process
- * WhatsApp messages and send replies back.
- * 
- * Prerequisites:
- * 1. WhatsApp Business API credentials (phoneNumberId, accessToken)
- * 2. Telegram Bot Token (from @BotFather)
- * 3. Webhook endpoint to receive WhatsApp messages
- * 
- * Usage:
- *   node whatsapp-telegram-bridge.js
- */
-
-const { 
-  createIntegration,
-  WhatsAppIntegration,
-  TelegramIntegration,
-  createA3MRouter 
-} = require('../dist/index.js');
-
-// Configuration
-const CONFIG = {
-  whatsapp: {
-    phoneNumberId: process.env.WHATSAPP_PHONE_NUMBER_ID,
-    accessToken: process.env.WHATSAPP_ACCESS_TOKEN,
-  },
-  telegram: {
-    botToken: process.env.TELEGRAM_BOT_TOKEN,
-    // The chat ID where your bot will process messages
-    // This could be your personal chat with the bot
-    chatId: process.env.TELEGRAM_CHAT_ID,
-  },
-};
-
-// Validate config
-function validateConfig() {
-  const missing = [];
-  if (!CONFIG.whatsapp.phoneNumberId) missing.push('WHATSAPP_PHONE_NUMBER_ID');
-  if (!CONFIG.whatsapp.accessToken) missing.push('WHATSAPP_ACCESS_TOKEN');
-  if (!CONFIG.telegram.botToken) missing.push('TELEGRAM_BOT_TOKEN');
-  if (!CONFIG.telegram.chatId) missing.push('TELEGRAM_CHAT_ID');
-  
-  if (missing.length > 0) {
-    console.error('❌ Missing environment variables:');
-    missing.forEach(v => console.error(`   - ${v}`));
-    console.error('\nSet these variables and try again.');
-    process.exit(1);
-  }
-}
-
-/**
- * WhatsApp → Telegram Bridge
- * 
- * Flow:
- * 1. Receive message from WhatsApp (via webhook)
- * 2. Forward message to Telegram bot
- * 3. Get reply from Telegram (bot processes it)
- * 4. Send reply back to WhatsApp user
- */
-class WhatsAppTelegramBridge {
-  constructor(config) {
-    this.whatsapp = new WhatsAppIntegration(
-      config.whatsapp.phoneNumberId,
-      config.whatsapp.accessToken
-    );
-    this.telegram = new TelegramIntegration(config.telegram.botToken);
-    this.telegramChatId = config.telegram.chatId;
-    
-    // A3M Router for intelligent routing
-    this.router = createA3MRouter();
-    
-    // Message tracking
-    this.pendingReplies = new Map(); // messageId -> { whatsappUser, timestamp }
-  }
-
-  /**
-   * Handle incoming WhatsApp message
-   * @param {Object} whatsappMessage - WhatsApp webhook payload
-   */
-  async handleWhatsAppMessage(whatsappMessage) {
-    try {
-      // Extract message details
-      const entry = whatsappMessage.entry?.[0];
-      const change = entry?.changes?.[0];
-      const value = change?.value;
-      const message = value?.messages?.[0];
-      
-      if (!message) {
-        console.log('No message in webhook payload');
-        return;
-      }
-
-      const from = message.from; // WhatsApp user phone number
-      const text = message.text?.body || '';
-      const messageId = message.id;
-
-      console.log(`📩 WhatsApp message from ${from}: "${text.substring(0, 50)}..."`);
-
-      // Route the message to get best processing strategy
-      const route = this.router.route(text);
-      console.log(`🔀 Routed to: ${route.primary_model} (${route.reasoning})`);
-
-      // Forward to Telegram bot with context
-      const telegramMessage = await this.forwardToTelegram(from, text, route);
-      
-      // Track pending reply
-      this.pendingReplies.set(telegramMessage.messageId, {
-        whatsappUser: from,
-        originalText: text,
-        timestamp: Date.now(),
-      });
-
-      console.log(`📤 Forwarded to Telegram (message ID: ${telegramMessage.messageId})`);
-
-    } catch (error) {
-      console.error('❌ Error handling WhatsApp message:', error.message);
-    }
-  }
-
-  /**
-   * Forward WhatsApp message to Telegram
-   */
-  async forwardToTelegram(whatsappUser, text, route) {
-    // Format message for Telegram bot
-    const formattedMessage = `
-🔄 <b>WhatsApp Bridge</b>
-📱 <b>From:</b> ${whatsappUser}
-🤖 <b>Route:</b> ${route.primary_model}
-
-💬 <b>Message:</b>
-${text}
-
-<i>Reply to this message to respond back to WhatsApp user</i>
-    `.trim();
-
-    // Send to Telegram
-    const result = await this.telegram.sendMessage(
-      this.telegramChatId,
-      formattedMessage
-    );
-
-    return {
-      messageId: result.message_id || `msg_${Date.now()}`,
-      chatId: this.telegramChatId,
-    };
-  }
-
-  /**
-   * Handle Telegram reply
-   * @param {Object} telegramUpdate - Telegram webhook/update payload
-   */
-  async handleTelegramReply(telegramUpdate) {
-    try {
-      const message = telegramUpdate.message || telegramUpdate.callback_query?.message;
-      if (!message) return;
-
-      const replyToMessage = message.reply_to_message;
-      if (!replyToMessage) {
-        console.log('Not a reply message, ignoring');
-        return;
-      }
-
-      // Extract original message ID from reply
-      const originalMessageId = replyToMessage.message_id;
-      const pending = this.pendingReplies.get(originalMessageId);
-
-      if (!pending) {
-        console.log('No pending WhatsApp reply found for this message');
-        return;
-      }
-
-      const replyText = message.text || message.caption || '';
-      console.log(`📩 Telegram reply: "${replyText.substring(0, 50)}..."`);
-
-      // Send reply back to WhatsApp
-      await this.sendWhatsAppReply(pending.whatsappUser, replyText);
-
-      // Clean up pending reply
-      this.pendingReplies.delete(originalMessageId);
-
-    } catch (error) {
-      console.error('❌ Error handling Telegram reply:', error.message);
-    }
-  }
-
-  /**
-   * Send reply back to WhatsApp user
-   */
-  async sendWhatsAppReply(to, text) {
-    const result = await this.whatsapp.sendMessage(to, text);
-    console.log(`📤 Sent WhatsApp reply to ${to}: "${text.substring(0, 50)}..."`);
-    return result;
-  }
-
-  /**
-   * Clean up old pending replies (older than 1 hour)
-   */
-  cleanupPendingReplies() {
-    const now = Date.now();
-    const oneHour = 60 * 60 * 1000;
-    
-    for (const [messageId, pending] of this.pendingReplies) {
-      if (now - pending.timestamp > oneHour) {
-        this.pendingReplies.delete(messageId);
-        console.log(`🧹 Cleaned up expired pending reply: ${messageId}`);
-      }
-    }
-  }
-
-  /**
-   * Start cleanup interval
-   */
-  startCleanup() {
-    setInterval(() => this.cleanupPendingReplies(), 5 * 60 * 1000); // Every 5 minutes
-  }
-}
-
-// Example usage
-async function main() {
-  validateConfig();
-
-  console.log('🚀 Starting WhatsApp ↔ Telegram Bridge\n');
-
-  const bridge = new WhatsAppTelegramBridge(CONFIG);
-  bridge.startCleanup();
-
-  console.log('✅ Bridge initialized');
-  console.log(`   WhatsApp Phone Number ID: ${CONFIG.whatsapp.phoneNumberId}`);
-  console.log(`   Telegram Chat ID: ${CONFIG.telegram.chatId}`);
-  console.log('');
-
-  // Example: Simulate receiving a WhatsApp message
-  console.log('📋 Example: Simulating WhatsApp webhook payload\n');
-  
-  const exampleWhatsAppMessage = {
-    entry: [{
-      changes: [{
-        value: {
-          messages: [{
-            from: '1234567890',
-            id: 'wamid.example123',
-            text: { body: 'Hello, I need help with my order #12345' },
-            timestamp: Date.now().toString(),
-          }],
-        },
-      }],
-    }],
-  };
-
-  await bridge.handleWhatsAppMessage(exampleWhatsAppMessage);
-
-  console.log('\n📋 To use this in production:');
-  console.log('   1. Set up WhatsApp Business API webhook');
-  console.log('   2. Set up Telegram bot webhook');
-  console.log('   3. Route webhooks to handleWhatsAppMessage() and handleTelegramReply()');
-  console.log('');
-  console.log('📖 See: https://developers.facebook.com/docs/whatsapp/cloud-api/guides/set-up-webhooks');
-  console.log('📖 See: https://core.telegram.org/bots/webhooks');
-}
-
-// Run if executed directly
-if (require.main === module) {
-  main().catch(console.error);
-}
-
-module.exports = { WhatsAppTelegramBridge };

package/hf-space/README.md

@@ -1,23 +0,0 @@
----
-title: A3M Router Demo
-emoji: 🔀
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.34.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: '#1 LLM routing benchmark & cheapest router with memory'
----
-
-# 🔀 A3M Router — #1 LLM Routing Benchmark & Cheapest Router with Memory
-
-See how parallel LLM execution works in real-time. Enter a query and watch 7 providers compete simultaneously.
-
-- 🏆 **#1 on RouterArena** (70.32 score)
-- 💰 **Cheapest** at $0.047/1K queries
-- 🔓 **Open-source** (MIT), 19.5KB
-- 🧠 **Only LLM router with memory**
-
-[Try it live →](https://github.com/Das-rebel/a3m-router)

package/hf-space/app.py

@@ -1,240 +0,0 @@
-import gradio as gr
-import json
-import time
-import os
-import random
-
-# A3M Router Demo - Live Parallel LLM Execution Visualization
-# No API keys needed - uses simulated responses for the demo
-
-PROVIDERS = [
-    ("OpenAI/GPT-4o-mini", 0.00015, 0.85),
-    ("Anthropic/Claude-3.5-Haiku", 0.00025, 0.83),
-    ("Groq/Llama-3.3-70B", 0.000059, 0.82),
-    ("DeepSeek/Chat", 0.000014, 0.79),
-    ("NVIDIA/Llama-3.3-70B", 0.00022, 0.84),
-    ("Together/Mistral-7B", 0.000018, 0.76),
-    ("OpenRouter/Auto", 0.000030, 0.80),
-]
-
-BENCHMARK_DATA = [
-    ("A3M Router 🥇", 76.43, 0.047, True),
-    ("Sqwish 🥈", 75.27, 0.18, False),
-    ("Azure (Microsoft) 🥉", 71.87, 0.22, False),
-    ("GPT-5 (OpenAI)", 64.32, 10.02, False),
-    ("RouteLLM (Berkeley)", 48.07, 0.27, True),
-]
-
-SAMPLE_RESPONSES = {
-    "hello": "Hello! I'm here to help. What would you like to know?",
-    "what is machine learning": "Machine learning is a subset of AI where algorithms learn patterns from data to make predictions, without being explicitly programmed for each task.",
-    "explain quantum computing": "Quantum computing uses quantum mechanical phenomena like superposition and entanglement to perform computations exponentially faster than classical computers for specific problems.",
-    "write a python sort": "def quicksort(arr):\n    if len(arr) <= 1: return arr\n    pivot = arr[len(arr)//2]\n    left = [x for x in arr if x < pivot]\n    right = [x for x in arr if x > pivot]\n    return quicksort(left) + [pivot] + quicksort(right)",
-}
-
-def simulate_routing(query, strategy):
-    """Simulate parallel LLM routing with confidence scoring."""
-    if not query.strip():
-        return "", "", "", ""
-    
-    start = time.time()
-    
-    # Find best matching sample response
-    response_base = SAMPLE_RESPONSES.get("what is machine learning")  # default
-    for key in SAMPLE_RESPONSES:
-        if key in query.lower():
-            response_base = SAMPLE_RESPONSES[key]
-            break
-    
-    # Simulate parallel execution
-    results = []
-    for provider, cost, base_conf in PROVIDERS:
-        latency = round(random.uniform(80, 350), 0)
-        # Add confidence variation
-        conf = round(base_conf + random.uniform(-0.05, 0.05), 2)
-        conf = min(max(conf, 0.5), 0.99)
-        results.append({
-            "provider": provider,
-            "response": response_base[:60] + "...",
-            "latency_ms": int(latency),
-            "confidence": conf,
-            "cost": cost,
-            "winner": False
-        })
-    
-    # Sort by confidence (A3M's strategy)
-    results.sort(key=lambda x: x["confidence"], reverse=True)
-    results[0]["winner"] = True
-    
-    winner = results[0]
-    total_cost = winner["cost"]
-    total_latency = max(r["latency_ms"] for r in results)  # Parallel = max
-    elapsed = round((time.time() - start) * 1000, 0)
-    
-    # Format results table
-    table = "| Provider | Confidence | Latency | Cost |\n|----------|-----------|---------|------|\n"
-    for r in results:
-        icon = "🏆" if r["winner"] else ""
-        table += f"| {icon} {r['provider']} | {r['confidence']:.0%} | {r['latency_ms']}ms | ${r['cost']:.6f} |\n"
-    
-    # Summary
-    summary = f"### 🏆 Winner: **{winner['provider']}**\n\n"
-    summary += f"- **Confidence:** {winner['confidence']:.0%}\n"
-    summary += f"- **Cost:** ${winner['cost']:.6f}\n"
-    summary += f"- **Total parallel latency:** {total_latency}ms\n"
-    summary += f"- **Strategy:** {strategy}\n\n"
-    summary += f"You got the **best response at the lowest cost** because all providers ran in parallel."
-    
-    # Cost comparison
-    gpt5_cost = 10.02 / 1000
-    savings = round(gpt5_cost / winner["cost"]) if winner["cost"] > 0 else 999
-    cost_text = f"### 💰 Cost vs Sequential Fallback\n\n"
-    cost_text += f"| Approach | Cost | Latency |\n|----------|------|----------|\n"
-    cost_text += f"| **A3M (parallel)** | **${winner['cost']:.6f}** | **{total_latency}ms** |\n"
-    cost_text += f"| Sequential (3 retries) | ${total_cost * 3:.6f} | {total_latency * 3}ms |\n"
-    cost_text += f"| GPT-5 (OpenAI) | ${gpt5_cost:.4f} | ~500ms |\n\n"
-    cost_text += f"**{savings}× cheaper** than calling GPT-5 directly.\n"
-    
-    return table, summary, cost_text, json.dumps(results, indent=2)
-
-def generate_benchmark():
-    """Generate benchmark comparison chart."""
-    chart_data = gr.Dataframe(
-        value=[[r[0], r[1], f"${r[2]}"] for r in BENCHMARK_DATA],
-        headers=["Router", "RouterArena Score", "Cost/1K"],
-        label="RouterArena Benchmark Results (arXiv:2510.00202)"
-    )
-    return chart_data
-
-with gr.Blocks(
-    theme=gr.themes.Soft(primary_hue="green"),
-    css="""
-        .winner-row { background-color: #1a3a1a !important; }
-        footer { display: none !important; }
-    """
-) as demo:
-    gr.Markdown("""
-    # 🔀 A3M Router — #1 LLM Routing Benchmark & Cheapest Router with Memory
-    
-    **See how parallel LLM execution works in real-time.** Enter a query and watch 7 providers compete simultaneously.
-    
-    ⭐ RouterArena #1 (76.43) | 💰 Cheapest at $0.047/1K | 🔓 Open-source (MIT) | 📦 19.5KB
-    """)
-    
-    with gr.Tab("🚀 Try It"):
-        with gr.Row():
-            query = gr.Textbox(
-                label="Your Query",
-                placeholder="Try: explain quantum computing, what is machine learning, write a python sort...",
-                scale=4
-            )
-            strategy = gr.Dropdown(
-                choices=["parallel (A3M default)", "fastest", "creative", "deep"],
-                value="parallel (A3M default)",
-                label="Strategy",
-                scale=1
-            )
-        submit = gr.Button("🚀 Execute Parallel Routing", variant="primary", size="lg")
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                results_table = gr.Markdown(label="Results")
-            with gr.Column(scale=1):
-                summary = gr.Markdown(label="Best Result")
-        
-        with gr.Row():
-            cost_comparison = gr.Markdown(label="Cost Savings")
-        
-        with gr.Accordion("Raw JSON Output", open=False):
-            raw_output = gr.JSON()
-        
-        gr.Examples(
-            examples=[["Explain quantum computing"], ["What is machine learning?"], ["Write a Python sort function"], ["Hello, how are you?"]],
-            inputs=query
-        )
-        
-        submit.click(
-            fn=simulate_routing,
-            inputs=[query, strategy],
-            outputs=[results_table, summary, cost_comparison, raw_output]
-        )
-    
-    with gr.Tab("📊 Benchmark"):
-        gr.Markdown("""
-        ### RouterArena Benchmark Results
-        
-        | Rank | Router | Score | Cost/1K | Open Source? |
-        |------|--------|:-----:|:-------:|:------------:|
-        | 🥇 | **A3M Router** | **76.43** | **$0.047** | ✅ |
-        | 🥈 | Sqwish | 75.27 | $0.18 | ❌ |
-        | 🥉 | Azure (Microsoft) | 71.87 | $0.22 | ❌ |
-        | 4 | GPT-5 (OpenAI) | 64.32 | $10.02 | ❌ |
-        | 5 | RouteLLM (Berkeley) | 48.07 | $0.27 | ✅ |
-        
-        **213× cheaper than GPT-5, 12 points higher.** Evaluated by RouterArena (arXiv:2510.00202) on 8,400 queries across 9 domains.
-        
-        [Full Benchmark →](https://das-rebel.github.io/a3m-router/benchmark) | [RouterArena PR →](https://github.com/RouteWorks/RouterArena/pull/113)
-        """)
-    
-    with gr.Tab("💻 Code"):
-        gr.Markdown("""
-        ### Install & Run in 5 Seconds
-        
-        ```bash
-        # No config needed — auto-detects API keys from environment
-        npm install adaptive-memory-multi-model-router
-        npx a3m-router route "Explain quantum computing"
-        ```
-        
-        ### TypeScript/Node.js
-        
-        ```javascript
-        import { createRouter } from 'adaptive-memory-multi-model-router';
-        
-        const router = createRouter(); // auto-detects API keys
-        
-        // Parallel execution with confidence scoring
-        const result = await router.route('What is machine learning?');
-        
-        console.log(result.response);    // Best response
-        console.log(result.provider);    // Winning provider
-        console.log(result.cost);        // Actual cost
-        console.log(result.confidence);  // Confidence score
-        ```
-        
-        ### With Memory (Unique Feature)
-        
-        ```javascript
-        const router = createRouter({
-          memory: { enabled: true }  // Context persists across sessions
-        });
-        
-        await router.route('My name is Alice');
-        await router.route('What is my name?');  // → "Your name is Alice!"
-        ```
-        
-        ### CLI
-        
-        ```bash
-        # Route a query
-        npx a3m-router route "Explain quantum computing"
-        
-        # Check costs
-        npx a3m-router cost
-        
-        # Health check
-        npx a3m-router health
-        ```
-        
-        [GitHub →](https://github.com/Das-rebel/a3m-router) | [npm →](https://www.npmjs.com/package/adaptive-memory-multi-model-router) | [Docs →](https://das-rebel.github.io/a3m-router/)
-        """)
-    
-    gr.Markdown("""
-    ---
-    🔀 A3M Router — #1 LLM Routing Benchmark & Cheapest Router with Memory | [GitHub](https://github.com/Das-rebel/a3m-router) | [npm](https://www.npmjs.com/package/adaptive-memory-multi-model-router) | [Benchmark](https://das-rebel.github.io/a3m-router/benchmark)
-    
-    *This demo simulates parallel LLM execution. In production, A3M makes real API calls to 47+ providers.*
-    """)
-
-if __name__ == "__main__":
-    demo.launch()

package/hf-space/requirements.txt

@@ -1 +0,0 @@
-gradio>=4.0.0

package/huggingface_space/README.md

@@ -1,35 +0,0 @@
----
-title: A3M Router Demo
-emoji: 🎯
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 4.44.0
-app_file: app.py
-pinned: false
----
-
-# A3M Router Demo
-
-[A3M Router](https://github.com/Das-rebel/a3m-router) — #1 LLM routing benchmark at $0.047/1K queries.
-
-This Space demonstrates intelligent LLM routing using 12 keyword signals.
-
-## Features
-
-- **Instant Routing**: <1ms routing decision
-- **47+ Providers**: OpenAI, Anthropic, Groq, Cerebras, DeepSeek, Gemini, Mistral...
-- **Cost Saving**: Routes to cheapest capable model
-- **No ML Required**: Rule-based heuristic routing
-
-## How It Works
-
-1. Enter your query
-2. A3M analyzes 12 keyword signals
-3. Routes to optimal provider based on query complexity
-4. Get fast, cost-effective responses
-
-## Disclaimer
-
-This demo uses a local A3M Router instance. For production use, 
-deploy your own router or use the npm package.

package/huggingface_space/app.py

@@ -1,126 +0,0 @@
-import gradio as gr
-import json
-import time
-
-# Simulated routing decisions (in production, use actual A3M Router API)
-ROUTING_RULES = {
-    "greeting": {"model": "groq/llama-3.3-70b", "tier": "free", "cost": 0.00001},
-    "code": {"model": "groq/llama-3.3-70b", "tier": "cheap", "cost": 0.0004},
-    "math": {"model": "deepseek/deepseek-chat", "tier": "cheap", "cost": 0.0003},
-    "creative": {"model": "anthropic/claude-3-haiku", "tier": "mid", "cost": 0.001},
-    "reasoning": {"model": "openai/gpt-4o-mini", "tier": "mid", "cost": 0.0015},
-    "default": {"model": "groq/llama-3.3-70b", "tier": "cheap", "cost": 0.0004}
-}
-
-def route_query(query):
-    """Route a query to the optimal provider"""
-    query_lower = query.lower()
-    
-    # Simple keyword matching
-    if any(word in query_lower for word in ["hi", "hello", "hey", "thanks"]):
-        result = ROUTING_RULES["greeting"]
-        reasoning = "Simple greeting detected → free tier"
-    elif any(word in query_lower for word in ["code", "python", "javascript", "function", "bug"]):
-        result = ROUTING_RULES["code"]
-        reasoning = "Coding task detected → cheap tier (Groq)"
-    elif any(word in query_lower for word in ["math", "calculate", "equation", "solve for"]):
-        result = ROUTING_RULES["math"]
-        reasoning = "Mathematical query → cheap tier (DeepSeek)"
-    elif any(word in query_lower for word in ["write", "story", "poem", "creative"]):
-        result = ROUTING_RULES["creative"]
-        reasoning = "Creative task → mid tier (Claude Haiku)"
-    elif any(word in query_lower for word in ["explain", "why", "how", "what is"]):
-        result = ROUTING_RULES["reasoning"]
-        reasoning = "Explanation needed → mid tier (GPT-4o mini)"
-    else:
-        result = ROUTING_RULES["default"]
-        reasoning = "General query → cheap tier (Groq)"
-    
-    # Simulate routing time
-    routing_time = round(time.time() % 1 * 10, 2)  # 0-10ms simulated
-    
-    return {
-        "model": result["model"],
-        "tier": result["tier"],
-        "estimated_cost": f"${result['cost']:.6f}",
-        "routing_time_ms": routing_time,
-        "reasoning": reasoning
-    }
-
-def explain_routing():
-    """Return explanation of A3M Router"""
-    return """
-## How A3M Router Works
-
-### 12 Keyword Signals
-A3M analyzes queries across 5 dimensions:
-1. **Domain**: coding, math, creative, factual
-2. **Complexity**: simple, medium, hard  
-3. **Intent**: debug, explain, create, compare
-4. **Length**: short, medium, long
-5. **Structure**: structured, unstructured
-
-### Provider Tiers
-| Tier | Providers | Cost/1K |
-|------|-----------|----------|
-| Free | Groq, Together | $0 |
-| Cheap | Mistral, DeepSeek | $0.001-0.01 |
-| Mid | Claude Haiku, GPT-4o mini | $0.01-0.05 |
-| Premium | GPT-4o, Claude 3.5 | $0.50+ |
-
-### Benchmark Results
-- **RouterArena Score**: 76.43 (#1 of 19 routers)
-- **Cost/1K queries**: $0.047
-- **vs GPT-5**: 213× cheaper
-"""
-
-# Examples for Gradio
-EXAMPLES = [
-    ["Hi, how are you?"],
-    ["Write a Python function to sort a list"],
-    ["Explain quantum entanglement"],
-    ["Solve for x: 2x + 5 = 15"],
-    ["Write a haiku about coding"],
-]
-
-# Build Gradio interface
-with gr.Blocks(title="A3M Router Demo", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎯 A3M Router Demo")
-    gr.Markdown("### #1 LLM Routing Benchmark — $0.047/1K — 213× cheaper than GPT-5")
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            query_input = gr.Textbox(
-                label="Enter your query",
-                placeholder="e.g., Explain machine learning...",
-                lines=3
-            )
-            route_btn = gr.Button("Route Query", variant="primary")
-            
-        with gr.Column(scale=1):
-            output_info = gr.JSON(label="Routing Decision")
-    
-    gr.Examples(EXAMPLES, inputs=[query_input], label="Try these examples")
-    
-    route_btn.click(
-        fn=route_query,
-        inputs=[query_input],
-        outputs=[output_info]
-    )
-    
-    query_input.submit(
-        fn=route_query,
-        inputs=[query_input],
-        outputs=[output_info]
-    )
-    
-    gr.Markdown(explain_routing())
-    
-    gr.Markdown("""
----
-📚 **Learn more**: [GitHub](https://github.com/Das-rebel/a3m-router) | 
-[npm](https://www.npmjs.com/package/adaptive-memory-multi-model-router) |
-[RouterArena](https://arxiv.org/abs/2510.00202)
-""")
-
-demo.launch()