adaptive-memory-multi-model-router 2.15.5 → 2.16.1

package/python/mcp-server/a3m_mcp/server.py

@@ -1,339 +1,205 @@
-"""A3M Router MCP Server — 4 tools for parallel multi-LLM routing.
-
-Tools:
-    a3m_route     - Route a query to the optimal LLM provider (no execution)
-    a3m_ensemble  - Execute query across multiple providers in parallel
-    a3m_classify  - Classify query type and get provider recommendations
-    a3m_providers - List all configured providers with cost and availability
-
-Run:
-    python -m a3m_mcp
-    # Or pipe JSON-RPC directly:
-    echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | python -m a3m_mcp
 """
+A3M Router MCP Server - MCP Protocol Server for A3M Router
+
+MCP 2.0.0 compatible server that provides A3M Router functionality
+as MCP tools for AI agents.
+"""
+
+import os
 import asyncio
 import json
-import os
-import sys
-from typing import Any, Dict, List, Optional
+from typing import Optional, List, Any
 
-# MCP imports — use correct lowlevel API for installed version
 try:
     from mcp.server.lowlevel import Server
+    from mcp import Tool, ListToolsResult
+    from mcp.types import CallToolResult, TextContent
     from mcp.server.stdio import stdio_server
-    from mcp.types import Tool, CallToolResult, TextContent
     HAS_MCP = True
-except ImportError as e:
+except ImportError:
     HAS_MCP = False
-    print(f"WARNING: mcp package not installed. Run: pip install mcp. Error: {e}", file=sys.stderr)
-
-# ─── A3M Router client ──────────────────────────────────────────────────────
-
-A3M_BASE_URL = os.getenv("A3M_BASE_URL", "http://localhost:8787")
-A3M_API_KEY = os.getenv("A3M_API_KEY", "not-needed")
-A3M_TIMEOUT = float(os.getenv("A3M_TIMEOUT", "30.0"))
+    print("WARNING: mcp package not installed. Run: pip install mcp", flush=True)
 
-
-class A3MRouterClient:
-    """Thin async client for the A3M Router HTTP API."""
-
-    def __init__(self, base_url: str = A3M_BASE_URL, api_key: str = A3M_API_KEY):
-        self.base_url = base_url.rstrip("/")
-        self.api_key = api_key
-        self._client: Optional[Any] = None
-
-    async def _get_client(self) -> Any:
-        if self._client is None:
-            import httpx
-            self._client = httpx.AsyncClient(
-                base_url=self.base_url,
-                timeout=A3M_TIMEOUT,
-                headers={"Authorization": f"Bearer {self.api_key}"},
-            )
-        return self._client
-
-    async def close(self):
-        if self._client:
-            await self._client.aclose()
-            self._client = None
-
-    async def route(self, query: str) -> Dict[str, Any]:
-        """Route a query — returns routing decision without LLM execution."""
-        client = await self._get_client()
-        try:
-            response = await client.get(
-                "/route",
-                params={"query": query},
-                headers={"Authorization": f"Bearer {self.api_key}"},
-            )
-            if response.status_code == 200:
-                return response.json()
-        except Exception:
-            pass
-        # Fallback
-        return {
-            "model": "groq/llama-3.3-70b-versatile",
-            "tier": "cheap",
-            "cost": 0.0,
-            "reasoning": "A3M adaptive routing",
-            "complexity": 0.3,
-        }
-
-    async def chat(
-        self,
-        query: str,
-        model: str = "auto",
-        system: Optional[str] = None,
-        max_tokens: int = 1024,
-        temperature: float = 0.7,
-    ) -> Dict[str, Any]:
-        """Send a chat message via A3M Router."""
-        client = await self._get_client()
-        messages = []
-        if system:
-            messages.append({"role": "system", "content": system})
-        messages.append({"role": "user", "content": query})
-
-        try:
-            response = await client.post(
-                "/v1/chat/completions",
-                json={
-                    "model": model,
-                    "messages": messages,
-                    "max_tokens": max_tokens,
-                    "temperature": temperature,
+# A3M Router client
+try:
+    import a3m
+    A3MRouter = a3m.A3MRouter
+except ImportError:
+    A3MRouter = None
+
+
+SERVER_NAME = "a3m-router"
+SERVER_VERSION = "1.0.0"
+
+_router: Optional["A3MRouter"] = None
+
+
+def get_router() -> "A3MRouter":
+    """Get or create A3MRouter instance."""
+    global _router
+    if _router is None:
+        base_url = os.environ.get("A3M_BASE_URL", "http://localhost:8787")
+        api_key = os.environ.get("A3M_API_KEY", "")
+        _router = A3MRouter(base_url=base_url, api_key=api_key)
+    return _router
+
+
+# Tool definitions
+TOOLS = [
+    Tool(
+        name="a3m_route",
+        title="Route Query",
+        description="Route a query to the optimal LLM provider using A3M's adaptive routing. Returns model selection, tier, estimated cost, and reasoning.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The user query to route (e.g. 'Write Python code to sort a list')",
+                },
+                "provider": {
+                    "type": "string",
+                    "description": "Optional: Force a specific provider (e.g. 'groq', 'google')",
+                },
+            },
+            "required": ["query"],
+        },
+    ),
+    Tool(
+        name="a3m_chat",
+        title="Chat with A3M",
+        description="Send a chat message through A3M Router's adaptive routing.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The user query",
                 },
-                headers={"Authorization": f"Bearer {self.api_key}"},
-            )
-            response.raise_for_status()
-            return response.json()
-        except Exception as e:
-            return {"error": str(e), "choices": [{"message": {"content": f"Error: {e}"}}]}
-
-    async def ensemble(
-        self,
-        query: str,
-        providers: Optional[List[str]] = None,
-        system: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Execute query across multiple providers in parallel."""
-        providers = providers or ["groq", "google", "cerebras"]
-        tasks = [
-            self.chat(query, model=p, system=system)
-            for p in providers
-        ]
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        responses = []
-        for i, r in enumerate(results):
-            if isinstance(r, Exception):
-                responses.append({"provider": providers[i], "error": str(r)})
-            else:
-                content = r.get("choices", [{}])[0].get("message", {}).get("content", "")
-                responses.append({"provider": providers[i], "content": content})
-
-        return {
-            "query": query,
-            "parallel_responses": responses,
-            "best_answer": responses[0].get("content", "") if responses else "",
-            "stats": {
-                "total_providers": len(providers),
-                "successful": sum(1 for r in responses if "error" not in r),
-                "failed": sum(1 for r in responses if "error" in r),
             },
-        }
-
-    async def classify(self, query: str) -> Dict[str, Any]:
-        """Classify a query by type and get provider recommendations."""
-        route = await self.route(query)
-        complexity = route.get("complexity", 0.5)
-        model = route.get("model", "groq/llama-3.3-70b-versatile")
-
-        query_lower = query.lower()
-        if any(k in query_lower for k in ["write code", "function", "class", "def ", "import "]):
-            classification = "code"
-            recommended = ["groq/llama-3.3-70b-versatile", "cerebras/cerebras-coder"]
-        elif any(k in query_lower for k in ["explain", "what is", "how does", "why is"]):
-            classification = "fast"
-            recommended = ["groq/llama-3.1-8b-instant", "google/gemini-2.0-flash"]
-        elif complexity >= 0.65:
-            classification = "deep"
-            recommended = ["openai/gpt-4o", "anthropic/claude-3.5-sonnet"]
-        else:
-            classification = "creative"
-            recommended = ["groq/llama-3.3-70b-versatile", "google/gemini-2.0-flash"]
-
-        return {
-            "query": query,
-            "classification": classification,
-            "complexity": complexity,
-            "recommended_model": model,
-            "recommended_providers": recommended,
-        }
-
-    async def providers(self) -> Dict[str, Any]:
-        """List all configured providers with cost and status."""
-        client = await self._get_client()
+            "required": ["query"],
+        },
+    ),
+    Tool(
+        name="a3m_cost_report",
+        title="Cost Report",
+        description="Get cost analytics across all providers.",
+        inputSchema={
+            "type": "object",
+            "properties": {},
+        },
+    ),
+    Tool(
+        name="a3m_models",
+        title="List Models",
+        description="List all available models with cost/latency info.",
+        inputSchema={
+            "type": "object",
+            "properties": {},
+        },
+    ),
+]
+
+
+class A3MServer:
+    """A3M Router MCP Server with tool handlers."""
+
+    def __init__(self):
+        pass
+
+    async def handle_list_tools(self, request_context=None) -> ListToolsResult:
+        """Handle tools/list request."""
+        return ListToolsResult(
+            tools=[
+                {
+                    "name": t.name,
+                    "description": t.description,
+                    "inputSchema": t.inputSchema,
+                }
+                for t in TOOLS
+            ]
+        )
+
+    async def handle_call_tool(self, request_context, name: str, arguments: dict) -> CallToolResult:
+        """Handle tools/call request."""
         try:
-            response = await client.get(
-                "/providers",
-                headers={"Authorization": f"Bearer {self.api_key}"},
-            )
-            if response.status_code == 200:
-                return response.json()
-        except Exception:
-            pass
-
-        default_providers = [
-            {"name": "groq", "models": ["llama-3.3-70b-versatile", "llama-3.1-8b-instant"], "cost_per_1k_input": 0.0, "status": "available"},
-            {"name": "google", "models": ["gemini-2.0-flash", "gemini-1.5-flash"], "cost_per_1k_input": 0.0, "status": "available"},
-            {"name": "cerebras", "models": ["cerebras-coder", "cerebras-llama-3.3-70b"], "cost_per_1k_input": 0.0, "status": "available"},
-            {"name": "openai", "models": ["gpt-4o", "gpt-4o-mini"], "cost_per_1k_input": 0.015, "status": "available"},
-            {"name": "anthropic", "models": ["claude-3.5-sonnet", "claude-3-opus"], "cost_per_1k_input": 0.015, "status": "available"},
-            {"name": "mistral", "models": ["mistral-large", "mistral-small"], "cost_per_1k_input": 0.008, "status": "available"},
-            {"name": "deepseek", "models": ["deepseek-chat", "deepseek-coder"], "cost_per_1k_input": 0.001, "status": "available"},
-        ]
-        return {"providers": default_providers, "source": "fallback"}
-
+            if name == "a3m_route":
+                router = get_router()
+                query = arguments.get("query")
+                provider = arguments.get("provider")
 
-# ─── MCP Server ───────────────────────────────────────────────────────────────
+                result = router.route(query, provider=provider)
+                return CallToolResult(
+                    content=[TextContent(type="text", text=json.dumps(result, indent=2))]
+                )
 
-if HAS_MCP:
-    SERVER_NAME = "a3m-router"
-    SERVER_VERSION = "1.0.0"
-
-    _router: Optional[A3MRouterClient] = None
-
-    def get_router() -> A3MRouterClient:
-        global _router
-        if _router is None:
-            _router = A3MRouterClient()
-        return _router
-
-    server = Server(SERVER_NAME)
-
-    @server.list_tools()
-    async def list_tools() -> List[Tool]:
-        """List all available MCP tools."""
-        return [
-            Tool(
-                name="a3m_route",
-                description="Route a query to the optimal LLM provider using A3M's adaptive routing. Returns model selection, tier, estimated cost, and reasoning — no LLM execution.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "query": {
-                            "type": "string",
-                            "description": "The user query to route (e.g. 'Write Python code to sort a list')",
-                        }
-                    },
-                    "required": ["query"],
-                },
-            ),
-            Tool(
-                name="a3m_ensemble",
-                description="Execute a query across multiple LLM providers in parallel and merge results. Returns all responses with stats on success/failure per provider.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "query": {
-                            "type": "string",
-                            "description": "The user query to execute across providers",
-                        },
-                        "providers": {
-                            "type": "array",
-                            "items": {"type": "string"},
-                            "description": "Optional list of provider names. Defaults to ['groq', 'google', 'cerebras']",
-                        },
-                        "system": {
-                            "type": "string",
-                            "description": "Optional system prompt to prepend",
-                        },
-                    },
-                    "required": ["query"],
-                },
-            ),
-            Tool(
-                name="a3m_classify",
-                description="Classify a query by type (fast/creative/deep/code) and get provider recommendations based on query complexity.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "query": {
-                            "type": "string",
-                            "description": "The query to classify",
-                        }
-                    },
-                    "required": ["query"],
-                },
-            ),
-            Tool(
-                name="a3m_providers",
-                description="List all configured LLM providers with their models, cost per 1K tokens, and availability status.",
-                inputSchema={
-                    "type": "object",
-                    "properties": {},
-                },
-            ),
-        ]
+            elif name == "a3m_chat":
+                router = get_router()
+                query = arguments.get("query")
 
-    @server.call_tool()
-    async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
-        """Execute an MCP tool call."""
-        router = get_router()
-        try:
-            if name == "a3m_route":
-                result = await router.route(arguments["query"])
-                text = json.dumps(result, indent=2)
-                return CallToolResult(content=[TextContent(type="text", text=text)])
-
-            elif name == "a3m_ensemble":
-                result = await router.ensemble(
-                    query=arguments["query"],
-                    providers=arguments.get("providers"),
-                    system=arguments.get("system"),
+                result = router.chat(query)
+                return CallToolResult(
+                    content=[TextContent(type="text", text=str(result))]
                 )
-                text = json.dumps(result, indent=2)
-                return CallToolResult(content=[TextContent(type="text", text=text)])
 
-            elif name == "a3m_classify":
-                result = await router.classify(arguments["query"])
-                text = json.dumps(result, indent=2)
-                return CallToolResult(content=[TextContent(type="text", text=text)])
+            elif name == "a3m_cost_report":
+                router = get_router()
+                report = router.cost_report()
+                return CallToolResult(
+                    content=[TextContent(type="text", text=json.dumps(report, indent=2))]
+                )
 
-            elif name == "a3m_providers":
-                result = await router.providers()
-                text = json.dumps(result, indent=2)
-                return CallToolResult(content=[TextContent(type="text", text=text)])
+            elif name == "a3m_models":
+                router = get_router()
+                models = router.models()
+                return CallToolResult(
+                    content=[TextContent(type="text", text=json.dumps(models, indent=2))]
+                )
 
             else:
                 return CallToolResult(
                     content=[TextContent(type="text", text=f"Unknown tool: {name}")],
                     isError=True,
                 )
+
         except Exception as e:
             return CallToolResult(
                 content=[TextContent(type="text", text=f"Error: {str(e)}")],
                 isError=True,
             )
-        finally:
-            await router.close()
-
-
-    async def main():
-        """Run the MCP server over stdio."""
-        print("A3M Router MCP Server starting...", file=sys.stderr)
-        print(f"Connecting to A3M Router at {A3M_BASE_URL}", file=sys.stderr)
-        async with stdio_server() as (read_stream, write_stream):
-            await server.run(
-                read_stream,
-                write_stream,
-                server.create_initialization_options(),
-            )
 
 
-if __name__ == "__main__":
+if HAS_MCP:
+    # Create server with handlers
+    a3m_server = A3MServer()
+
+    server = Server(
+        SERVER_NAME,
+        version=SERVER_VERSION,
+        on_list_tools=a3m_server.handle_list_tools,
+        on_call_tool=a3m_server.handle_call_tool,
+    )
+
+
+async def main():
+    """Main entry point for MCP server."""
     if not HAS_MCP:
-        print("ERROR: mcp package required. Install with: pip install mcp", file=sys.stderr)
-        sys.exit(1)
-    asyncio.run(main())
+        print("ERROR: mcp package not installed", flush=True)
+        return
+
+    print(f"Starting {SERVER_NAME} MCP Server v{SERVER_VERSION}", flush=True)
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options(),
+        )
+
+
+if __name__ == "__main__":
+    if HAS_MCP:
+        asyncio.run(main())
+    else:
+        print("ERROR: mcp package required", flush=True)
+        print("Run: pip install mcp", flush=True)

package/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "a3m-router"
-version = "2.2.2"
+version = "2.16.1"
 description = "Auto-selects cheapest capable LLM from 47+ providers — 70-95% cost savings"
 readme = "README.md"
 license = {text = "MIT"}
@@ -61,10 +61,13 @@ adapters = [
 dev = ["pytest>=7.4.0", "pytest-asyncio>=0.21.0", "black>=23.0.0"]
 
 [project.urls]
-Homepage = "https://github.com/Das-rebel/a3m-router"
-Documentation = "https://das-rebel.github.io/a3m-router"
+Homepage = "https://github.com/Das-rebel/a3m-router#a3m-router"
+Documentation = "https://github.com/Das-rebel/a3m-router#readme"
 Repository = "https://github.com/Das-rebel/a3m-router"
 Changelog = "https://github.com/Das-rebel/a3m-router/releases"
+"NPM Package" = "https://www.npmjs.com/package/adaptive-memory-multi-model-router"
+"PyPI Package" = "https://pypi.org/project/a3m-router/"
+"GitHub Stars" = "https://github.com/Das-rebel/a3m-router/stargazers"
 
 [tool.setuptools.packages.find]
 where = ["."]

package/scripts/submit-sitemap.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+#
+# A3M Router — Sitemap Submission Script
+# Submits sitemap to Google, Bing, and IndexNow for faster indexing
+#
+set -e
+
+SITEMAP_URL="${SITEMAP_URL:-https://a3m-router.com/sitemap.xml}"
+INDEXNOW_KEY="${INDEXNOW_KEY:-}"
+
+echo "=== A3M Router Sitemap Submission ==="
+echo "Sitemap: $SITEMAP_URL"
+echo ""
+
+# ─── Google ───────────────────────────────────────────
+echo "[1/3] Submitting to Google..."
+GOOGLE_STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
+  "https://www.google.com/ping?sitemap=$SITEMAP_URL")
+if [ "$GOOGLE_STATUS" = "200" ]; then
+  echo "  ✅ Google: OK (HTTP $GOOGLE_STATUS)"
+else
+  echo "  ⚠️  Google: HTTP $GOOGLE_STATUS"
+fi
+
+# ─── Bing ─────────────────────────────────────────────
+echo "[2/3] Submitting to Bing..."
+BING_STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
+  "https://www.bing.com/ping?sitemap=$SITEMAP_URL")
+if [ "$BING_STATUS" = "200" ]; then
+  echo "  ✅ Bing: OK (HTTP $BING_STATUS)"
+else
+  echo "  ⚠️  Bing: HTTP $BING_STATUS"
+fi
+
+# ─── IndexNow ─────────────────────────────────────────
+echo "[3/3] Submitting to IndexNow..."
+if [ -z "$INDEXNOW_KEY" ]; then
+  echo "  ⚠️  Skipped: INDEXNOW_KEY env var not set"
+  echo "  To enable IndexNow: export INDEXNOW_KEY=your_key_from_indexnow.org"
+else
+  # Get the sitemap URLs and submit each to IndexNow
+  curl -s "$SITEMAP_URL" | grep -oP '(?<=<loc>)[^<]+' | while read -r url; do
+    RESPONSE=$(curl -s -w "%{http_code}" -o /dev/null -X POST \
+      "https://indexnow.org/ping" \
+      -H "Content-Type: text/plain" \
+      -d "url=$url&key=$INDEXNOW_KEY")
+    echo "  IndexNow: $url → HTTP $RESPONSE"
+  done
+fi
+
+echo ""
+echo "=== Done ==="

package/src/__types__/registry.d.ts

@@ -0,0 +1,14 @@
+declare module '@my-org/a3m-router/src/providers/registry' {
+  const PROVIDERS: Map<string, any>;
+  const registry: Map<string, any>;
+  export function registerProvider(name: string, config: any): void;
+  export function getProvider(name: string): any;
+  export function listProviders(): Array<[string, any]>;
+  export interface ProviderRegistry {
+    registerProvider: (name: string, config: any) => void;
+    getProvider: (name: string) => any;
+    listProviders: () => Array<[string, any]>;
+  }
+  const registryInstance: ProviderRegistry;
+  export default registryInstance;
+}