bizonquant-mcp 0.1.0__py3-none-any.whl

bizonquant_mcp/__init__.py

@@ -0,0 +1,19 @@
+"""BizonQuant MCP server：把平台能力面（行情/多因子选股/回测）开放给外部 agent。
+
+客户端形态（调研报告 C 方案）：本包是 stdio MCP server，跑在用户本机，
+所有工具都是对公网网关 REST 的薄封装——服务器零常驻进程。
+"""
+
+from bizonquant_mcp.gateway import (
+    BizonQuantError,
+    CredentialError,
+    GatewayClient,
+)
+from bizonquant_mcp.version import __version__
+
+__all__ = [
+    "BizonQuantError",
+    "CredentialError",
+    "GatewayClient",
+    "__version__",
+]

bizonquant_mcp/__main__.py

@@ -0,0 +1,5 @@
+"""python -m bizonquant_mcp → stdio MCP server。"""
+
+from bizonquant_mcp.server import main
+
+main()

bizonquant_mcp/cli.py

@@ -0,0 +1,168 @@
+"""CLI：init / doctor / revoke——从零到可用全程不开前端。
+
+init    交互式录入 access_key/secret_key/base_url，写配置文件（0600），
+        并跑一遍 doctor 验证
+doctor  探链路：health → 换发 token → whoami → 数据覆盖摘要
+revoke  用同 key 再换发一次：互踢规则下同 key 旧会话全部失效
+        （key 本体的删除/停用需在桌面端或 API 管理）
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import stat
+import sys
+from pathlib import Path
+
+from bizonquant_mcp import __version__
+from bizonquant_mcp.gateway import DEFAULT_BASE_URL, BizonQuantError, GatewayClient
+
+CONFIG_PATH = (
+    Path(os.environ.get("BIZONQUANT_CONFIG", ""))
+    or Path.home() / ".config" / "bizonquant-mcp" / "config.json"
+)
+
+
+def _load_or_prompt(access: str | None, secret: str | None, base_url: str | None) -> tuple[str, str, str]:
+    env_access = os.environ.get("BIZONQUANT_ACCESS_KEY")
+    env_secret = os.environ.get("BIZONQUANT_SECRET_KEY")
+    access = access or env_access
+    secret = secret or env_secret
+    base_url = base_url or os.environ.get("BIZONQUANT_BASE_URL") or DEFAULT_BASE_URL
+
+    if not (access and secret) and CONFIG_PATH.exists():
+        cfg = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+        access = access or cfg.get("access_key")
+        secret = secret or cfg.get("secret_key")
+        base_url = base_url or cfg.get("base_url") or DEFAULT_BASE_URL
+
+    if not (access and secret):
+        if not sys.stdin.isatty():
+            raise BizonQuantError("非交互环境且未提供凭证（--access-key/--secret-key 或环境变量）")
+        print("BizonQuant MCP 凭证初始化")
+        print("（access_key/secret_key 在桌面端「API 密钥」页创建，permissions 勾选 mcp.read / mcp.write）")
+        access = access or input("access_key: ").strip()
+        secret = secret or input("secret_key: ").strip()
+        custom = input(f"base_url [{DEFAULT_BASE_URL}]: ").strip()
+        base_url = custom or base_url
+    return access, secret, base_url
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    access, secret, base_url = _load_or_prompt(args.access_key, args.secret_key, args.base_url)
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(
+        json.dumps(
+            {"access_key": access, "secret_key": secret, "base_url": base_url},
+            ensure_ascii=False,
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    CONFIG_PATH.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 0600：secret 落盘仅本人可读
+    print(f"配置已写入 {CONFIG_PATH}")
+    return cmd_doctor(args)
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    access, secret, base_url = _load_or_prompt(args.access_key, args.secret_key, args.base_url)
+    gw = GatewayClient(access_key=access, secret_key=secret, base_url=base_url)
+    ok = True
+
+    async def _run() -> None:
+        nonlocal ok
+
+        try:
+            resp = await gw._http.get("/health")
+            print(f"1) 网关可达：{base_url} → HTTP {resp.status_code}")
+        except Exception as exc:  # noqa: BLE001 - doctor 要把任何异常转成人话
+            print(f"1) 网关不可达：{exc}")
+            ok = False
+            return
+        try:
+            await gw._fetch_token()
+            print("2) agent-token 换发：成功（scope=agent）")
+        except Exception as exc:  # noqa: BLE001
+            print(f"2) agent-token 换发失败：{exc}")
+            ok = False
+            return
+        try:
+            me = await gw.get("/api/v1/users/me")
+            user = me
+            if isinstance(me, dict):
+                user = me.get("user") or me.get("data", {}).get("user") or me.get("data") or me
+            print(
+                f"3) whoami：{user.get('username', '?')}（tenant={user.get('tenant_id', '?')}）"
+                if isinstance(user, dict)
+                else f"3) whoami：{me}"
+            )
+        except Exception as exc:  # noqa: BLE001
+            print(f"3) whoami 失败：{exc}")
+            ok = False
+        try:
+            cov = await gw.get("/api/v1/selection/multi-factor/metadata")
+            keys = sorted(cov.keys()) if isinstance(cov, dict) else type(cov).__name__
+            print(f"4) 数据面 metadata：{keys}")
+        except Exception as exc:  # noqa: BLE001
+            print(f"4) 数据面不可用：{exc}")
+
+    import asyncio
+
+    asyncio.run(_run())
+    print("doctor: PASS" if ok else "doctor: FAIL")
+    return 0 if ok else 1
+
+
+def cmd_revoke(args: argparse.Namespace) -> int:
+    access, secret, base_url = _load_or_prompt(args.access_key, args.secret_key, args.base_url)
+    gw = GatewayClient(access_key=access, secret_key=secret, base_url=base_url)
+
+    async def _run() -> None:
+        # 同 key 再换发一次 → 互踢规则下该 key 的全部旧会话立即失效
+        await gw._fetch_token()
+        print("已换发新会话：同 key 的旧 agent token 全部 401。")
+        print("如需永久吊销，请在桌面端删除该 API Key。")
+
+    import asyncio
+
+    asyncio.run(_run())
+    return 0
+
+
+def main() -> None:
+    if len(sys.argv) == 1:
+        # 无参数（console script 默认）= 启动 MCP stdio server
+        from bizonquant_mcp.server import main as server_main
+
+        server_main()
+        return
+
+    parser = argparse.ArgumentParser(prog="bizonquant-mcp", description=__doc__)
+    parser.add_argument("--version", action="version", version=f"bizonquant-mcp {__version__}")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    def _common(p: argparse.ArgumentParser) -> None:
+        p.add_argument("--access-key", help="覆盖配置/环境变量")
+        p.add_argument("--secret-key", help="覆盖配置/环境变量")
+        p.add_argument("--base-url", help="覆盖配置/环境变量")
+
+    p_init = sub.add_parser("init", help="录入凭证写配置文件并自检")
+    _common(p_init)
+    p_init.set_defaults(func=cmd_init)
+
+    p_doc = sub.add_parser("doctor", help="探链路：health/token/whoami/数据面")
+    _common(p_doc)
+    p_doc.set_defaults(func=cmd_doctor)
+
+    p_rev = sub.add_parser("revoke", help="踢掉同 key 全部旧会话")
+    _common(p_rev)
+    p_rev.set_defaults(func=cmd_revoke)
+
+    args = parser.parse_args()
+    try:
+        sys.exit(args.func(args))
+    except BizonQuantError as exc:
+        print(f"错误：{exc}", file=sys.stderr)
+        sys.exit(2)

bizonquant_mcp/common.py

@@ -0,0 +1,38 @@
+"""工具公共件：响应解包与输出裁剪（移植 QuantBot TS 工具语义）。"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+
+def unwrap(data: Any) -> Any:
+    """网关两种响应包装：{code,message,data:{...}} 与顶层平铺——统一取载荷。"""
+    if isinstance(data, dict) and "data" in data and isinstance(data["data"], dict):
+        inner = data["data"]
+        # 防误伤：business payload 里也可能有 data 键（如 klines bars），
+        # 仅当外层像标准包装（有 code/message 或唯一 data 键）时才解包
+        if "code" in data or "message" in data or set(data) == {"data"}:
+            return inner
+    return data
+
+
+def trim_curve(points: list[Any], max_points: int = 120) -> list[Any]:
+    """曲线抽样：≤max_points 原样返回，超过等距抽 max_points 点（保首尾）。"""
+    if len(points) <= max_points:
+        return points
+    step = (len(points) - 1) / (max_points - 1)
+    return [points[round(i * step)] for i in range(max_points)]
+
+
+def sma(values: list[float], window: int) -> float | None:
+    """简单均线；样本不足返回 None。"""
+    if len(values) < window:
+        return None
+    return sum(values[-window:]) / window
+
+
+def safe_round(value: float | None, digits: int = 4) -> float | None:
+    if value is None or (isinstance(value, float) and math.isnan(value)):
+        return None
+    return round(value, digits)

bizonquant_mcp/gateway.py

@@ -0,0 +1,166 @@
+"""网关 HTTP 客户端：token 换发缓存、401 纪律、错误映射。
+
+客户端纪律（调研报告 §4 阶段 1）：
+- 默认拒绝 http:// 明文（只走 TLS 网关；明文中间盒改写 UA 的既有事故）
+- token 只放 Authorization 头，不进 query
+- 401 且 token 已尽力刷新过一次仍 401 → 停（防密码锁定类风暴；agent-token
+  无密码锁定，但 key 撤销后的连续换发同样是无意义风暴）
+- UA 带包版本，便于服务端审计区分
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+import httpx
+
+from bizonquant_mcp.version import __version__
+
+DEFAULT_BASE_URL = "https://bizon.naiyu.xyz:8443"
+
+# access token 官方有效期 120 分钟；提前 5 分钟换发，避免边界 401
+TOKEN_REFRESH_MARGIN_S = 300
+
+
+class BizonQuantError(RuntimeError):
+    """工具层统一错误：MCP 把 message 透传给 agent。"""
+
+
+class CredentialError(BizonQuantError):
+    """key/secret 无效、账号被禁用或 key 被撤销——换发重试无意义。"""
+
+
+class GatewayClient:
+    """对公网网关的异步 REST 客户端，持 API Key 并缓存换发的 agent token。"""
+
+    def __init__(
+        self,
+        *,
+        access_key: str,
+        secret_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        allow_insecure_http: bool = False,
+        timeout_s: float = 30.0,
+    ) -> None:
+        self._access_key = access_key.strip()
+        self._secret_key = secret_key.strip()
+        base_url = base_url.strip().rstrip("/")
+        if base_url.startswith("http://") and not allow_insecure_http:
+            raise BizonQuantError(
+                f"拒绝明文 http:// 网关地址（{base_url}）：中间盒可能改写请求。"
+                "只走 https://；确有内网明文需求请设 BIZONQUANT_ALLOW_INSECURE=1"
+            )
+        self._base_url = base_url
+        self._http = httpx.AsyncClient(
+            base_url=base_url,
+            timeout=timeout_s,
+            headers={"User-Agent": f"bizonquant-mcp/{__version__}"},
+        )
+        self._token: str | None = None
+        self._token_exp: float = 0.0
+        self._refresh_lock = asyncio.Lock()
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    @property
+    def base_url(self) -> str:
+        return self._base_url
+
+    # ── token 换发 ────────────────────────────────────────────────────────
+
+    async def _fetch_token(self) -> None:
+        resp = await self._http.post(
+            "/api/v1/auth/agent-token",
+            json={"access_key": self._access_key, "secret_key": self._secret_key},
+        )
+        if resp.status_code in (401, 403):
+            raise CredentialError(
+                f"API Key 无效或被撤销（HTTP {resp.status_code}）：{resp.text[:200]}"
+            )
+        if resp.status_code == 429:
+            raise BizonQuantError(f"换发限流（HTTP 429）：{resp.text[:200]}")
+        resp.raise_for_status()
+        data = resp.json()
+        self._token = data["access_token"]
+        # JWT exp claim 是权威有效期；缺失时退回 2 小时（网关官方口径）
+        claims = _decode_jwt_claims(self._token)
+        exp = claims.get("exp")
+        self._token_exp = float(exp) if exp else time.time() + 7200
+
+    async def _ensure_token(self) -> str:
+        if self._token and time.time() < self._token_exp - TOKEN_REFRESH_MARGIN_S:
+            return self._token
+        async with self._refresh_lock:
+            # 双检：等锁期间别的协程可能已换好
+            if self._token and time.time() < self._token_exp - TOKEN_REFRESH_MARGIN_S:
+                return self._token
+            await self._fetch_token()
+            assert self._token is not None
+            return self._token
+
+    # ── 请求 ─────────────────────────────────────────────────────────────
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: dict[str, Any] | None = None,
+    ) -> Any:
+        """发起网关请求并返回 JSON 载荷；401 时换发重试一次。"""
+        token = await self._ensure_token()
+        resp = await self._http.request(
+            method,
+            path,
+            params=params,
+            json=json_body,
+            headers={"Authorization": f"Bearer {token}"},
+        )
+        if resp.status_code == 401:
+            # token 过期或会话被撤（删 key/轮换）：换发一次再试；
+            # 仍 401 说明 key 本身已失效，停手
+            await self._fetch_token()
+            resp = await self._http.request(
+                method,
+                path,
+                params=params,
+                json=json_body,
+                headers={"Authorization": f"Bearer {self._token}"},
+            )
+            if resp.status_code == 401:
+                raise CredentialError("API Key 已失效（换发后仍 401），请检查 key 状态")
+        if resp.status_code == 403:
+            raise BizonQuantError(
+                f"网关拒绝该操作（403，agent token 能力面限制）：{resp.text[:200]}"
+            )
+        if resp.status_code >= 400:
+            # 后端校验错误（422 等）的 detail 对 agent 修正参数至关重要，必须透传
+            raise BizonQuantError(
+                f"网关返回 HTTP {resp.status_code}：{resp.text[:500]}"
+            )
+        if not resp.content:
+            return None
+        return resp.json()
+
+    async def get(self, path: str, **kwargs: Any) -> Any:
+        return await self.request("GET", path, **kwargs)
+
+    async def post(self, path: str, *, json_body: dict[str, Any], **kwargs: Any) -> Any:
+        return await self.request("POST", path, json_body=json_body, **kwargs)
+
+
+def _decode_jwt_claims(token: str) -> dict[str, Any]:
+    """解 JWT payload（不验签——TLS 信道内自己刚拿到的 token，无需验）。"""
+    import base64
+    import json
+
+    try:
+        payload = token.split(".")[1]
+        payload += "=" * (-len(payload) % 4)
+        return json.loads(base64.urlsafe_b64decode(payload))
+    except Exception:
+        return {}

bizonquant_mcp/server.py

@@ -0,0 +1,71 @@
+"""FastMCP 实例组装：stdio 入口 + 工具注册。
+
+本 server 是纯能力面——会话管理归外部 agent 宿主（Claude Code / Cursor 等）。
+凭证走环境变量：BIZONQUANT_ACCESS_KEY + BIZONQUANT_SECRET_KEY
+（或 BIZONQUANT_API_KEY=access_key.secret_key）。
+"""
+
+from __future__ import annotations
+
+import os
+
+from mcp.server.mcpserver import MCPServer
+
+from bizonquant_mcp.gateway import DEFAULT_BASE_URL, BizonQuantError, GatewayClient
+from bizonquant_mcp.version import __version__
+from bizonquant_mcp.tools import backtest, market, screening
+
+
+def credentials_from_env() -> tuple[str, str, str]:
+    """(access_key, secret_key, base_url)；缺失即抛，让进程启动就失败。"""
+    access = os.environ.get("BIZONQUANT_ACCESS_KEY", "").strip()
+    secret = os.environ.get("BIZONQUANT_SECRET_KEY", "").strip()
+    if not access and not secret:
+        # 兼容单变量形式 access_key.secret_key（以首次出现的 . 为界）
+        combined = os.environ.get("BIZONQUANT_API_KEY", "").strip()
+        if combined and "." in combined:
+            access, secret = combined.split(".", 1)
+    if not access or not secret:
+        raise BizonQuantError(
+            "缺少凭证：请设置 BIZONQUANT_ACCESS_KEY 与 BIZONQUANT_SECRET_KEY"
+            "（或 BIZONQUANT_API_KEY=access_key.secret_key）；"
+            "用 bizonquant-mcp init 生成配置后按提示写入 mcpServers env"
+        )
+    base_url = os.environ.get("BIZONQUANT_BASE_URL", DEFAULT_BASE_URL)
+    return access, secret, base_url
+
+
+def create_server() -> MCPServer:
+    access, secret, base_url = credentials_from_env()
+    gw = GatewayClient(
+        access_key=access,
+        secret_key=secret,
+        base_url=base_url,
+        allow_insecure_http=os.environ.get("BIZONQUANT_ALLOW_INSECURE") == "1",
+    )
+
+    mcp: MCPServer = MCPServer(
+        "bizonquant",
+        instructions=(
+            "BizonQuant 量化平台能力面：股票搜索、K 线行情、多因子即时选股、"
+            "选股方案管理、多因子回测。回测为异步任务：submit_backtest 提交后用 "
+            "wait_backtest（有界等待，done:false 时续调）或 get_backtest_status 轮询。\n"
+            "纪律：工具未返回 = 没发生；backtest_id 只认工具返回值；"
+            "回测日期先查 get_data_coverage；选股条件里的因子名只认 list_factors。"
+        ),
+        version=__version__,
+    )
+
+    market.register(mcp, gw)
+    screening.register(mcp, gw)
+    backtest.register(mcp, gw)
+    return mcp
+
+
+def main() -> None:
+    server = create_server()
+    server.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

bizonquant_mcp/tools/__init__.py

@@ -0,0 +1,3 @@
+"""工具注册聚合。"""
+
+from bizonquant_mcp.tools import backtest, market, screening  # noqa: F401

bizonquant_mcp/tools/backtest.py

@@ -0,0 +1,203 @@
+"""回测工具：submit_backtest / wait_backtest / get_backtest_status / get_backtest_result / list_backtests。
+
+异步回测全景（调研 §2）：submit 入 Celery 队列 → 结果落 PG → 进度走 Redis。
+wait_backtest 单次 ≤50s 有界轮询（宿主工具超时通常 60s），done:false 续调。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+from bizonquant_mcp.common import trim_curve, unwrap
+from bizonquant_mcp.gateway import GatewayClient
+
+# 与宿主工具超时（60s）保持安全距离
+WAIT_BUDGET_S = 50.0
+POLL_INTERVAL_S = 3.0
+# queued 超 30 分钟无进展提示队列疑似停摆（celery 宕机后 queued 行永不判死）
+STALLED_QUEUED_S = 1800.0
+
+_TERMINAL = {"completed", "success", "failed", "error", "cancelled", "aborted"}
+
+
+async def submit_backtest(
+    gw: GatewayClient,
+    config: dict[str, Any],
+    start_date: str,
+    end_date: str,
+    engine_config: dict[str, Any] | None = None,
+    strategy_name: str = "多因子选股",
+    strategy_id: str | None = None,
+) -> dict[str, Any]:
+    """提交多因子正式回测（写操作：入队，不阻塞等待结果）。"""
+    body: dict[str, Any] = {
+        "config": config,
+        "date_range": {"start_date": start_date, "end_date": end_date},
+        "engine_config": engine_config or {},
+        "strategy_name": strategy_name,
+    }
+    if strategy_id:
+        body["strategy_id"] = strategy_id
+    data = await gw.post(
+        "/api/v1/selection/multi-factor/structured-backtest/submit",
+        json_body=body,
+    )
+    data = unwrap(data)
+    if not isinstance(data, dict):
+        return {"raw": data}
+    return {
+        "backtest_id": data.get("backtest_id") or data.get("id"),
+        "status": data.get("status", "queued"),
+        "message": data.get("message", "已提交，用 wait_backtest 或 get_backtest_status 跟进"),
+    }
+
+
+async def get_backtest_status(gw: GatewayClient, backtest_id: str) -> dict[str, Any]:
+    """单次查回测状态（阶段标签 + 排队位次）。"""
+    data = await gw.get(f"/api/v1/backtests/{backtest_id}")
+    data = unwrap(data)
+    if not isinstance(data, dict):
+        return {"raw": data}
+    return {
+        "backtest_id": backtest_id,
+        "status": data.get("status"),
+        "stage": data.get("stage"),
+        "queue_position": data.get("queue_position"),
+        "progress": data.get("progress"),
+        "error": data.get("error"),
+    }
+
+
+async def wait_backtest(
+    gw: GatewayClient, backtest_id: str, queued_since_s: float = 0.0
+) -> dict[str, Any]:
+    """有界阻塞等待回测终态（单次 ≤50s）。done:false 时续调本工具。
+
+    queued_since_s 由调用方累计：同一回测多次续调时传入，用于发现
+    队列停摆（celery 宕机后 queued 行永不判死）。
+    """
+    deadline = time.monotonic() + WAIT_BUDGET_S
+    status = "unknown"
+    last: dict[str, Any] = {}
+    while time.monotonic() < deadline:
+        last = await get_backtest_status(gw, backtest_id)
+        status = str(last.get("status") or "").lower()
+        if status in _TERMINAL:
+            return {**last, "done": True}
+        await asyncio.sleep(POLL_INTERVAL_S)
+    if status == "queued" and queued_since_s >= STALLED_QUEUED_S:
+        last["warning"] = (
+            f"已 queued 超 {int(queued_since_s / 60)} 分钟无进展：队列疑似停摆"
+            "（celery 宕机后排队任务不会自动判死），建议人工检查服务端"
+        )
+    return {**last, "done": False, "queued_since_s": queued_since_s + WAIT_BUDGET_S}
+
+
+async def get_backtest_result(
+    gw: GatewayClient, backtest_id: str, max_curve_points: int = 120
+) -> dict[str, Any]:
+    """回测结果：指标全量，曲线抽样（≤max_curve_points 点），逐笔截尾。"""
+    data = await gw.get(f"/api/v1/backtests/{backtest_id}/result")
+    data = unwrap(data)
+    if not isinstance(data, dict):
+        return {"raw": data}
+    out: dict[str, Any] = {
+        "backtest_id": backtest_id,
+        "status": data.get("status"),
+        "metrics": data.get("metrics") or data.get("summary") or {},
+    }
+    for key in ("equity_curve", "nav_curve", "curve", "benchmark_curve"):
+        curve = data.get(key)
+        if isinstance(curve, list):
+            out[key] = trim_curve(curve, max_curve_points)
+    trades = data.get("trades") or data.get("records")
+    if isinstance(trades, list):
+        out["trades_head"] = trades[:50]
+        out["trades_count"] = len(trades)
+    for key in ("factor_report", "turnover", "logs", "positions", "error"):
+        if data.get(key) is not None:
+            out[key] = data[key]
+    return out
+
+
+async def list_backtests(
+    gw: GatewayClient,
+    engine_type: str = "structured_multi_factor",
+    strategy_type: str | None = None,
+    limit: int = 20,
+) -> list[dict[str, Any]]:
+    """回测历史（按提交时间倒序）。engine_type 必填：structured_multi_factor /
+    multi_factor_timing 等。"""
+    params: dict[str, Any] = {"engine_type": engine_type, "limit": limit}
+    if strategy_type:
+        params["strategy_type"] = strategy_type
+    data = await gw.get("/api/v1/backtests", params=params)
+    data = unwrap(data)
+    items = data if isinstance(data, list) else data.get("backtests", data.get("items", []))
+    return [
+        {
+            "backtest_id": b.get("backtest_id") or b.get("id"),
+            "strategy_name": b.get("strategy_name"),
+            "strategy_type": b.get("strategy_type"),
+            "status": b.get("status"),
+            "date_range": b.get("date_range"),
+            "created_at": b.get("created_at"),
+            "metrics": b.get("metrics") or {},
+        }
+        for b in items or []
+    ]
+
+
+def register(mcp: Any, gw: GatewayClient) -> None:
+    """把本组工具注册进 MCPServer 实例。"""
+
+    @mcp.tool()
+    async def submit_backtest_tool(
+        config: dict[str, Any],
+        start_date: str,
+        end_date: str,
+        engine_config: dict[str, Any] | None = None,
+        strategy_name: str = "多因子选股",
+        strategy_id: str | None = None,
+    ) -> dict[str, Any]:
+        """提交多因子正式回测（异步任务，返回即入队）。
+
+        config 同 screen_stocks_tool；日期先过 get_data_coverage_tool 与
+        get_trading_day_info_tool（两端必须为交易日）。提交后用
+        wait_backtest_tool 等结果。backtest_id 只认本工具返回值。
+        """
+        return await submit_backtest(
+            gw, config, start_date, end_date, engine_config, strategy_name, strategy_id
+        )
+
+    @mcp.tool()
+    async def wait_backtest_tool(
+        backtest_id: str, queued_since_s: float = 0.0
+    ) -> dict[str, Any]:
+        """有界阻塞等待回测终态（单次 ≤50s）。
+
+        done:false 表示未到终态，续调本工具并把返回的 queued_since_s 传回；
+        queued 超 30 分钟会提示队列疑似停摆。
+        """
+        return await wait_backtest(gw, backtest_id, queued_since_s)
+
+    @mcp.tool()
+    async def get_backtest_status_tool(backtest_id: str) -> dict[str, Any]:
+        """单次查回测状态（阶段标签 + 排队位次），不想阻塞等待时用。"""
+        return await get_backtest_status(gw, backtest_id)
+
+    @mcp.tool()
+    async def get_backtest_result_tool(
+        backtest_id: str, max_curve_points: int = 120
+    ) -> dict[str, Any]:
+        """取回测结果：指标全量，资金曲线等距抽样（默认 120 点），逐笔截尾 50 笔。"""
+        return await get_backtest_result(gw, backtest_id, max_curve_points)
+
+    @mcp.tool()
+    async def list_backtests_tool(
+        engine_type: str = "structured_multi_factor", limit: int = 20
+    ) -> list[dict[str, Any]]:
+        """回测历史（倒序）。engine_type：structured_multi_factor / multi_factor_timing。"""
+        return await list_backtests(gw, engine_type, limit=limit)

bizonquant_mcp/tools/market.py

@@ -0,0 +1,210 @@
+"""行情与基础工具：search_stocks / get_daily_klines / get_me / get_trading_day_info / get_data_coverage。
+
+get_daily_klines 移植 QuantBot 的区间摘要语义：往前多拉 100 自然日热身 bar
+算 MA20/MA60，热身段不进返回——「走势怎么样」「站没站上均线」直接读摘要。
+"""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timedelta
+from typing import Any
+
+from bizonquant_mcp.common import safe_round, sma, trim_curve, unwrap
+from bizonquant_mcp.gateway import GatewayClient
+
+_WARMUP_DAYS = 100  # 与 QuantBot TS 对齐：60 根日线均线 ≈ 90 自然日 + 缓冲
+_MAX_BARS_OUT = 250
+
+
+async def get_me(gw: GatewayClient) -> dict[str, Any]:
+    data = await gw.get("/api/v1/users/me")
+    user = unwrap(data)
+    if isinstance(user, dict) and "user" in user:
+        user = user["user"]
+    return user if isinstance(user, dict) else {"raw": user}
+
+
+async def search_stocks(
+    gw: GatewayClient, query: str, limit: int = 20
+) -> list[dict[str, Any]]:
+    data = await gw.get(
+        "/api/v1/stocks/search", params={"q": query, "limit": min(limit, 200)}
+    )
+    data = unwrap(data)
+    results = data.get("results", []) if isinstance(data, dict) else data
+    return [
+        {
+            "symbol": r.get("symbol"),
+            "name": r.get("name"),
+            "market": r.get("market"),
+            "price": r.get("price") or r.get("closePrice"),
+        }
+        for r in (results or [])[:limit]
+    ]
+
+
+async def get_trading_day_info(
+    gw: GatewayClient, date: str | None = None, market: str = "SSE"
+) -> dict[str, Any]:
+    date = date or datetime.now().strftime("%Y-%m-%d")
+    params = {"market": market, "date": date}
+    is_trading = await gw.get(
+        "/api/v1/market-calendar/is-trading-day", params=params
+    )
+    next_day = await gw.get("/api/v1/market-calendar/next-trading-day", params=params)
+    prev_day = await gw.get("/api/v1/market-calendar/prev-trading-day", params=params)
+    return {
+        "date": date,
+        "market": market,
+        "is_trading_day": is_trading.get("is_trading_day")
+        if isinstance(is_trading, dict)
+        else None,
+        "next_trading_day": next_day.get("next_trading_day")
+        if isinstance(next_day, dict)
+        else None,
+        "prev_trading_day": prev_day.get("prev_trading_day")
+        if isinstance(prev_day, dict)
+        else None,
+    }
+
+
+async def get_data_coverage(gw: GatewayClient) -> dict[str, Any]:
+    """数据覆盖区间/可用因子数/股票池——回测日期边界的唯一合法来源。"""
+    metadata = await gw.get("/api/v1/selection/multi-factor/metadata")
+    meta = unwrap(metadata)
+    if not isinstance(meta, dict):
+        return {"raw": meta}
+    out: dict[str, Any] = {}
+    cov = meta.get("data_coverage")
+    if isinstance(cov, dict):
+        out["data_coverage"] = cov
+    factors = meta.get("factors")
+    if isinstance(factors, list):
+        out["factor_count"] = len(factors)
+    if meta.get("universe_presets"):
+        out["universe_presets"] = meta["universe_presets"]
+    if not out:
+        out = {"keys": sorted(meta.keys())}
+    return out
+
+
+async def get_daily_klines(
+    gw: GatewayClient,
+    symbol: str,
+    start_date: str,
+    end_date: str | None = None,
+    interval: str = "1d",
+) -> dict[str, Any]:
+    """K 线 + 区间摘要。热身段只用于均线，不出现在 bars 里。"""
+    end_date = end_date or datetime.now().strftime("%Y-%m-%d")
+    warm_start = (
+        datetime.strptime(start_date, "%Y-%m-%d") - timedelta(days=_WARMUP_DAYS)
+    ).strftime("%Y-%m-%d")
+
+    data = await gw.get(
+        f"/api/v1/market/klines/{symbol}",
+        params={
+            "start": warm_start,
+            "end": end_date,
+            "interval": interval,
+            "source": "auto",
+        },
+    )
+    data = unwrap(data)
+    bars: list[dict[str, Any]] = data.get("bars", []) if isinstance(data, dict) else []
+    # 均线必须用含热身的全量收盘价——先算再裁剪，顺序不能反
+    warm_closes = [float(b["close"]) for b in bars if b.get("close") is not None]
+    ma20_warm = sma(warm_closes, 20)
+    ma60_warm = sma(warm_closes, 60)
+    if interval == "1d":
+        bars = [b for b in bars if b.get("date") and b["date"] >= start_date]
+    closes = [float(b["close"]) for b in bars if b.get("close") is not None]
+
+    summary: dict[str, Any] = {"symbol": symbol, "interval": interval}
+    if closes:
+        last = closes[-1]
+        first = closes[0]
+        summary.update(
+            {
+                "bar_count": len(closes),
+                "first_date": bars[0].get("date"),
+                "last_date": bars[-1].get("date"),
+                "latest_close": safe_round(last),
+                "period_change_pct": safe_round((last / first - 1) * 100, 2),
+                "period_high": safe_round(max(float(b["high"]) for b in bars if b.get("high") is not None)),
+                "period_low": safe_round(min(float(b["low"]) for b in bars if b.get("low") is not None)),
+            }
+        )
+        summary["ma20"] = safe_round(ma20_warm)
+        summary["ma60"] = safe_round(ma60_warm)
+        if ma60_warm is not None:
+            summary["above_ma60"] = last > ma60_warm
+        if ma20_warm is not None:
+            summary["above_ma20"] = last > ma20_warm
+    coverage = data.get("coverage") if isinstance(data, dict) else None
+    if isinstance(coverage, dict):
+        summary["coverage"] = {
+            k: coverage.get(k)
+            for k in ("local_min", "local_max", "actual_start", "actual_end", "missing_head", "missing_tail")
+            if k in coverage
+        }
+    out_bars = trim_curve(
+        [
+            {k: b.get(k) for k in ("date", "timestamp", "open", "high", "low", "close", "volume") if k in b}
+            for b in bars
+        ],
+        _MAX_BARS_OUT,
+    )
+    return {"summary": summary, "bars": out_bars}
+
+
+def register(mcp: Any, gw: GatewayClient) -> None:
+    """把本组工具注册进 FastMCP 实例。"""
+
+    @mcp.tool()
+    async def get_me_tool() -> dict[str, Any]:
+        """当前登录用户信息。同时是凭证探针：连不上/凭证无效会在这里暴露。"""
+        return await get_me(gw)
+
+    @mcp.tool()
+    async def search_stocks_tool(query: str, limit: int = 20) -> list[dict[str, Any]]:
+        """按代码/名称/拼音搜索股票，把模糊输入归一成规范代码（symbol）。
+
+        其它工具的 symbol 参数一律以此工具返回的规范代码为准。
+        """
+        return await search_stocks(gw, query, limit)
+
+    @mcp.tool()
+    async def get_trading_day_info_tool(
+        date: str | None = None, market: str = "SSE"
+    ) -> dict[str, Any]:
+        """判断某日是否交易日，并给出上一/下一交易日。
+
+        所有日期类参数（回测区间、as_of_date）都应先来这里锚定。
+        """
+        return await get_trading_day_info(gw, date, market)
+
+    @mcp.tool()
+    async def get_data_coverage_tool() -> dict[str, Any]:
+        """查数据覆盖区间、可用因子数与股票池预设。
+
+        回测日期与选股 as_of_date 的边界来源：日期超出覆盖区间必失败，
+        先查这里再提交。
+        """
+        return await get_data_coverage(gw)
+
+    @mcp.tool()
+    async def get_daily_klines_tool(
+        symbol: str,
+        start_date: str,
+        end_date: str | None = None,
+        interval: str = "1d",
+    ) -> dict[str, Any]:
+        """个股 K 线（默认日线），先读 summary 再看 bars。
+
+        summary 含区间涨跌幅/高低点/最新收盘/MA20/MA60/是否站上均线——
+        「走势怎么样」「站没站上 60 日线」直接读 summary，不必逐根分析 bars；
+        bars 超过 250 根时等距抽样。interval 支持 1d/60m/30m/15m/5m。
+        """
+        return await get_daily_klines(gw, symbol, start_date, end_date, interval)

bizonquant_mcp/tools/screening.py

@@ -0,0 +1,181 @@
+"""选股与策略工具：list_factors / screen_stocks / list_presets / save_preset / list_my_strategies。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from bizonquant_mcp.common import unwrap
+from bizonquant_mcp.gateway import GatewayClient
+
+# 本地取值语义覆盖：后端 usage 描述缺这些关键口径（与 QuantBot TS 对齐）
+_FACTOR_USAGE_OVERRIDES: dict[str, str] = {
+    "moving_average_trend": (
+        "取值是 MA短/MA长 − 1（量级 ±0.1），不是 0/1 布尔。"
+        "「MA5 在 MA60 上方」写 ma_distance(window=60) gte 0，"
+        "不要写 moving_average_trend gte 1（等于要求 MA5 是 MA60 两倍，必然 0 只）"
+    ),
+    "ma_distance": "现价距 N 日均线的比例；「站上 N 日线」= ma_distance(window=N) gte 0",
+    "price_momentum": "区间收益动量，量级 ±0.5；>0 为上涨动能",
+    "volume_momentum": "量能动量；>0 为放量",
+    "ma_trend": "均线斜率方向；>0 为多头排列",
+}
+
+
+async def list_factors(gw: GatewayClient) -> dict[str, Any]:
+    """因子目录：名称/方向/参数/取值语义。因子名的唯一合法来源。"""
+    data = await gw.get("/api/v1/selection/multi-factor/factors")
+    data = unwrap(data)
+    factors = data.get("factors", data) if isinstance(data, dict) else data
+    out: list[dict[str, Any]] = []
+    for f in factors or []:
+        if not isinstance(f, dict):
+            continue
+        name = f.get("name") or f.get("factor")
+        item = dict(f)
+        if name in _FACTOR_USAGE_OVERRIDES and not item.get("value_hint"):
+            item["value_hint"] = _FACTOR_USAGE_OVERRIDES[name]
+        out.append(item)
+    catalog = unwrap(await gw.get("/api/v1/selection/multi-factor/sectors"))
+    return {
+        "factors": out,
+        "sector_catalog": catalog if isinstance(catalog, dict) else None,
+        "value_hints": _FACTOR_USAGE_OVERRIDES,
+    }
+
+
+async def screen_stocks(
+    gw: GatewayClient,
+    config: dict[str, Any],
+    as_of_date: str | None = None,
+    limit: int = 20,
+) -> dict[str, Any]:
+    """即时截面选股。返回前 limit 只，附排序/过滤因子的当期值。"""
+    body: dict[str, Any] = {"config": config}
+    if as_of_date:
+        body["as_of_date"] = as_of_date
+    data = await gw.post(
+        "/api/v1/selection/multi-factor/screen", json_body=body
+    )
+    data = unwrap(data)
+    if not isinstance(data, dict):
+        return {"raw": data}
+    stocks = data.get("stocks") or data.get("results") or []
+    # 剔除后端「结果共 N 条仅返回前 M 条」类冗余告警——passed_count 已表达
+    warnings = [
+        w
+        for w in (data.get("warnings") or [])
+        if not (isinstance(w, str) and "仅返回前" in w)
+    ]
+    limit_ = max(1, min(limit, 100))
+    items = stocks[:limit_]
+    # 附带策略用到的因子值：排序因子 + 各类过滤条件的因子（对齐
+    # StructuredStrategyConfig：sorting.rules / technical / fundamental_filters / special_indicators）
+    wanted: list[str] = []
+    for rule in (config.get("sorting") or {}).get("rules") or []:
+        if isinstance(rule, dict) and rule.get("factor_name"):
+            wanted.append(rule["factor_name"])
+    for cond_key in ("technical", "fundamental_filters", "special_indicators", "fundamental"):
+        for cond in config.get(cond_key) or []:
+            if isinstance(cond, dict) and cond.get("factor_name"):
+                wanted.append(cond["factor_name"])
+    for s in items:
+        values = s.get("factor_values")
+        if not isinstance(values, dict):
+            values = s.get("factors") if isinstance(s.get("factors"), dict) else {}
+        s["factor_values"] = {f: values.get(f) for f in dict.fromkeys(wanted)}
+    return {
+        "passed_count": data.get("passed_count", data.get("total", len(stocks))),
+        "returned_count": len(items),
+        "as_of_date": data.get("as_of_date") or as_of_date,
+        "stocks": items,
+        "warnings": warnings,
+    }
+
+
+async def list_presets(gw: GatewayClient) -> list[dict[str, Any]]:
+    """列出用户多因子选股方案（含 config/date_range，供提交回测取用）。"""
+    data = await gw.get("/api/v1/selection/multi-factor/presets")
+    data = unwrap(data)
+    return data if isinstance(data, list) else data.get("presets", [])
+
+
+async def save_preset(
+    gw: GatewayClient,
+    name: str,
+    config: dict[str, Any],
+    date_range: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    """把多因子配置保存为选股方案（写操作：只写用户自己的方案列表）。"""
+    body: dict[str, Any] = {"name": name, "config": config}
+    if date_range:
+        body["date_range"] = date_range
+    data = await gw.post("/api/v1/selection/multi-factor/presets", json_body=body)
+    return unwrap(data)
+
+
+async def list_my_strategies(gw: GatewayClient) -> list[dict[str, Any]]:
+    """用户全部策略（多因子/组合/轮动）及运行状态。"""
+    data = await gw.get("/api/v1/strategies")
+    data = unwrap(data)
+    items = data if isinstance(data, list) else data.get("strategies", data.get("items", []))
+    return [
+        {
+            "strategy_id": s.get("strategy_id") or s.get("id"),
+            "name": s.get("name") or s.get("strategy_name"),
+            "type": s.get("type") or s.get("strategy_type"),
+            "status": s.get("status"),
+            "mode": s.get("mode"),
+        }
+        for s in items or []
+    ]
+
+
+def register(mcp: Any, gw: GatewayClient) -> None:
+    """把本组工具注册进 MCPServer 实例。"""
+
+    @mcp.tool()
+    async def list_factors_tool() -> dict[str, Any]:
+        """查因子目录：因子名/方向/参数/取值语义。因子名的唯一合法来源。
+
+        value_hint 覆盖了高频踩坑口径：moving_average_trend 是 MA短/MA长−1
+        的比值（量级 ±0.1）不是 0/1 布尔；「站上 N 日线」= ma_distance
+        window=N gte 0。选股条件里的因子必须出自本目录。
+        """
+        return await list_factors(gw)
+
+    @mcp.tool()
+    async def screen_stocks_tool(
+        config: dict[str, Any], as_of_date: str | None = None, limit: int = 20
+    ) -> dict[str, Any]:
+        """即时截面选股（无副作用查询）。
+
+        config 为 StructuredStrategyConfig：universe_preset（hs300/all_a 等，
+        见 get_data_coverage_tool）、technical/fundamental_filters 条件
+        （{factor_name, params, operator, value}）、sorting.rules 排序
+        （{factor_name, weight, direction: higher_better|lower_better}）。
+        返回前 limit 只并附策略涉及的因子当期值（取不到为 null）。
+        as_of_date 用交易日（先问 get_trading_day_info_tool）。
+        """
+        return await screen_stocks(gw, config, as_of_date, limit)
+
+    @mcp.tool()
+    async def list_presets_tool() -> list[dict[str, Any]]:
+        """列出用户已保存的多因子选股方案（含 config 与默认回测区间）。"""
+        return await list_presets(gw)
+
+    @mcp.tool()
+    async def save_preset_tool(
+        name: str,
+        config: dict[str, Any],
+        date_range: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """把多因子配置保存为选股方案（写操作，仅写用户自己的方案列表）。
+
+        date_range 形如 {"start_date": "2023-01-01", "end_date": "2026-08-28"}。
+        """
+        return await save_preset(gw, name, config, date_range)
+
+    @mcp.tool()
+    async def list_my_strategies_tool() -> list[dict[str, Any]]:
+        """列出用户全部策略（多因子/组合/轮动）及运行状态。"""
+        return await list_my_strategies(gw)

bizonquant_mcp/version.py

@@ -0,0 +1,3 @@
+"""包版本（独立模块避免 __init__ ↔ gateway 循环导入）。"""
+
+__version__ = "0.1.0"

bizonquant_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: bizonquant-mcp
+Version: 0.1.0
+Summary: BizonQuant MCP server —— 把量化能力面（行情/多因子选股/回测）开放给外部 agent
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.9
+Description-Content-Type: text/markdown
+
+# bizonquant-mcp
+
+BizonQuant 量化平台的 MCP server（客户端形态）：跑在你本机，把平台能力面开放给外部 agent（Claude Code / Cursor / Codex / 自写 agent），**服务器零常驻进程、不开前端**。
+
+## 能力（首期 15 工具）
+
+| 组 | 工具 | 说明 |
+|---|---|---|
+| 锚点 | `get_me_tool` | 当前用户；凭证探针 |
+| 锚点 | `get_trading_day_info_tool` | 交易日判断 + 上/下一交易日 |
+| 锚点 | `get_data_coverage_tool` | 数据覆盖/因子数/股票池——回测日期边界来源 |
+| 行情 | `search_stocks_tool` | 模糊名 → 规范代码 |
+| 行情 | `get_daily_klines_tool` | K 线 + 区间摘要（涨跌/高低/MA20/MA60/站上均线） |
+| 选股 | `list_factors_tool` | 因子目录 + 取值语义（防条件翻译错） |
+| 选股 | `screen_stocks_tool` | 即时截面选股，附因子值 |
+| 选股 | `list_presets_tool` / `save_preset_tool` | 方案列表 / 存方案 |
+| 回测 | `submit_backtest_tool` | 提交多因子回测（异步） |
+| 回测 | `wait_backtest_tool` | 有界等待（≤50s），done:false 续调 |
+| 回测 | `get_backtest_status_tool` / `get_backtest_result_tool` / `list_backtests_tool` | 状态 / 结果（曲线抽样）/ 历史 |
+| 总览 | `list_my_strategies_tool` | 全部策略与运行状态 |
+
+## 安装与运行
+
+```bash
+# 从仓库根
+cd mcp-server && uv sync
+uv run bizonquant-mcp init     # 录入 key 并自检（写入 ~/.config/bizonquant-mcp/config.json，0600）
+uv run bizonquant-mcp doctor   # 探链路：health / token / whoami / 数据面
+```
+
+## 接入 Claude Code（stdio）
+
+```jsonc
+// ~/.claude.json 的 mcpServers
+"bizonquant": {
+  "command": "uv",
+  "args": ["--directory", "<仓库路径>/mcp-server", "run", "bizonquant-mcp"],
+  "env": {
+    "BIZONQUANT_ACCESS_KEY": "qm_live_xxx",
+    "BIZONQUANT_SECRET_KEY": "sk_yyy",
+    "BIZONQUANT_BASE_URL": "https://bizon.naiyu.xyz:8443"
+  }
+}
+```
+
+也支持单变量 `BIZONQUANT_API_KEY=access_key.secret_key`。
+
+## 拿凭证（三选一）
+
+1. **桌面端**：API 密钥页建 key，permissions 勾 `mcp.read`（只读）或 `mcp.*`（含 save_preset / submit_backtest 写点）
+2. **过渡 curl**：登录（注意 device_type）→ `POST /api/v1/api-keys`（`{"name":"mcp","permissions":["mcp.*"]}`，secret 只显示一次）
+3. 桌面端「Agent 接入」UI（待建，阶段 2）
+
+## 客户端纪律（内置，无需配置）
+
+- 默认拒绝 `http://` 明文网关（`BIZONQUANT_ALLOW_INSECURE=1` 可解锁内网场景）
+- token 只走 Authorization 头；401 自动换发一次，仍 401 即停（key 撤销后不打风暴）
+- UA 带 `bizonquant-mcp/{version}`，服务端可审计
+
+## 安全模型
+
+- 凭证是 API Key（access_key + bcrypt secret），不是账号密码——泄漏面仅限该 key 的能力面
+- 服务端对 agent token 施加 **scope 硬闸**：GET 全放，非 GET 只放 5 条写白名单（选股/存方案/回测提交），`/admin` 与 `/api-keys` 一律 403
+- 交易/资金类端点不在能力面内；删 key / 停用 / 轮换 secret 即时全链失效
+- `revoke` 命令 = 同 key 再换发一次（互踢规则下旧会话全灭）；永久吊销请在桌面端删 key
+
+## 开发
+
+```bash
+uv run pytest -q        # 全量测试（含与网关 scope 闸、TS 工具表的 (method,path) 对拍）
+uv run bizonquant-mcp --version
+```
+
+对拍闸：`tests/test_conformance.py` 断言本包工具的 (method, path) ⊆ 网关 `AGENT_WRITE_ALLOWLIST` ∪ GET——网关收窄或工具新增写路径而网关未放行时，测试立即红。

bizonquant_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+bizonquant_mcp/__init__.py,sha256=xOCKTPiNN9Q84zS8nbYioV7TyIuoHMNkG9sT9_6u9Fg,540
+bizonquant_mcp/__main__.py,sha256=WXmGO-0o75IwDQE__pyuhpdRsbqZCxbruHhXhafmsuA,103
+bizonquant_mcp/cli.py,sha256=WW6nr9sm6CF2q91NzOK4A_DrrRrNc026-H71kSn5_j8,6495
+bizonquant_mcp/common.py,sha256=i5VNkvc8GPle5KUV2kvoMSmhUDTpAgFtXBeFmpaqRd8,1452
+bizonquant_mcp/gateway.py,sha256=gEs62OM87OgUegA2x0Z3tF4TKhKXw5Pyc14FhhRpoS0,6433
+bizonquant_mcp/server.py,sha256=u_L5Mbak8CN2doFdLRdbgTizGlXlcQC-0b8icML88kk,2691
+bizonquant_mcp/version.py,sha256=8T_WMC6SJVyhhZrKnyrVbbmFgZhVCiXYwKJGCWPdiY0,100
+bizonquant_mcp/tools/__init__.py,sha256=2hYOHsPsTnV1hB9-hZwLByH75u0KIZ5PCAvdK7MCI5o,104
+bizonquant_mcp/tools/backtest.py,sha256=CwUtE568wP8PBhQ7TRLIutYg9z-rUII0PQoNS9Ec5I8,7938
+bizonquant_mcp/tools/market.py,sha256=yLpmLwFwbCq_uDTkBi4iT4bBujqIYpp4bKHwKMt0rrw,7929
+bizonquant_mcp/tools/screening.py,sha256=MKwJHdQmnwd7z4kod-Y97X4eds4y48nwi2hWT6iuevs,7672
+bizonquant_mcp-0.1.0.dist-info/METADATA,sha256=YB7KcdvKuZk-DGEu9GnjLIN0H8dvPmHx-GBml_wOuhE,3862
+bizonquant_mcp-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+bizonquant_mcp-0.1.0.dist-info/entry_points.txt,sha256=oO-xN72NP0V2BvU1w_DtmP2N0CKpVe5yZVehpkrhznY,59
+bizonquant_mcp-0.1.0.dist-info/RECORD,,

bizonquant_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

bizonquant_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bizonquant-mcp = bizonquant_mcp.cli:main