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

package/huggingface_space/create_space.py

@@ -1,208 +0,0 @@
-#!/usr/bin/env python3
-"""
-Create a minimal HuggingFace Space for A3M Router demo
-
-This creates the files needed for a Gradio-based HuggingFace Space
-that demonstrates A3M Router's routing capabilities.
-"""
-
-import os
-
-SPACE_DIR = '/Users/Subho/adaptive-memory-multi-model-router/huggingface_space'
-
-os.makedirs(SPACE_DIR, exist_ok=True)
-
-# Create README.md for the Space
-README_CONTENT = '''---
-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.
-'''
-
-# Create app.py
-APP_PY = '''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()
-'''
-
-# Create requirements.txt
-REQS = '''gradio>=4.0.0
-'''
-
-# Create README
-with open(os.path.join(SPACE_DIR, 'README.md'), 'w') as f:
-    f.write(README_CONTENT)
-
-# Create app.py
-with open(os.path.join(SPACE_DIR, 'app.py'), 'w') as f:
-    f.write(APP_PY)
-
-# Create requirements.txt
-with open(os.path.join(SPACE_DIR, 'requirements.txt'), 'w') as f:
-    f.write(REQS)
-
-print(f"✅ Created HuggingFace Space at: {SPACE_DIR}")
-print(f"\nFiles created:")
-for f in os.listdir(SPACE_DIR):
-    print(f"  {f}")
-
-print(f"\n📋 Next steps:")
-print(f"1. Review app.py and README.md")
-print(f"2. Push to GitHub")
-print(f"3. Create Space at: https://huggingface.co/new-space")
-print(f"4. Select 'Gradio' as SDK")
-print(f"5. Point to your GitHub repo")

package/huggingface_space/requirements.txt

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

package/mcp-server/README.md

@@ -1,188 +0,0 @@
-# A3M Router MCP Server
-
-MCP (Model Context Protocol) server for [A3M Router](https://github.com/Das-rebel/a3m-router) — parallel multi-LLM execution for AI agents.
-
-Allows any MCP-compatible AI agent (Claude Code, Cursor, Windsurf, etc.) to use A3M's routing and ensemble execution directly.
-
-## Tools
-
-| Tool | Description |
-|------|-------------|
-| `a3m_route` | Route a query to the optimal LLM provider (model selection + reasoning, no execution) |
-| `a3m_ensemble` | Execute a query across multiple providers in parallel and merge results |
-| `a3m_classify` | Classify a query by type (fast/creative/deep/code) and get provider recommendations |
-| `a3m_providers` | List all configured providers with models, cost, and availability |
-
-## Installation
-
-```bash
-# Install globally
-npm install -g @a3m/mcp-server
-
-# Or from the repo
-cd mcp-server
-npm install
-```
-
-## Configuration
-
-Set API keys as environment variables for the providers you want to use:
-
-```bash
-# Required for at least one provider
-export GROQ_API_KEY=gsk_...
-export GOOGLE_API_KEY=AIza...
-export CEREBRAS_API_KEY=csk-...
-export MISTRAL_API_KEY=...
-export MINIMAX_API_KEY=...
-
-# Optional: Custom A3M config
-export A3M_CONFIG_PATH=~/.config/a3m-router/providers.json
-```
-
-## Usage
-
-### Claude Code
-
-Add to your `~/.claude.json` or project `.claude.json`:
-
-```json
-{
-  "mcpServers": {
-    "a3m-router": {
-      "command": "npx",
-      "args": ["@a3m/mcp-server"],
-      "env": {
-        "GROQ_API_KEY": "gsk_...",
-        "GOOGLE_API_KEY": "AIza..."
-      }
-    }
-  }
-}
-```
-
-### Cursor
-
-In Cursor Settings -> Features -> MCP Servers, add:
-
-```
-Name: A3M Router
-Type: command
-Command: npx @a3m/mcp-server
-```
-
-### Direct MCP Client
-
-```bash
-# Start the server
-npx @a3m/mcp-server
-
-# Pipe stdin/stdout for MCP protocol
-echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | npx @a3m/mcp-server
-```
-
-### Testing the Server
-
-```bash
-# Clone and install
-git clone https://github.com/Das-rebel/a3m-router.git
-cd a3m-router/mcp-server
-npm install
-npx tsc
-
-# Run directly (pipe test)
-echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node dist/index.js
-
-# Or use the MCP inspector
-npx @modelcontextprotocol/inspector node dist/index.js
-```
-
-## Examples
-
-### Route a query
-
-```
-Tool: a3m_route
-Input: { "query": "Write a Python function to sort a list" }
-Output:
-{
-  "model": "groq/llama-3.3-70b-versatile",
-  "tier": "cheap",
-  "provider": "groq",
-  "confidence": 0.85,
-  "reasoning": "Code query detected, routing to fast coding provider",
-  "estimated_cost": 0.000012,
-  "classification": "code"
-}
-```
-
-### Ensemble execution
-
-```
-Tool: a3m_ensemble
-Input: { "query": "Explain quantum computing in 3 sentences" }
-Output:
-{
-  "query": "Explain quantum computing in 3 sentences",
-  "parallel_responses": [
-    { "provider": "groq", "confidence": 0.92, "content": "..." },
-    { "provider": "google", "confidence": 0.88, "content": "..." },
-    { "provider": "cerebras", "confidence": 0.85, "content": "..." }
-  ],
-  "best_answer": "...",
-  "stats": {
-    "total_providers": 4,
-    "successful": 3,
-    "failed": 1,
-    "total_cost": 0.000031
-  }
-}
-```
-
-## Protocol
-
-The server uses standard MCP transport via stdio:
-
-```
-Client -> Server: JSON-RPC request (stdin)
-Server -> Client: JSON-RPC response (stdout)
-Server -> Stderr: Logs (for debugging)
-```
-
-## Architecture
-
-```
-┌─────────────────────────────────────────────────┐
-│             MCP Client (Claude Code, Cursor)     │
-└──────────────────┬──────────────────────────────┘
-                   │ MCP Protocol (stdio)
-┌──────────────────▼──────────────────────────────┐
-│           A3M MCP Server (mcp-server)            │
-│                                                   │
-│  a3m_route   a3m_ensemble   a3m_classify  providers│
-└──────────────────┬──────────────────────────────┘
-                   │ Internal API
-┌──────────────────▼──────────────────────────────┐
-│        A3M Router (adaptive-memory-multi-        │
-│           model-router)                          │
-│                                                   │
-│  routeQuery()  extractQueryFeatures()  providers  │
-└───────┬────────────┬────────────┬────────────────┘
-        │            │            │
-   ┌────▼───┐  ┌────▼───┐  ┌────▼───┐
-   │  Groq  │  │ Google │  │Cerebras│  ...
-   └────────┘  └────────┘  └────────┘
-```
-
-## Development
-
-```bash
-cd mcp-server
-npm install
-npm run build    # npx tsc
-npm start        # node dist/index.js
-```
-
-## License
-
-MIT

package/mcp-server/package.json

@@ -1,29 +0,0 @@
-{
-  "name": "@a3m/mcp-server",
-  "version": "0.1.0",
-  "description": "MCP server for A3M Router - parallel multi-LLM execution for AI agents",
-  "type": "module",
-  "bin": {
-    "a3m-mcp": "./dist/index.js"
-  },
-  "main": "./dist/index.js",
-  "exports": {
-    ".": "./dist/index.js"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "adaptive-memory-multi-model-router": "^2.13.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.7.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Das-rebel/a3m-router.git"
-  }
-}