baichuan-mcp-server 1.0.0__tar.gz

baichuan_mcp_server-1.0.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.5
+Name: baichuan-mcp-server
+Version: 1.0.0
+Summary: Baichuan Router — Multi-model AI routing MCP server. One endpoint, every model.
+Project-URL: Repository, https://github.com/baichuan-alliance/router
+Author: Baichuan Alliance
+License: Apache-2.0
+Keywords: agent,ai-router,baichuan,cross-model,llm,mcp,model-routing
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp<2
+Description-Content-Type: text/markdown
+
+# Baichuan Router (MCP Server)
+
+**One prompt, every model — route, compare, and save.**
+
+Baichuan Router is an open-source MCP server that routes prompts across multiple AI models.
+
+## Quick Start
+
+```bash
+uvx baichuan-mcp-server
+```
+
+Or install:
+
+```bash
+pip install baichuan-mcp-server
+```
+
+## License
+
+Apache-2.0 © Baichuan Alliance

baichuan_mcp_server-1.0.0/README.md

@@ -0,0 +1,21 @@
+# Baichuan Router (MCP Server)
+
+**One prompt, every model — route, compare, and save.**
+
+Baichuan Router is an open-source MCP server that routes prompts across multiple AI models.
+
+## Quick Start
+
+```bash
+uvx baichuan-mcp-server
+```
+
+Or install:
+
+```bash
+pip install baichuan-mcp-server
+```
+
+## License
+
+Apache-2.0 © Baichuan Alliance

baichuan_mcp_server-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "baichuan-mcp-server"
+version = "1.0.0"
+description = "Baichuan Router — Multi-model AI routing MCP server. One endpoint, every model."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+dependencies = [
+    "httpx>=0.27.0",
+    "mcp<2",
+]
+keywords = ["mcp", "model-routing", "cross-model", "llm", "ai-router", "agent", "baichuan"]
+authors = [{ name = "Baichuan Alliance" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Repository = "https://github.com/baichuan-alliance/router"
+
+[project.scripts]
+baichuan-router = "baichuan_router.server:run"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/baichuan_router"]

baichuan_mcp_server-1.0.0/src/baichuan_router/__init__.py

@@ -0,0 +1,3 @@
+"""Baichuan Router — Multi-model AI routing MCP server."""
+
+__version__ = "1.0.0"

baichuan_mcp_server-1.0.0/src/baichuan_router/server.py

@@ -0,0 +1,214 @@
+"""Baichuan Router MCP server (self-hosted, BYOK).
+
+Route prompts across 9 AI model providers through a single MCP server.
+Bring your own keys (BYOK) via model_api_key, or set environment variables.
+No lock-in, no vendor bias.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import uuid
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+_port = int(os.environ.get("BAICHUAN_PORT", "47832"))
+mcp = FastMCP("Baichuan Router", host="127.0.0.1", port=_port)
+
+SUPPORTED_MODELS = (
+    "chatgpt", "grok", "claude", "gemini", "llama",
+    "deepseek", "qwen", "silicon", "groq",
+)
+
+
+def _reply(model, status, 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):
+    value = (os.environ.get(name) or "").strip()
+    if not value:
+        raise RuntimeError(f"missing credential: {name}")
+    return value
+
+
+def _key(name, override=None):
+    """Use a caller-supplied key (BYOK) when present, else the server env key."""
+    if override and str(override).strip():
+        return str(override).strip()
+    return _secret(name)
+
+
+def _post_json(url, headers, payload):
+    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, key_override=None):
+    if key_override:
+        key = key_override
+    elif 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_override=None):
+    key = _key("ANTHROPIC_API_KEY", key_override)
+    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_override=None):
+    key = _key("GEMINI_API_KEY", key_override)
+    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, key_override=None):
+    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", key_override=key_override)
+    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", key_override=key_override)
+    if model == "llama":
+        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, key_override=key_override)
+    if model == "claude":
+        return _call_claude(prompt, system, max_tokens, temperature, key_override=key_override)
+    if model == "gemini":
+        return _call_gemini(prompt, system, max_tokens, temperature, key_override=key_override)
+    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", key_override=key_override)
+    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", key_override=key_override)
+    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", key_override=key_override)
+    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", key_override=key_override)
+    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 = "",
+    model_api_key: str = "",
+) -> dict:
+    """Route prompt to a model, return unified response.
+
+    model: chatgpt|grok|claude|gemini|llama|deepseek|qwen|silicon|groq
+    model_api_key (BYOK): optional caller-owned key for the target provider.
+    When provided it is used instead of the server-side credential.
+    """
+    try:
+        if model not in SUPPORTED_MODELS:
+            return _reply(model, "failed", error=f"unsupported model: {model}")
+        text, usage = _route(model, prompt, system or None, max_tokens or None, temperature, key_override=(model_api_key or None))
+        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."""
+    return {"models": [{"model": m} for m in SUPPORTED_MODELS]}
+
+
+@mcp.tool()
+def health_check() -> dict:
+    """Health check: backend env status."""
+    backends = {}
+    for model in SUPPORTED_MODELS:
+        env_var = f"{model.upper()}_API_KEY"
+        backends[model] = {"env_set": bool((os.environ.get(env_var) or "").strip())}
+    return {
+        "status": "ok",
+        "host": platform.node(),
+        "python": platform.python_version(),
+        "backends": backends,
+    }
+
+
+def run():
+    """Run the MCP server over SSE transport."""
+    mcp.run(transport="sse")
+
+
+if __name__ == "__main__":
+    run()