quantifyme
Describe a trading strategy in plain English and deploy a live signal model in one call. No signup.
Sollte ich dies verwenden
Qualität und Sicherheit
Basierend auf einer automatisierten Analyse der Tool-Definitionen und der Einhaltung des Protokolls.
Kontextkosten
Dies ist die ungefähre Anzahl der Tokens, die jedes Mal verbraucht werden, wenn die Tools des Servers in den Kontext eines Modells geladen werden. Höhere Werte verringern die Aufmerksamkeit, die für andere Aufgaben verfügbar ist.
Installieren
Installation mit einem Klick
Fügen Sie dies Ihrer Datei `claude_desktop_config.json` hinzu:
{
"mcpServers": {
"quantifyme": {
"url": "https://mcp.quantifyme.ai/mcp"
}
}
}Remote-Endpunkte
https://mcp.quantifyme.ai/mcpstreamable-httpWas es kann
Tool-Inventar
Tools (11)
🔴one_shot(prompt, symbol, timeframe, claude_model, preset, ...)
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 writes the code: "sonnet" (default, best quality) or "haiku" (faster, cheaper). Generation is billed from the account's credits. 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; list_models shows 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 at once (the deploy runs in the background so the live card can stream progress) with: - job_token (str): get_deploy_result(job_token) returns the final result. - poll_url (str): the progress URL the live card polls. - pending (bool): true; the deploy is still running. - symbol, timeframe (str). Each call starts one deploy and one deploy card, and is billed from the account's credits. The server routes the request: a vague `prompt` deploys the best curated preset for the market, or a fresh build when there is none; specific rules generate a fresh strategy. A community strategy deploys only after the user has seen its author and code (get_strategy_code) and picked it, through its `community_id`. get_deploy_result(job_token) waits for the deploy and returns the out-of-sample stats, `stem`, `live_url` and `source`/`author` as text; its `source` says when a pre-existing community strategy was used, and a `suggestion` is a matching community strategy that was not deployed.
Eingabe-Schema
{
"type": "object",
"properties": {
"prompt": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Prompt"
},
"symbol": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Symbol"
},
"timeframe": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Timeframe"
},
"claude_model": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Claude Model"
},
"preset": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Preset"
},
"community_id": {
"anyOf": [
{
"type": "integer"
},
{
"type": "null"
}
],
"default": null,
"title": "Community Id"
},
"webhook_url": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Webhook Url"
},
"telegram_chat_id": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Telegram Chat Id"
}
},
"title": "one_shotArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "one_shotDictOutput"
}🟢get_deploy_result(job_token)
Wait for a `one_shot` deploy to finish and return its final result as text. Takes the job_token `one_shot` returned. Waits until the deploy finishes, up to about 2.5 minutes; past that it returns ok:false with pending:true, and a later call with the same token picks the same deploy up again. It renders no card of its own: the one_shot deploy card is the visual, where the client renders it. `source == "community"` means the deploy used a pre-existing strategy by `@author` that the user picked. A `suggestion` is a community strategy that matched a vague request and was not deployed; it deploys only after the user has seen its author and code and picked it. 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), source ("preset" | "generated" | "community"), author (community username if any), author_url + strategy_url (links for the author and the community strategy), community_id, suggest_custom (bool), suggestion ({community_id, title, author} or null: matched, not deployed), and note (a one-line summary of the source). On failure: {ok:false, error} (or {pending:true}).
Eingabe-Schema
{
"type": "object",
"properties": {
"job_token": {
"title": "Job Token",
"type": "string"
}
},
"required": [
"job_token"
],
"title": "get_deploy_resultArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "get_deploy_resultDictOutput"
}🟡link_account
Link this chat to the user's existing QuantifyMe account. For a user who already has a QuantifyMe account, who wonders why their models are missing here, or who 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 MCP session, 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 that carries the same OAuth bearer or the same MCP session acts as their account and deploys land in their own model list. A client that opens a new MCP session on every turn must link again in that session; every answer's `acting_as` line says which identity was used. Returns `link_url`: the user opens it and approves; nothing else is required from them. If the session is already linked, returns already_linked:true and the account's username instead.
Eingabe-Schema
{
"type": "object",
"properties": {},
"title": "link_accountArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "link_accountDictOutput"
}🟢list_models
List the user's trained models with pre-computed train/test stats. `acting_as` names the identity listed: the linked account or a trial user (#1962).
Eingabe-Schema
{
"type": "object",
"properties": {},
"title": "list_modelsArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "list_modelsDictOutput"
}🟢list_deployed
List the user's currently deployed (live) models.
Eingabe-Schema
{
"type": "object",
"properties": {},
"title": "list_deployedArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "list_deployedDictOutput"
}🟢generate_strategy(features, signals, model, risk, description, ...)
Generate Python strategy code only: nothing is trained or deployed. Returns the generated code for the user to read or edit; each call is billed from the account's credits. Args: features: Plain-English description of features (e.g. "RSI 14, Bollinger Bands"). signals: Plain-English description of signal logic (e.g. "Buy when RSI < 30"). model: ML model name (default Random Forest). risk: Plain-English risk rules (e.g. "0.5% stop loss"). description: Optional one-line summary; the generator weighs it as the main 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, about a third of the credits).
Eingabe-Schema
{
"type": "object",
"properties": {
"features": {
"default": "",
"title": "Features",
"type": "string"
},
"signals": {
"default": "",
"title": "Signals",
"type": "string"
},
"model": {
"default": "Random Forest",
"title": "Model",
"type": "string"
},
"risk": {
"default": "",
"title": "Risk",
"type": "string"
},
"description": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Description"
},
"symbol": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Symbol"
},
"timeframe": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Timeframe"
},
"claude_model": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Claude Model"
}
},
"title": "generate_strategyArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "generate_strategyDictOutput"
}🟢browse_community(limit, sort)
Browse the public community leaderboard of published strategies, ranked by a composite performance score (best first). No signup or key needed. Each entry's `id` is what `one_shot` takes as `community_id` to deploy a live signal model running that exact strategy. 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. The sorted entries keep their `id`, which one_shot(community_id=...) deploys. 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}. - count (int). - metric (str): the sort key applied.
Eingabe-Schema
{
"type": "object",
"properties": {
"limit": {
"default": 20,
"title": "Limit",
"type": "integer"
},
"sort": {
"default": "composite",
"title": "Sort",
"type": "string"
}
},
"title": "browse_communityArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "browse_communityDictOutput"
}🟢find_strategy(description, symbol, timeframe)
Find a published community strategy that matches a plain-English idea. Mirrors the quantifyme.ai landing page: "Found <X> by @<author> (WR/PF): use it, or generate fresh". It is for browsing; a vague deploy request is handled by one_shot(prompt=...) alone, which deploys the best curated preset or a fresh build. A community strategy is another user's code, so it deploys only after the user has seen its author and code (get_strategy_code with the match's community_id) and picked it. The two outcomes: - use the match: one_shot(community_id=<match.community_id>) deploys that exact strategy, with no generation; - generate fresh: one_shot(prompt="<their description>") writes a new custom strategy. With no match, only the second applies. 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; one_shot(prompt=...) with it generates fresh. - suggestion: one sentence describing the match and the two outcomes.
Eingabe-Schema
{
"type": "object",
"properties": {
"description": {
"title": "Description",
"type": "string"
},
"symbol": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Symbol"
},
"timeframe": {
"anyOf": [
{
"type": "string"
},
{
"type": "null"
}
],
"default": null,
"title": "Timeframe"
}
},
"required": [
"description"
],
"title": "find_strategyArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "find_strategyDictOutput"
}🟢get_strategy_code(community_id)
Get the actual Python code behind a community leaderboard strategy. Takes an entry's `id` from `browse_community` or `find_strategy` and returns its real `feature_engineering()` + `strategy_config()` source, for the user to inspect or tweak. The same id passed to `one_shot` as `community_id` deploys it unchanged. 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).
Eingabe-Schema
{
"type": "object",
"properties": {
"community_id": {
"title": "Community Id",
"type": "integer"
}
},
"required": [
"community_id"
],
"title": "get_strategy_codeArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "get_strategy_codeDictOutput"
}🟢get_quote(symbol)
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).
Eingabe-Schema
{
"type": "object",
"properties": {
"symbol": {
"default": "EURUSD",
"title": "Symbol",
"type": "string"
}
},
"title": "get_quoteArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "get_quoteDictOutput"
}🟢get_model_chart(stem)
A trained model's backtest: trades, stats and the data for a cumulative-return chart. Takes a model's `stem` (from `get_deploy_result`, `one_shot` or `list_models`) and returns how it traded. In clients that render the openai/outputTemplate widget (ChatGPT) it shows an interactive chart; elsewhere the structured output carries the trades and stats a client can draw as a line chart of the cumulative return and a trade table. 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.
Eingabe-Schema
{
"type": "object",
"properties": {
"stem": {
"title": "Stem",
"type": "string"
}
},
"required": [
"stem"
],
"title": "get_model_chartArguments"
}Ausgabe-Schema
{
"type": "object",
"additionalProperties": true,
"title": "get_model_chartDictOutput"
}Community
Nachweis