baiduan-router 1.0.0__tar.gz

baiduan_router-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.5
+Name: baiduan-router
+Version: 1.0.0
+Summary: Route prompts across multiple leading AI models through a single MCP server
+Author: Baichuan
+License: Apache-2.0
+Keywords: ai-router,cross-model,llm,mcp,model-routing
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=1.0.0

baiduan_router-1.0.0/README.md

@@ -0,0 +1,42 @@
+# Baichuan Router
+
+**One prompt, every model — route, compare, and save.**
+
+Baichuan Router is an open-source MCP server that routes your prompts across multiple leading AI models. Instead of being locked into a single provider, get side-by-side comparison, cost optimization, and smart model selection — all through one neutral interface.
+
+## Quick Start
+
+```bash
+npx baiduan-router
+```
+
+Or install:
+
+```bash
+pip install baiduan-router
+```
+
+## Features
+
+- **Multi-model routing** — send one prompt to multiple models, compare results
+- **Smart selection** — auto-route simple tasks to cost-effective models, complex tasks to premium ones
+- **MCP-native** — works with Claude Desktop, VS Code, Cursor, and any MCP-compatible client
+- **BYOK** — bring your own API keys, never stored or logged
+- **Open source** — Apache-2.0, fully self-hostable
+
+## Supported Models
+
+Set environment variables for the models you want to use:
+
+| Model   | Env Variable         | Free Tier Available |
+|---------|---------------------|---------------------|
+| Gemini  | `GEMINI_API_KEY`    | ✅ Unlimited        |
+| Grok    | `GROK_API_KEY`      | ✅ $25 credits      |
+| DeepSeek| `DEEPSEEK_API_KEY`  | ✅ Unlimited        |
+| Qwen    | `DASHSCOPE_API_KEY` | ✅ 1M tokens/month  |
+| Claude  | `ANTHROPIC_API_KEY` | —                   |
+| ChatGPT | `OPENAI_API_KEY`    | —                   |
+
+## License
+
+Apache-2.0 © Baichuan

baiduan_router-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "baiduan-router"
+version = "1.0.0"
+description = "Route prompts across multiple leading AI models through a single MCP server"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+dependencies = ["mcp>=1.0.0", "httpx>=0.27.0"]
+keywords = ["mcp", "model-routing", "cross-model", "llm", "ai-router"]
+authors = [{ name = "Baichuan" }]
+
+[project.scripts]
+baiduan-router = "baiduan_router.server:run"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/baiduan_router"]

baiduan_router-1.0.0/src/baiduan_router/__init__.py

@@ -0,0 +1 @@
+# Baichuan Router - Multi-model MCP routing server

baiduan_router-1.0.0/src/baiduan_router/db.py

@@ -0,0 +1,75 @@
+"""Baichuan Dispatcher - SQLite user & usage store.
+
+Zero external deps (Python stdlib). Deploy-to-init.
+Confidential credentials never stored.
+"""
+
+import sqlite3
+import hashlib
+import os
+
+DB_PATH = os.environ.get("DISPATCHER_DB") or os.path.join(os.path.dirname(__file__), "dispatcher.db")
+
+
+def _conn():
+    c = sqlite3.connect(DB_PATH)
+    c.row_factory = sqlite3.Row
+    c.execute("PRAGMA journal_mode=WAL")
+    return c
+
+
+def init_db():
+    with _conn() as db:
+        db.executescript("""
+            CREATE TABLE IF NOT EXISTS users (
+                id         INTEGER PRIMARY KEY AUTOINCREMENT,
+                api_key_hash TEXT UNIQUE NOT NULL,
+                tier       TEXT NOT NULL DEFAULT 'free'
+                           CHECK(tier IN ('free','pro')),
+                daily_quota INTEGER NOT NULL DEFAULT 100,
+                created_at TEXT NOT NULL DEFAULT (datetime('now'))
+            );
+            CREATE TABLE IF NOT EXISTS usage_logs (
+                id              INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id         INTEGER NOT NULL REFERENCES users(id),
+                model           TEXT NOT NULL,
+                prompt_tokens   INTEGER NOT NULL DEFAULT 0,
+                completion_tokens INTEGER NOT NULL DEFAULT 0,
+                cost_cents      INTEGER NOT NULL DEFAULT 0,
+                timestamp       TEXT NOT NULL DEFAULT (datetime('now'))
+            );
+            CREATE INDEX IF NOT EXISTS idx_usage_user_ts
+                ON usage_logs(user_id, timestamp);
+        """)
+
+
+def _hash_key(raw: str) -> str:
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+def get_user_by_key(api_key: str) -> dict | None:
+    h = _hash_key(api_key)
+    with _conn() as db:
+        row = db.execute("SELECT * FROM users WHERE api_key_hash=?", (h,)).fetchone()
+    return dict(row) if row else None
+
+
+def get_daily_usage(user_id: int, date: str) -> int:
+    with _conn() as db:
+        row = db.execute(
+            "SELECT COUNT(*) AS cnt FROM usage_logs WHERE user_id=? AND date(timestamp)=?",
+            (user_id, date),
+        ).fetchone()
+    return row["cnt"]
+
+
+def log_usage(user_id: int, model: str, prompt_tokens: int, completion_tokens: int, cost_cents: int):
+    with _conn() as db:
+        db.execute(
+            "INSERT INTO usage_logs (user_id, model, prompt_tokens, completion_tokens, cost_cents) VALUES (?,?,?,?,?)",
+            (user_id, model, prompt_tokens, completion_tokens, cost_cents),
+        )
+
+
+# Auto-init on import (zero ops)
+init_db()

baiduan_router-1.0.0/src/baiduan_router/pricing.py

@@ -0,0 +1,27 @@
+"""Baichuan Dispatcher - model cost mapping.
+
+Unit: US cents per million tokens (approximate).
+Free/ultra-cheap models: cost=0.
+"""
+
+# (input_cents_per_1M, output_cents_per_1M)
+PRICES = {
+    "chatgpt":  (1500, 6000),   # ~$15/$60
+    "claude":   (1500, 7500),   # ~$15/$75
+    "grok":     (0, 0),         # free key
+    "gemini":   (0, 0),         # free key
+    "deepseek": (14, 110),      # ~$0.14/$1.10 (ultra-cheap, rounded to 0)
+    "qwen":     (0, 0),         # DashScope free quota
+    "silicon":  (0, 0),         # SiliconFlow free quota
+    "groq":     (0, 0),         # free
+    "llama":    (0, 0),         # local
+}
+
+
+def calculate_cost(model: str, input_tokens: int, output_tokens: int) -> int:
+    """Return cost_cents (integer cents). Free models return 0."""
+    inp, out = PRICES.get(model, (0, 0))
+    if inp == 0 and out == 0:
+        return 0
+    cost = (input_tokens / 1_000_000) * inp + (output_tokens / 1_000_000) * out
+    return max(0, round(cost))

baiduan_router-1.0.0/src/baiduan_router/server.py

@@ -0,0 +1,252 @@
+"""Baichuan Dispatcher.
+
+Multi-model routing MCP server.
+Credentials via env vars, never in code or logs.
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+from datetime import date as _today
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+from .db import get_user_by_key, log_usage, get_daily_usage
+from .pricing import calculate_cost
+
+mcp = FastMCP("Baichuan Dispatcher", host="127.0.0.1", port=47832)
+
+SUPPORTED_MODELS = (
+    "chatgpt", "grok", "claude", "gemini", "llama",
+    # Free / open-source backends (Chinese ecosystem)
+    "deepseek",   # DeepSeek - unlimited free tier, excellent coding
+    "qwen",       # Alibaba DashScope - Qwen models, free tier 1M tokens
+    "silicon",   # SiliconFlow - open-source model cloud inference
+    "groq",      # Groq - free fast inference, hosts Llama etc.
+)
+
+PRO_MODELS = {"chatgpt", "claude"}
+FREE_MODELS = set(SUPPORTED_MODELS) - PRO_MODELS
+DAILY_QUOTA = {"free": 100, "pro": 1000}
+
+
+def _reply(model: str, status: str, text=None, error=None, usage=None):
+    return {
+        "model": model,
+        "status": status,
+        "text": text,
+        "usage": usage or {"input_tokens": 0, "output_tokens": 0},
+        "task_id": str(uuid.uuid4()),
+        "error": error,
+    }
+
+
+def _secret(name: str) -> str:
+    value = (os.environ.get(name) or "").strip()
+    if not value:
+        raise RuntimeError(f"missing credential: {name}")
+    return value
+
+
+def _post_json(url: str, headers: dict, payload: dict):
+    with httpx.Client(timeout=180) as client:
+        resp = client.post(url, headers=headers, json=payload)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def _call_openai_compat(default_model, default_base, prompt, system, max_tokens, temperature, key_env, base_env, key_optional=False):
+    if key_optional:
+        key = (os.environ.get(key_env) or "").strip() or "local"
+    else:
+        key = _secret(key_env)
+    base = (os.environ.get(base_env) or default_base).rstrip("/")
+    payload = {
+        "model": os.environ.get(key_env.replace("_API_KEY", "") + "_MODEL") or default_model,
+        "messages": [],
+    }
+    if system:
+        payload["messages"].append({"role": "system", "content": system})
+    payload["messages"].append({"role": "user", "content": prompt})
+    if max_tokens:
+        payload["max_tokens"] = max_tokens
+    if temperature is not None:
+        payload["temperature"] = temperature
+    data = _post_json(f"{base}/chat/completions", {"Authorization": f"Bearer {key}"}, payload)
+    text = data["choices"][0]["message"]["content"]
+    usage = {
+        "input_tokens": data.get("usage", {}).get("prompt_tokens", 0),
+        "output_tokens": data.get("usage", {}).get("completion_tokens", 0),
+    }
+    return text, usage
+
+
+def _call_claude(prompt, system, max_tokens, temperature):
+    key = _secret("ANTHROPIC_API_KEY")
+    base = (os.environ.get("ANTHROPIC_BASE_URL") or "https://api.anthropic.com").rstrip("/")
+    model = os.environ.get("CLAUDE_MODEL") or "claude-opus-5"
+    payload = {
+        "model": model,
+        "max_tokens": max_tokens or 4096,
+        "messages": [{"role": "user", "content": prompt}],
+    }
+    if system:
+        payload["system"] = system
+    if temperature is not None:
+        payload["temperature"] = temperature
+    headers = {"x-api-key": key, "anthropic-version": "2023-06-01", "content-type": "application/json"}
+    data = _post_json(f"{base}/v1/messages", headers, payload)
+    text = "".join(b.get("text", "") for b in data.get("content", []) if b.get("type") == "text")
+    usage = {
+        "input_tokens": data.get("usage", {}).get("input_tokens", 0),
+        "output_tokens": data.get("usage", {}).get("output_tokens", 0),
+    }
+    return text, usage
+
+
+def _call_gemini(prompt, system, max_tokens, temperature):
+    key = _secret("GEMINI_API_KEY")
+    model = os.environ.get("GEMINI_MODEL") or "gemini-2.5-pro"
+    base = (os.environ.get("GEMINI_BASE_URL") or "https://generativelanguage.googleapis.com").rstrip("/")
+    url = f"{base}/v1beta/models/{model}:generateContent?key={key}"
+    contents = []
+    if system:
+        contents.append({"role": "user", "parts": [{"text": system}]})
+    contents.append({"role": "user", "parts": [{"text": prompt}]})
+    payload = {"contents": contents}
+    gen = {}
+    if max_tokens:
+        gen["maxOutputTokens"] = max_tokens
+    if temperature is not None:
+        gen["temperature"] = temperature
+    if gen:
+        payload["generationConfig"] = gen
+    data = _post_json(url, {"content-type": "application/json"}, payload)
+    try:
+        text = data["candidates"][0]["content"]["parts"][0]["text"]
+    except (KeyError, IndexError):
+        text = ""
+    usage = {
+        "input_tokens": data.get("usageMetadata", {}).get("promptTokenCount", 0),
+        "output_tokens": data.get("usageMetadata", {}).get("candidatesTokenCount", 0),
+    }
+    return text, usage
+
+
+def _route(model, prompt, system, max_tokens, temperature):
+    if model == "chatgpt":
+        return _call_openai_compat("gpt-6-astra", "https://api.openai.com/v1", prompt, system, max_tokens, temperature, "OPENAI_API_KEY", "OPENAI_BASE_URL")
+    if model == "grok":
+        return _call_openai_compat("grok-4.6", "https://api.x.ai/v1", prompt, system, max_tokens, temperature, "GROK_API_KEY", "GROK_BASE_URL")
+    if model == "llama":
+        # Override default model via LLAMA_MODEL env var, e.g. export LLAMA_MODEL=qwen2.5:7b
+        return _call_openai_compat("qwen2.5:7b", "http://127.0.0.1:11434/v1", prompt, system, max_tokens, temperature, "LLAMA_API_KEY", "LLAMA_BASE_URL", key_optional=True)
+    if model == "claude":
+        return _call_claude(prompt, system, max_tokens, temperature)
+    if model == "gemini":
+        return _call_gemini(prompt, system, max_tokens, temperature)
+    if model == "deepseek":
+        return _call_openai_compat("deepseek-chat", "https://api.deepseek.com/v1", prompt, system, max_tokens, temperature, "DEEPSEEK_API_KEY", "DEEPSEEK_BASE_URL")
+    if model == "qwen":
+        return _call_openai_compat("qwen-plus", "https://dashscope.aliyuncs.com/compatible-mode/v1", prompt, system, max_tokens, temperature, "DASHSCOPE_API_KEY", "DASHSCOPE_BASE_URL")
+    if model == "silicon":
+        return _call_openai_compat("Qwen/Qwen3-235B-A22B", "https://api.siliconflow.cn/v1", prompt, system, max_tokens, temperature, "SILICONFLOW_API_KEY", "SILICONFLOW_BASE_URL")
+    if model == "groq":
+        return _call_openai_compat("llama-4-scout-17b-16e-instruct", "https://api.groq.com/openai/v1", prompt, system, max_tokens, temperature, "GROQ_API_KEY", "GROQ_BASE_URL")
+    raise ValueError(f"unsupported model: {model}")
+
+
+@mcp.tool()
+def route_to_model(
+    model: str,
+    prompt: str,
+    system: str = "",
+    max_tokens: int = 0,
+    temperature: float = 0.7,
+    context_id: str = "",
+    api_key: str = "",
+) -> dict:
+    """Route prompt to a model, return unified response.
+
+    model: chatgpt|grok|claude|gemini|llama|deepseek|qwen|silicon|groq
+    External users must pass api_key; internal calls bypass auth (unlimited).
+    """
+    try:
+        if model not in SUPPORTED_MODELS:
+            return _reply(model, "failed", error=f"unsupported model: {model}")
+        # ---- Auth & permissions (external users only; no api_key = bypass) ----
+        user_id = 0   # 0 = internal (bypass billing/limits)
+        if api_key:
+            user = get_user_by_key(api_key)
+            if not user:
+                return _reply(model, "failed", error="invalid api_key")
+            # Paywall: PRO models only for pro tier users
+            if model in PRO_MODELS and user["tier"] != "pro":
+                return _reply(model, "failed", error="pro tier required for this model")
+            # Daily quota check
+            today = _today().isoformat()
+            cnt = get_daily_usage(user["id"], today)
+            if cnt >= user["daily_quota"]:
+                return _reply(model, "failed", error="daily quota exhausted")
+            user_id = user["id"]
+        # ---- Route ----
+        text, usage = _route(model, prompt, system or None, max_tokens or None, temperature)
+        # ---- Log usage (external users only) ----
+        if user_id:
+            cost = calculate_cost(model, usage["input_tokens"], usage["output_tokens"])
+            log_usage(user_id, model, usage["input_tokens"], usage["output_tokens"], cost)
+        return _reply(model, "completed", text=text, usage=usage)
+    except Exception as exc:  # noqa: BLE001
+        return _reply(model, "failed", error=str(exc))
+
+
+@mcp.tool()
+def list_models() -> dict:
+    """List available models with tier (free/pro)."""
+    models = []
+    for m in SUPPORTED_MODELS:
+        models.append({"model": m, "tier": "pro" if m in PRO_MODELS else "free"})
+    return {"models": models}
+
+
+@mcp.tool()
+def health_check() -> dict:
+    """System health check: backend connectivity, DB status, process info."""
+    import platform, time
+    start = time.time()
+    result = {
+        "status": "ok",
+        "host": platform.node(),
+        "python": platform.python_version(),
+        "uptime_seconds": time.time() - start,  # approximate
+        "backends": {},
+        "db": "ok",
+    }
+    # Test DB
+    try:
+        from .db import _conn
+        c = _conn()
+        c.execute("SELECT COUNT(*) FROM users")
+        result["db_users"] = c.fetchone()[0]
+        c.execute("SELECT COUNT(*) FROM usage_logs")
+        result["db_logs"] = c.fetchone()[0]
+        c.close()
+    except Exception as e:
+        result["db"] = str(e)
+    # Test backends (quick connectivity)
+    for model in SUPPORTED_MODELS:
+        try:
+            result["backends"][model] = {"model": model, "tier": "pro" if model in PRO_MODELS else "free", "env_set": bool(os.environ.get(f"{model.upper()}_API_KEY"))}
+        except Exception:
+            result["backends"][model] = {"model": model, "error": "check failed"}
+    return result
+
+
+
+def run():
+    mcp.run(transport="sse")
+
+if __name__ == "__main__":
+    run()