backtest360-mcp 0.1.0__tar.gz

backtest360_mcp-0.1.0/.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Environments
+.venv/
+venv/
+
+# Tooling
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Editors
+.idea/
+.vscode/
+*.swp

backtest360_mcp-0.1.0/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to backtest360-mcp are documented here.
+
+## 0.1.0
+
+Initial release.
+
+- MCP server over stdio exposing the Backtest360 engine API as 12 tools:
+  `engine_info`, `get_catalog`, `list_indicators`, `get_strategy_schema`,
+  `validate_strategy`, `run_backtest`, `get_latest_signal`, `compare_backtests`,
+  `compute_stats`, `search_tickers`, `list_tickers`, `get_data_range`.
+- Reference catalogs additionally published as MCP resources
+  (`backtest360://catalog/{name}`, `backtest360://schema/strategy`).
+- Response shaping for backtest results (`summary` / `stats` / `full`, add-on
+  `include` blocks, series downsampling, trade pagination) with an explicit
+  `truncated_by_mcp` marker on any size-capped result.
+- Discovery calls stay within a client's context budget: `list_tickers` returns
+  a bounded, explicitly marked result instead of the full ticker universe;
+  `list_indicators` returns a single consolidated object (`{"indicators": [...],
+  "count": N}`); oversized catalogs and ticker-search results are size-capped and
+  marked `truncated_by_mcp`; and the catalog and strategy-schema resources return
+  a readable error instead of failing hard. `list_indicators` returns the same
+  result shape on every supported Python version.
+- Agent-oriented error semantics: failed validations and request rejections are
+  returned as readable results; capacity and permission errors carry explicit
+  retry/recovery guidance and the engine request id.
+- Environment-driven configuration (`BACKTEST360_API_KEY`,
+  `BACKTEST360_ENGINE_URL`, timeout, output cap).
+- Example MCP client configuration (`examples/mcp.json`).
+- Releases are published automatically from version tags via OIDC trusted
+  publishing — no stored tokens.

backtest360_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Backtest360
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backtest360_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: backtest360-mcp
+Version: 0.1.0
+Summary: MCP server exposing the Backtest360 engine API as tools for AI agents
+Project-URL: Homepage, https://backtest360.com
+Project-URL: Repository, https://github.com/Backtest360/backtest360-mcp
+Project-URL: API Reference, https://api.backtest360.com/docs
+Project-URL: Changelog, https://github.com/Backtest360/backtest360-mcp/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/Backtest360/backtest360-mcp/issues
+Author-email: Backtest360 <hello@backtest360.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,api-client,backtesting,mcp,model-context-protocol,quantitative-finance,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.27
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# backtest360-mcp
+
+MCP server exposing the [Backtest360](https://backtest360.com) engine API as tools for AI agents.
+
+Connect any MCP-capable AI client and drive real backtests conversationally: discover
+indicators, build and validate strategies, run backtests, and read the results — all
+against the deterministic Backtest360 engine. The server contains no AI and computes no
+numbers of its own; it is a thin, faithful adapter over the engine HTTP API. Your engine
+API key and its plan govern everything (permissions, rate limits, data access).
+
+**Status: pre-release (v0.1.x).** Local stdio transport. Remote (HTTP) deployment is planned.
+
+## Install
+
+```bash
+pip install backtest360-mcp        # or, from a clone: pip install -e .
+```
+
+Requires Python 3.10+ and a Backtest360 API key — create one at
+[backtest360.com](https://backtest360.com).
+
+## Configuration
+
+Everything is environment-driven:
+
+| Variable | Required | Default | Purpose |
+|---|---|---|---|
+| `BACKTEST360_API_KEY` | yes | — | Engine API key, sent as `X-API-Key` |
+| `BACKTEST360_ENGINE_URL` | no | `https://api.backtest360.com` | Engine base URL |
+| `BACKTEST360_MCP_TIMEOUT` | no | `300` | Per-request timeout (seconds) |
+| `BACKTEST360_MCP_MAX_OUTPUT_BYTES` | no | `100000` | Hard cap on a single tool result |
+
+## Connect an MCP client
+
+Add the server to your MCP client's configuration (the common `mcpServers` shape):
+
+```json
+{
+  "mcpServers": {
+    "backtest360": {
+      "command": "backtest360-mcp",
+      "env": {
+        "BACKTEST360_API_KEY": "b360_..."
+      }
+    }
+  }
+}
+```
+
+Prefer not to put the key in a config file? Point `command` at a small wrapper script
+that exports the key from your secrets manager and then runs `backtest360-mcp`. A
+minimal example config is in [`examples/mcp.json`](examples/mcp.json).
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `engine_info` | Engine version, API contract, health |
+| `get_catalog` | Reference catalogs: operators, execution modes, stop types, sizing methods, bar frequencies, metric sections |
+| `list_indicators` | Indicator discovery; per-indicator parameter schemas |
+| `get_strategy_schema` | JSON Schema for strategy documents |
+| `validate_strategy` | Validate a strategy without running it — returns structured, locatable errors |
+| `run_backtest` | Run a historical backtest |
+| `get_latest_signal` | Evaluate the most recent bar only (no P&L) |
+| `compare_backtests` | Run several strategies on the same data, side by side |
+| `compute_stats` | Compute the metric set from an externally produced returns series |
+| `search_tickers` / `list_tickers` | Asset discovery for server-side data fetch |
+| `get_data_range` | Available history and bar-count estimate for a symbol |
+
+The cheap static catalogs are also published as MCP resources
+(`backtest360://catalog/{name}`, `backtest360://schema/strategy`) for clients that
+support resource attachment.
+
+## Response shaping
+
+A full backtest result is megabytes; an agent's context is not. `run_backtest` and
+`compare_backtests` take `response_detail`:
+
+- `summary` (default) — headline metrics, warnings, counts, equity endpoints
+- `stats` — every metric the plan allows
+- `full` — plus series (downsampled, endpoints preserved) and trades (paginated)
+
+`include=["trades", "equity_curve", "monthly_returns", "yearly_returns"]` adds specific
+blocks at the lighter levels. Results exceeding the output cap are reduced further and
+explicitly marked `truncated_by_mcp` — never silently cut. Shaping only ever selects and
+thins what the engine returned; no value is computed or altered.
+
+## Error semantics
+
+Designed for agents:
+
+- **Fixable by changing the request** → returned as a normal result: failed validations
+  arrive as `{"valid": false, "errors": [...]}` with machine codes and document
+  locations; engine rejections arrive as `{"accepted": false, "error": ...}` with a hint.
+- **Not fixable that way** → a tool error with explicit guidance: rate limits carry the
+  `Retry-After` value; engine-busy says retry with backoff; a compute timeout says
+  do **not** retry and reduce scope instead; permission problems name the missing
+  capability. Engine request ids are included for support.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest                  # unit suite against a mock engine — no network
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

backtest360_mcp-0.1.0/README.md

@@ -0,0 +1,109 @@
+# backtest360-mcp
+
+MCP server exposing the [Backtest360](https://backtest360.com) engine API as tools for AI agents.
+
+Connect any MCP-capable AI client and drive real backtests conversationally: discover
+indicators, build and validate strategies, run backtests, and read the results — all
+against the deterministic Backtest360 engine. The server contains no AI and computes no
+numbers of its own; it is a thin, faithful adapter over the engine HTTP API. Your engine
+API key and its plan govern everything (permissions, rate limits, data access).
+
+**Status: pre-release (v0.1.x).** Local stdio transport. Remote (HTTP) deployment is planned.
+
+## Install
+
+```bash
+pip install backtest360-mcp        # or, from a clone: pip install -e .
+```
+
+Requires Python 3.10+ and a Backtest360 API key — create one at
+[backtest360.com](https://backtest360.com).
+
+## Configuration
+
+Everything is environment-driven:
+
+| Variable | Required | Default | Purpose |
+|---|---|---|---|
+| `BACKTEST360_API_KEY` | yes | — | Engine API key, sent as `X-API-Key` |
+| `BACKTEST360_ENGINE_URL` | no | `https://api.backtest360.com` | Engine base URL |
+| `BACKTEST360_MCP_TIMEOUT` | no | `300` | Per-request timeout (seconds) |
+| `BACKTEST360_MCP_MAX_OUTPUT_BYTES` | no | `100000` | Hard cap on a single tool result |
+
+## Connect an MCP client
+
+Add the server to your MCP client's configuration (the common `mcpServers` shape):
+
+```json
+{
+  "mcpServers": {
+    "backtest360": {
+      "command": "backtest360-mcp",
+      "env": {
+        "BACKTEST360_API_KEY": "b360_..."
+      }
+    }
+  }
+}
+```
+
+Prefer not to put the key in a config file? Point `command` at a small wrapper script
+that exports the key from your secrets manager and then runs `backtest360-mcp`. A
+minimal example config is in [`examples/mcp.json`](examples/mcp.json).
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `engine_info` | Engine version, API contract, health |
+| `get_catalog` | Reference catalogs: operators, execution modes, stop types, sizing methods, bar frequencies, metric sections |
+| `list_indicators` | Indicator discovery; per-indicator parameter schemas |
+| `get_strategy_schema` | JSON Schema for strategy documents |
+| `validate_strategy` | Validate a strategy without running it — returns structured, locatable errors |
+| `run_backtest` | Run a historical backtest |
+| `get_latest_signal` | Evaluate the most recent bar only (no P&L) |
+| `compare_backtests` | Run several strategies on the same data, side by side |
+| `compute_stats` | Compute the metric set from an externally produced returns series |
+| `search_tickers` / `list_tickers` | Asset discovery for server-side data fetch |
+| `get_data_range` | Available history and bar-count estimate for a symbol |
+
+The cheap static catalogs are also published as MCP resources
+(`backtest360://catalog/{name}`, `backtest360://schema/strategy`) for clients that
+support resource attachment.
+
+## Response shaping
+
+A full backtest result is megabytes; an agent's context is not. `run_backtest` and
+`compare_backtests` take `response_detail`:
+
+- `summary` (default) — headline metrics, warnings, counts, equity endpoints
+- `stats` — every metric the plan allows
+- `full` — plus series (downsampled, endpoints preserved) and trades (paginated)
+
+`include=["trades", "equity_curve", "monthly_returns", "yearly_returns"]` adds specific
+blocks at the lighter levels. Results exceeding the output cap are reduced further and
+explicitly marked `truncated_by_mcp` — never silently cut. Shaping only ever selects and
+thins what the engine returned; no value is computed or altered.
+
+## Error semantics
+
+Designed for agents:
+
+- **Fixable by changing the request** → returned as a normal result: failed validations
+  arrive as `{"valid": false, "errors": [...]}` with machine codes and document
+  locations; engine rejections arrive as `{"accepted": false, "error": ...}` with a hint.
+- **Not fixable that way** → a tool error with explicit guidance: rate limits carry the
+  `Retry-After` value; engine-busy says retry with backoff; a compute timeout says
+  do **not** retry and reduce scope instead; permission problems name the missing
+  capability. Engine request ids are included for support.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest                  # unit suite against a mock engine — no network
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

backtest360_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "backtest360-mcp"
+dynamic = ["version"]
+description = "MCP server exposing the Backtest360 engine API as tools for AI agents"
+readme = "README.md"
+license = "MIT"
+authors = [
+    {name = "Backtest360", email = "hello@backtest360.com"},
+]
+requires-python = ">=3.10"
+keywords = [
+    "backtesting",
+    "trading",
+    "quantitative-finance",
+    "mcp",
+    "model-context-protocol",
+    "ai-agents",
+    "api-client",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Typing :: Typed",
+]
+dependencies = [
+    "mcp>=1.27",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+]
+
+[project.scripts]
+backtest360-mcp = "backtest360_mcp.server:main"
+
+[project.urls]
+Homepage = "https://backtest360.com"
+Repository = "https://github.com/Backtest360/backtest360-mcp"
+"API Reference" = "https://api.backtest360.com/docs"
+Changelog = "https://github.com/Backtest360/backtest360-mcp/blob/main/CHANGELOG.md"
+Issues = "https://github.com/Backtest360/backtest360-mcp/issues"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+markers = [
+    "integration: tests that require network access or a live engine",
+]
+addopts = "-m 'not integration'"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/backtest360_mcp"]
+artifacts = ["src/backtest360_mcp/py.typed"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "pyproject.toml",
+]

backtest360_mcp-0.1.0/src/backtest360_mcp/__init__.py

@@ -0,0 +1,13 @@
+"""Backtest360 MCP server — engine API as tools for AI agents."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("backtest360-mcp")
+except PackageNotFoundError:
+    __version__ = "0.0.0.dev"
+
+from backtest360_mcp.engine_client import EngineClient, EngineError
+from backtest360_mcp.settings import Settings
+
+__all__ = ["EngineClient", "EngineError", "Settings", "__version__"]

backtest360_mcp-0.1.0/src/backtest360_mcp/engine_client.py

@@ -0,0 +1,255 @@
+"""Thin HTTP client for the Backtest360 engine API.
+
+The server is a protocol adapter: requests go to the engine as-is, responses
+come back as-is (tool-level shaping happens in :mod:`backtest360_mcp.shaping`).
+This client adds only transport concerns — auth header, contract header,
+timeouts, and uniform error mapping.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+
+# API contract version this server targets, sent via X-Client-Contract.
+# The engine rejects the call with HTTP 409 when it no longer supports this
+# contract, signalling that backtest360-mcp needs updating.
+_CLIENT_CONTRACT = "1"
+
+
+def _server_version() -> str:
+    from backtest360_mcp import __version__
+
+    return __version__
+
+
+class EngineError(Exception):
+    """Raised on any non-2xx response from the engine (or client-side failure).
+
+    Attributes:
+        status: HTTP status code (0 for client-side errors raised before any
+            request was sent).
+        code: Machine-readable engine error code when the response carried one
+            (e.g. ``QUOTA_EXCEEDED``, ``COMPUTE_TIMEOUT``).
+        body: Parsed response body (dict) or raw text when JSON parsing failed.
+        request_id: ``X-Request-ID`` response header, when present. Joins the
+            failure to the engine's logs.
+        retry_after: Seconds to wait before retrying, from the ``Retry-After``
+            header on capacity responses (429/503). ``None`` when absent.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int,
+        code: str | None = None,
+        body: dict[str, Any] | str | None = None,
+        request_id: str | None = None,
+        retry_after: float | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.body = body
+        self.request_id = request_id
+        self.retry_after = retry_after
+
+
+class EngineClient:
+    """Synchronous client for the engine endpoints the MCP server exposes.
+
+    Args:
+        engine_url: Engine base URL (no trailing slash).
+        api_key: Key sent as ``X-API-Key`` on every request.
+        timeout: Per-request timeout in seconds.
+        transport: Optional httpx transport override (tests inject a
+            ``httpx.MockTransport`` here).
+    """
+
+    def __init__(
+        self,
+        engine_url: str,
+        api_key: str,
+        timeout: float = 300.0,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self._base_url = engine_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+        self._transport = transport
+
+    # -----------------------------------------------------------------------
+    # Transport
+    # -----------------------------------------------------------------------
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "X-API-Key": self._api_key,
+            "X-Client-Version": f"backtest360-mcp/{_server_version()}",
+            "X-Client-Contract": _CLIENT_CONTRACT,
+            "Content-Type": "application/json",
+        }
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        """Send a request and return the parsed JSON response.
+
+        Raises:
+            EngineError: On any non-2xx response, a non-JSON success body,
+                or a payload that cannot be serialized.
+        """
+        url = f"{self._base_url}{path}"
+        try:
+            content = json.dumps(body, allow_nan=False) if body is not None else None
+        except (ValueError, TypeError) as exc:
+            raise EngineError(
+                f"Payload is not JSON-serializable: {exc}. "
+                "Check for NaN, Inf, or non-serializable values.",
+                status=0,
+                code="MCP_INVALID_PAYLOAD",
+            ) from exc
+
+        with httpx.Client(timeout=self._timeout, transport=self._transport) as http:
+            response = http.request(
+                method, url, headers=self._headers(), params=params, content=content
+            )
+
+        if response.status_code >= 400:
+            raise self._to_error(response)
+
+        try:
+            return response.json()
+        except Exception:
+            raise EngineError(
+                f"Engine returned a non-JSON response (HTTP {response.status_code}).",
+                status=response.status_code,
+                code="MCP_MALFORMED_RESPONSE",
+                body=response.text or None,
+            ) from None
+
+    @staticmethod
+    def _to_error(response: httpx.Response) -> EngineError:
+        """Map an error response to an EngineError, preserving the engine's
+        structured detail (code, message) and operational headers."""
+        try:
+            resp_body: dict[str, Any] | str | None = response.json()
+        except Exception:
+            resp_body = response.text or None
+
+        request_id = response.headers.get("x-request-id")
+        retry_after_header = response.headers.get("retry-after")
+        try:
+            retry_after = float(retry_after_header) if retry_after_header else None
+        except ValueError:
+            retry_after = None
+
+        code: str | None = None
+        message = ""
+        if isinstance(resp_body, dict):
+            detail = resp_body.get("detail")
+            if isinstance(detail, str):
+                message = detail
+            elif isinstance(detail, dict):
+                message = detail.get("message", "") or response.text
+                code = detail.get("code")
+            elif isinstance(detail, list):
+                # 422 request-validation errors arrive as a list of per-field dicts.
+                parts = []
+                for item in detail:
+                    if isinstance(item, dict):
+                        loc = " -> ".join(str(p) for p in item.get("loc", []))
+                        msg = item.get("msg", "")
+                        parts.append(f"{loc}: {msg}" if loc else msg)
+                    else:
+                        parts.append(str(item))
+                message = "; ".join(filter(None, parts)) or response.text
+            else:
+                message = (
+                    resp_body.get("error") or resp_body.get("message") or response.text
+                )
+        else:
+            message = str(resp_body) if resp_body else ""
+
+        return EngineError(
+            message or f"HTTP {response.status_code}",
+            status=response.status_code,
+            code=code,
+            body=resp_body,
+            request_id=request_id,
+            retry_after=retry_after,
+        )
+
+    # -----------------------------------------------------------------------
+    # Endpoints
+    # -----------------------------------------------------------------------
+
+    def version(self) -> dict[str, Any]:
+        return self.request("GET", "/api/version")
+
+    def health(self) -> dict[str, Any]:
+        return self.request("GET", "/api/health")
+
+    def indicators(self) -> Any:
+        return self.request("GET", "/api/indicators")
+
+    def strategy_schema(self) -> dict[str, Any]:
+        return self.request("GET", "/api/schemas/strategy")
+
+    def catalog(self, path: str) -> Any:
+        """Fetch one reference catalog by its API path (e.g. '/api/operators')."""
+        return self.request("GET", path)
+
+    def validate_strategy(self, body: dict[str, Any]) -> dict[str, Any]:
+        """POST /api/validate-strategy.
+
+        A failed validation arrives as HTTP 422 whose body *is* the validation
+        result (``{"valid": false, "errors": [...]}``). That outcome is
+        returned like a success — it is the agent's fix-and-retry input, not
+        a transport failure.
+        """
+        try:
+            return self.request("POST", "/api/validate-strategy", body=body)
+        except EngineError as exc:
+            if (
+                exc.status == 422
+                and isinstance(exc.body, dict)
+                and "valid" in exc.body
+            ):
+                return exc.body
+            raise
+
+    def backtest(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self.request("POST", "/api/backtest", body=body)
+
+    def latest_signal(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self.request("POST", "/api/latest-signal", body=body)
+
+    def compare(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self.request("POST", "/api/backtest/compare", body=body)
+
+    def stats(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self.request("POST", "/api/stats", body=body)
+
+    def ticker_search(self, query: str, asset_class: str | None, limit: int) -> Any:
+        params: dict[str, Any] = {"q": query, "limit": limit}
+        if asset_class:
+            params["asset_class"] = asset_class
+        return self.request("GET", "/api/data/search", params=params)
+
+    def tickers(self, asset_class: str | None) -> Any:
+        params = {"asset_class": asset_class} if asset_class else None
+        return self.request("GET", "/api/data/tickers", params=params)
+
+    def data_range(self, symbol: str, frequency: str) -> Any:
+        return self.request(
+            "GET", "/api/data/range", params={"symbol": symbol, "frequency": frequency}
+        )