# ai.quantifyme/quantifyme (remote · mcp.quantifyme.ai)

Describe a trading strategy in plain English and deploy a live signal model in one call. No signup.

- Trust score: 63/100 (medium)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `mcp.quantifyme.ai`: 63/100 (this document), [markdown](https://verifymcp.io/servers/ai-quantifyme-quantifyme/mcp.md), [page](https://verifymcp.io/servers/ai-quantifyme-quantifyme/mcp)

## Channel facts

- Endpoint: `https://mcp.quantifyme.ai/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (one_shot).
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 70/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3550 tokens (~197/item across 18 items; 13 tools + 5 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.
  - Supports UI / widget rendering.

## Install

### Claude

```bash
claude mcp add --transport http ai-quantifyme-quantifyme https://mcp.quantifyme.ai/mcp
```

### Codex

```toml
[mcp_servers.ai-quantifyme-quantifyme]
url = "https://mcp.quantifyme.ai/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-quantifyme-quantifyme": {
      "type": "remote",
      "url": "https://mcp.quantifyme.ai/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-quantifyme-quantifyme --url https://mcp.quantifyme.ai/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-quantifyme-quantifyme:
    url: "https://mcp.quantifyme.ai/mcp"
```

### Other

```json
{
  "mcpServers": {
    "ai-quantifyme-quantifyme": {
      "type": "http",
      "url": "https://mcp.quantifyme.ai/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-01 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 61, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 60, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-28 (score 59, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 58, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 57)

First indexed and scored.

## MCP tools (13)

### `one_shot` (~700 tokens)

Deploy Strategy (generate + backtest + go live)

End-to-end deploy: generate strategy → train → deploy live.

    One of `prompt` (free-form NL), `preset` (curated winning strategy), or
    `community_id` (copy a published community strategy) is required. If more
    than one is passed, precedence is community_id > preset > prompt.

    Args:
      prompt: Natural-language strategy description (e.g. "Buy when RSI < 30, sell > 70").
      symbol: Currency pair to backtest on. One of: EURUSD, USDJPY, GBPUSD,
        USDCHF, USDCAD, AUDUSD, NZDUSD. Default EURUSD.
      timeframe: Candle granularity. One of: 1min, 5min, 15min, 1h. Default 15min.
      claude_model: Which Claude variant to use for code generation.
        "sonnet" (default — best quality, 1/day free) or "haiku" (faster, 3/day free).
        Ignored when `preset` is set (no generation needed).
      preset: Curated winning-strategy slug. Skips Claude generation entirely
        — deploys a pre-saved strategy known to backtest well on the chosen
        symbol. Available slugs: ema_cross_fast, momentum, scalper_stack,
        sma_only, trend_ema, volatility, bb_squeeze, all_mix, pivot_kid_ema.
        Not every slug exists for every symbol — call list_models afterwards
        to confirm what deployed.
      community_id: Copy-trade a published community strategy. Pass the `id`
        of an entry from `browse_community`. Loads that exact strategy code,
        skips Claude generation, then trains + deploys it. `symbol`/`timeframe`
        still apply to the backtest+deploy.
      webhook_url: Optional webhook to receive live signals.
      telegram_chat_id: Optional Telegram chat ID for signal delivery.

    Returns IMMEDIATELY (the deploy runs in the background so the live card can
    stream progress) with:
        - job_token (str): pass to get_deploy_result to fetch the final result.
        - poll_url (str): the card polls this for live progress; you can ignore it.
        - pending (bool): always true here — the deploy is still running.…

Input parameters:

- `claude_model`
- `community_id`
- `preset`
- `prompt`
- `symbol`
- `telegram_chat_id`
- `timeframe`
- `webhook_url`

### `get_deploy_result` (~354 tokens)

Get Deploy Result

Wait for a `one_shot` deploy to finish and return its final result.

    `one_shot` returns a job_token immediately and the LIVE CARD already streams
    progress and renders the interactive backtest chart itself. Call this ONCE with
    the token to get the final numbers as TEXT so you can summarize them — it does
    NOT render another card (no need for get_model_chart). It BLOCKS until the deploy
    finishes (or ~2.5 min); on timeout it returns ok:false + pending:true — call it
    again with the same token.

    IMPORTANT: if `source == "community"`, the deploy used a PRE-EXISTING strategy by
    `@author` — tell the user that, share the `live_url` as the Live dashboard link,
    and ask whether they'd like to GENERATE A CUSTOM strategy instead. Use the
    `note` field as your guide.

    Args:
      job_token: the token returned by `one_shot`.

    Returns:
      dict with: ok, stem, model, live_url, symbol, timeframe, channels (list),
      stats:{ret, wr, pf, n, mdd} (out-of-sample test-split metrics — SHOW THESE),
      source ("community" | "generated"), author (community username if any),
      author_url + strategy_url (render @author and "pre-existing strategy" as those
      Markdown links), community_id, suggest_custom (bool), and note (a ready
      instruction — follow it). On failure: {ok:false, error} (or {pending:true}).

Input parameters:

- `job_token` (string, required)

### `link_account` (~168 tokens)

Link My QuantifyMe Account

Link this chat to the user's existing QuantifyMe account.

    Call this when the user says they already have a QuantifyMe account, or
    asks why their models are missing / where a model went, or wants what they
    deploy here to show up in their own dashboard.

    By default this connector works with NO signup: it mints an anonymous trial
    account per chat, so models deployed here belong to that throwaway identity
    rather than to the user's real one. This returns a short-lived URL; once the
    user opens it and approves, every later call in THIS chat acts as their
    account and deploys land in their own model list.

    Give the user the `link_url` to open. Nothing else is required from them.

### `list_models` (~21 tokens)

List Trained Models

List the user's trained models with pre-computed train/test stats.

### `list_deployed` (~19 tokens)

List Deployed Live Models

List the user's currently deployed (live) models.

### `top_up` (~75 tokens)

Top Up Credits with Crypto

Fund your QuantifyMe credits with crypto (USDC) — no signup, no human, no
    card. The agent-native funding rail. SIMULATED in this build (no real charge)
    and capped at $100 for the POC. Returns your new credit balance.

Input parameters:

- `amount_usd` (number, required)

### `generate_strategy` (~261 tokens)

Generate Strategy Code (no training)

Generate Python strategy code (no training/deploy). Use when the user wants raw code.

    Args:
      features: NL description of features (e.g. "RSI 14, Bollinger Bands").
      signals: NL description of signal logic (e.g. "Buy when RSI < 30").
      model: ML model name (default Random Forest).
      risk: NL risk rules (e.g. "0.5% stop loss").
      description: Optional one-line summary; treated as PRIMARY USER REQUEST.
      symbol: Currency pair the code should target. One of: EURUSD, USDJPY,
        GBPUSD, USDCHF, USDCAD, AUDUSD, NZDUSD. Default EURUSD.
      timeframe: Candle granularity. One of: 1min, 5min, 15min, 1h. Default 15min.
      claude_model: "sonnet" (default) or "haiku" (faster, higher daily cap).

Input parameters:

- `claude_model`
- `description`
- `features` (string)
- `model` (string)
- `risk` (string)
- `signals` (string)
- `symbol`
- `timeframe`

### `browse_community` (~338 tokens)

Browse Community Strategies (leaderboard)

Browse the public community leaderboard of published strategies, ranked
    by a composite performance score (best first). No signup or key needed.

    Copy-trade flow: call this to find a top strategy, then pass its `id` to
    `one_shot` as `community_id` to deploy a live signal model running that
    exact strategy in one call.

    Args:
      limit: How many top entries to return (default 20, max 200).
      sort: Ranking metric, best-first — one of "composite" (default),
        "ret" (total return), "wr" (win rate), "sharpe", "n_trades". Mirrors
        the quantifyme.ai/community page's sortable columns, so an agent can
        pick the top strategy by the metric it cares about in one call. The
        sorted entries keep their `id`, so the winner is directly deployable
        via one_shot(community_id=...).

    Returns:
      dict with:
        - scripts (list[dict]): ranked entries, best first. Each has:
            id (int — pass to one_shot as community_id), username, title,
            description, created_at, score, and metrics {total_ret,
            sharpe_strat, win_rate, n_trades, mdd, profit_factor}. SHOW the
            top few with their win_rate / total_ret so the user can pick one.
        - count (int).
        - metric (str): the sort key applied.

Input parameters:

- `limit` (integer)
- `sort` (string)

### `find_strategy` (~384 tokens)

Find a Matching Strategy

Find an existing PROVEN strategy that matches a plain-English idea, so you
    can offer the user a choice — deploy the existing one, or generate a fresh
    custom one. Mirrors the quantifyme.ai landing experience: "Found <X> by
    @<author> (WR/PF) — Use it / Generate fresh".

    CALL THIS FIRST when a user describes a strategy idea. Then present the match
    (if any) and ASK which they want:
      • Use it          → one_shot(community_id=<match.community_id>) — deploys the
                          exact proven strategy (free, no generation).
      • Generate fresh  → one_shot(prompt="<their description>") — Claude writes a
                          brand-new custom strategy for them.
    If there's no match, just offer to generate fresh.

    Args:
      description: the user's strategy idea in plain English (e.g. "buy EURUSD
        15min when RSI < 30, sell when RSI > 70").
      symbol: optional pair to constrain the match (EURUSD, USDJPY, GBPUSD,
        USDCHF, USDCAD, AUDUSD, NZDUSD).
      timeframe: optional granularity to constrain the match (1min/5min/15min/1h).

    Returns:
      dict with:
        - match: the best existing strategy, or null. When present:
            {community_id, title, username, wr, pf, ret, n_trades, symbol,
             timeframe}. Pass community_id to one_shot to deploy it unchanged.
        - description: echoed back — pass as one_shot(prompt=...) to generate fresh.
        - suggestion: a ready-to-show sentence offering the user the choice.

Input parameters:

- `description` (string, required)
- `symbol`
- `timeframe`

### `get_strategy_code` (~207 tokens)

Get Community Strategy Code

Get the actual Python code behind a community leaderboard strategy.

    Use after `browse_community`: pass an entry's `id` here to read its real
    `feature_engineering()` + `strategy_config()` source so the user can
    inspect or tweak it. To deploy it unchanged, pass the same id to
    `one_shot` as `community_id`. Read-only, no signup needed.

    Args:
      community_id: The `id` of a community entry (from `browse_community`).

    Returns:
      dict with: id, title, username, description, symbol, timeframe,
      metrics {total_ret, win_rate, profit_factor, n_trades, mdd, sharpe_strat},
      and `code` (the full Python source). SHOW the code to the user, and offer
      to deploy it via one_shot(community_id=...) or tweak it first.

Input parameters:

- `community_id` (integer, required)

### `get_quote` (~183 tokens)

Get Current Price (G7 FX quote)

Get the latest price for a G7 FX pair — a quick "what's it at now" check.

    Useful for context before deploying a strategy. The price is the close of
    the most recent 1-minute bar from the platform's market feed (not a raw
    live tick); FX markets close on weekends, so the `stale` flag marks a bar
    that is more than 15 minutes old.

    Args:
      symbol: G7 pair — one of EURUSD, USDJPY, GBPUSD, USDCHF, USDCAD, AUDUSD,
        NZDUSD. Default EURUSD.

    Returns:
      dict with: symbol, price (latest close), time (bar timestamp, UTC),
      change + change_pct (vs the prior 1-min bar), stale (bool).

Input parameters:

- `symbol` (string)

### `get_model_chart` (~252 tokens)

Show Backtest Chart (equity + trades)

Visualize a trained model's backtest — a cumulative-return chart + trade log + stats.

    Use after `one_shot` / `list_models` with the model's `stem` to SHOW the user how it
    traded (the "is it actually any good" view). In ChatGPT this renders an interactive
    widget. In Claude, render an interactive **artifact** from this tool's structured
    output: a line chart of the cumulative return plus a table of the trades.

    Args:
      stem: The model stem (e.g. "14_EURUSD_15min_Model_24") from `list_models` / `one_shot`.

    Returns:
      dict with: ok, stem, symbol, timeframe, stats {ret, wr, pf, n, mdd, sharpe},
      and trades [{type, entry_time, exit_time, entry_price, exit_price, pnl,
      pnl_pct, exit_reason, period}] (most recent ~200). exit_reason is one of
      TP / SL / close_only / signal / end. ret/mdd/wr are fractions; pnl_pct is percent.

Input parameters:

- `stem` (string, required)

### `stream_test` (~115 tokens)

Live Streaming Diagnostic

Diagnostic: test whether LIVE data streaming works in this client.

    Renders a widget with three panels — a JS timer (baseline), a WebSocket to
    the live price feed, and an HTTP poll of /quote — each showing a live value
    + status, so you can see exactly which streaming mechanisms the client's
    widget sandbox actually permits. Use when a live/ticking chart isn't moving.

    Args:
      symbol: G7 pair to stream (default EURUSD).

Input parameters:

- `symbol` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-quantifyme-quantifyme/mcp#diagnostics

## Score history

- 2026-08-03: 63
- 2026-08-02: 62
- 2026-08-01: 62
- 2026-07-31: 61
- 2026-07-30: 60
- 2026-07-29: 59
- 2026-07-28: 59
- 2026-07-27: 58
- 2026-07-26: 57

## Links

- Remote endpoint: https://mcp.quantifyme.ai/mcp
- Website: https://quantifyme.ai/
- Changelog RSS feed: https://verifymcp.io/servers/ai-quantifyme-quantifyme/mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-quantifyme-quantifyme/mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/ai-quantifyme-quantifyme/mcp