# TextToQuant MCP MCP Server > **TextToQuant MCP MCP Server** is a hosted, multitenant Model Context Protocol (MCP) server run by **MewCP** (https://mewcp.com), giving AI agents managed access to TextToQuant MCP. > > MewCP takes care of all MCP infrastructure for you — credential storage, OAuth flows, > token refresh, and production-grade auto-scaling — so your AI agents can connect to > third-party services and run freely without you managing any MCP server yourself. > > Server page: https://mewcp.com/mcp/texttoquant-mcp > MewCP docs: https://docs.mewcp.com > Full catalog: https://mewcp.com/llms.txt --- ## About TextToQuant converts plain-English trading strategies into backtests using real market data across crypto, forex, and equities. Analyze returns, drawdowns, and trade histories; stress-test parameters, assess overfitting, compare strategy variants, build multi-asset portfolios, scan crypto markets, and export strategies to Pine Script. --- ## Details - Server ID: `texttoquant-mcp` - Version: 2.7.1 - Tools: 79 - Authentication: OAuth, managed by MewCP - Transport: http --- ## Access The gateway URL below serves your **entire MewCP toolset**, not this server on its own. Pasting a config snippet is not enough — TextToQuant MCP has to be in the toolset first. In order: 1. Add TextToQuant MCP to your toolset at https://mewcp.com/mcp/texttoquant-mcp 2. Connect your TextToQuant MCP account (OAuth); MewCP stores the credential and attaches it to each call 3. Copy your MewCP API key from the dashboard (Developer) 4. Configure your client with the snippet for it below Once connected, an agent does **not** see this server's tools as top-level tools. It sees four meta-tools and reaches everything through them: - `search(query)` — find tools by keyword across the toolset - `get_schema(tools)` — full description and arguments for the tools you picked - `list_accounts(provider)` — only when one app has several connected accounts - `call_tool(server_maskedId, tool_name, args)` — execute So the list below is what `search` can return for this server, not a set of callable tool names on their own. --- ## Tools (79) Descriptions are truncated to 160 characters; call `get_schema` for the full text and the argument schema. Where a tool is annotated, its type is shown — treat `destructive` as irreversible. - `parse_strategy` _(write)_ — Parse a plain English trading strategy into TextToQuant's structured format. Returns the parsed query (asset, timeframe, entry/exit conditions, risk settings)… - `run_backtest` _(write)_ — Execute a backtest from a parsed strategy (the object returned by parse_strategy). BILLS ONE BACKTEST CREDIT on the account. Runs can take up to a few minutes;… - `list_backtests` _(read)_ — List the account's saved backtests: id, asset, timeframe, return, win rate, trades, dates. Filter and sort server side ("my best BTC run" → asset:"BTCUSDT",… - `get_backtest` _(read)_ — Fetch one saved backtest by id: summary metrics, grade, the strategy parameters it ran with, and the FULL REPORT (`_digest` as prose, present it in full;… - `list_indicators` _(read)_ — List the user's SAVED custom indicators (created in the app's Pine editor, via CSV upload, or with save_pine_indicator). Returns each indicator's name, source,… - `get_indicator` _(read)_ — Fetch ONE saved custom indicator by name in FULL detail, including its Pine Script source code (pineCode), its plotNames (output series), the compiled… - `get_indicator_series` _(read)_ — Compute an indicator over a symbol, timeframe and date range and return its plotted values: either a SAVED custom indicator by name (JavaScript, Python, Pine… - `save_pine_indicator` _(write)_ — Compile a TradingView Pine Script against real market data and save it as a reusable custom indicator on the account (same pipeline as the app's Pine editor… - `validate_js_indicator` _(read)_ — Check a JAVASCRIPT indicator without running it: syntax, the module shape (INPUTS / PLOTS / calc), and that every `@name` import resolves to one of your saved… - `preview_js_indicator` _(read)_ — Compile AND run a JAVASCRIPT indicator against real bars WITHOUT saving it, and get the plotted series back. Unlike preview_indicator (Pine), this returns the… - `save_js_indicator` _(write)_ — Author a JAVASCRIPT indicator and save it on the account. Compiled and RUN on real bars in a sandbox before storing: a save yields a working indicator or a… - `validate_py_indicator` _(read)_ — Check a PYTHON indicator without running it: syntax and the module shape (INPUTS / PLOTS / calc). Loads NO market data and never calls calc(), so it answers in… - `preview_py_indicator` _(read)_ — Compile AND run a PYTHON indicator against real bars WITHOUT saving it, and get the plotted series back. Like preview_js_indicator and unlike preview_indicator… - `save_py_indicator` _(write)_ — Author a PYTHON indicator and save it on the account: the capability and `ta.*` helpers of save_js_indicator, numerically identical. Compiled and RUN on real… - `save_csv_indicator` _(destructive)_ — Save an indicator from PRECOMPUTED VALUES supplied as CSV text: a series this platform cannot compute, a vendor feed, a model output, outside research. The… - `delete_indicator` _(destructive)_ — Delete one of the user's saved custom indicators by name (CSV, Pine, JavaScript or Python). This cannot be undone. - `get_usage` _(read)_ — The account's plan tier and backtest budget: the included allowance (backtestLimit, backtestsUsed, quotaRemaining; monthly on paid plans, but on Free it is 5… - `start_here` _(read)_ — Shows the six ways to start on TextToQuant (get market data, build an indicator, run a backtest, screen the market, develop a strategy, or type your own) as a… - `get_plans` _(read)_ — The subscription tiers (free/pro/power/quant/enterprise) with their current monthly/annual price, headline feature + limit deltas (backtest credits, Monte… - `explain_parse` _(read)_ — Round trip a parsed strategy back into plain English, the EXACT settings that will run: asset, window, every entry/exit condition, sizing, and costs. Read it… - `explain_grade` _(read)_ — Why did this run get its grade? Returns the stored hurdle anchored breakdown: the four pillars (profitability, risk, consistency, edge) with their scores,… - `workspace_summary` _(read)_ — A one call "where was I" briefing: plan credits left, the most recent runs with grades and labels, saved custom indicators, and live scan alerts. Useful at the… - `describe_capabilities` _(read)_ — The platform's strategy vocabulary, so you can write ideas that actually parse and run: supported asset classes and how to name their symbols, timeframes,… - `start_analysis` _(write)_ — Robustness job on a SAVED backtest (id from run_backtest): "sweep" (one parameter, 5 runs), "grid" (5x5, 2 parameters), "walk_forward" (anchored),… - `get_analysis` _(read)_ — Poll a robustness analysis started with start_analysis (progress while running, full result when done). Also: kind "sweep_options" (no jobId) lists the… - `get_backtest_data` _(read)_ — Fetch the raw data behind a saved backtest: equity curve, trade list, candles, buy and hold curve, chart markers, Monte Carlo results, the entry/exit CONDITION… - `show_backtest` _(read)_ — Render a saved backtest as its full visual report: price candlesticks with trade markers, equity + drawdown, Monte Carlo distributions and the metrics board,… - `show_analysis` _(read)_ — Render a COMPLETED robustness analysis as a chart image: sweep bars, parameter grid heatmap, walk forward window strip, or multi asset table. Use after… - `show_context` _(read)_ — CONTEXT ANALYSIS, the INDICATOR READING dashboard: which indicator buckets (RSI 14 + Williams %R 14 by default) the strategy wins and bleeds in, with the… - `show_portfolio` _(read)_ — Render a COMPLETED portfolio run as a branded report image: a metrics strip (return, Sharpe, max drawdown, win rate, trades, grade), the book equity curve with… - `compare_backtests` _(read)_ — Compare 2 to 4 saved backtests side by side as a chart image: overlaid equity curves plus a metric table with the best value per row highlighted. Use whenever… - `share_backtest` _(destructive)_ — Create (or revoke) the public share link for a saved backtest. Returns two links to the same run: `url`, the shareable report page (/s/), a sanitized read only… - `share_chart` _(destructive)_ — Create a public chart link for a saved backtest: the price chart with its trades and indicators as the owner last arranged it, at a short /c/ URL anyone can… - `cancel_backtest` _(destructive)_ — Cancel a backtest that is still QUEUED (not yet computing) and refund the credit it was billed at enqueue. A run that already started computing continues… - `parse_portfolio` _(write)_ — Split ONE plain English multi asset prompt (e.g. "buy BTC and ETH when RSI crosses above 30 on 1d, 8% TP 4% SL, keep 20% in cash, max 3 positions") into per… - `run_portfolio` _(write)_ — Run a SHARED CAPITAL multi asset portfolio backtest: all assets draw from ONE capital pool and a contention rule resolves same bar entries. BILLS ONE BACKTEST… - `list_portfolios` _(read)_ — List the user's SAVED portfolio (book) runs, newest first, the durable history of everything run with run_portfolio. Use this to find a book run earlier… - `get_portfolio` _(read)_ — Poll a portfolio run started with run_portfolio. Returns status running | completed (with the full portfolio result: combined metrics, per asset attribution,… - `get_portfolio_analysis` _(read)_ — The full analysis of a completed portfolio (book) run: combined metrics and grade, per asset attribution (which asset made or lost the money), the basket… - `get_portfolio_sweep` _(read)_ — Poll a run_portfolio_sweep job: per value book metrics as they complete, and the best value (by Sharpe) once done. A flat plateau across values means robust; a… - `get_iterations` _(read)_ — The edit/version history of a strategy session: every iteration (run) it produced, in order, with labels and ids. Pass the strategy_session_id from a backtest… - `diff_iterations` _(read)_ — Compare TWO backtests and report exactly WHAT CHANGED: the parsed strategy fields that differ (asset, timeframe, dates, each entry/exit condition, sizing,… - `organize_history` _(destructive)_ — Keep the run history tidy: action "tag" replaces a backtest's tags (filter later with list_backtests), "rename_iteration" relabels one run in an edit session,… - `manage_webhooks` _(destructive)_ — Push instead of poll: manage HTTPS receivers that get a signed POST when a backtest completes or fails. action "list" (default), "create" {url} (max 3 active;… - `share_portfolio` _(destructive)_ — Create (or revoke) the public share link for a COMPLETED portfolio run. Pass the run id from a completed get_portfolio result (the result.id, NOT the jobId).… - `rephrase_strategy` _(write)_ — Rewrite a vague or ambiguous strategy idea into clearer, parser friendly language WITHOUT inventing parameters, then feed the result to parse_strategy for a… - `edit_backtest` _(write)_ — Iterate on an existing backtest: rerun a MODIFIED strategy and save it into the SAME iteration session as the base run, so History groups them and you can… - `analyze_conditions` _(read)_ — Forward outcome probability for a SINGLE entry condition: when it fires on the given asset, what happens in the following bars (hit rate + return… - `list_examples` _(read)_ — The platform's public showcase strategies: real, best performing shared backtests with their plain English query, asset, and headline metrics. Study them as… - `publish_to_gallery` _(destructive)_ — List (or unlist) one of the user's backtests in the PUBLIC showcase gallery that list_examples reads from. The run must already have a public share link (call… - `export_pine` _(read)_ — Convert a strategy into a TradingView Pine Script v6 strategy() script the user can paste into the Pine editor. Pass either parsedQuery (from parse_strategy)… - `get_overfit_verdict` _(read)_ — Overfitting assessment for a backtest: its Deflated Sharpe Ratio (the run's Probabilistic Sharpe deflated by how many strategy configs were tried), PBO if a… - `get_regime_edge` _(read)_ — ROBUSTNESS PANEL: "Edge by regime" across the four PRICE ACTION blocks: Trend Up, Trend Down, Quiet Range, Volatile Chop. Classifies every bar into a block and… - `list_context_dimensions` _(read)_ — The dimension ids refine_context / show_context / get_context_trades accept. Every built in indicator that can bucket a run's trades, with its default period,… - `refine_context` _(read)_ — Reanalyze a backtest's trades along DIFFERENT market regime dimensions (trend, volatility, structure, entry_position, or a saved custom indicator) WITHOUT… - `filter_by_context` _(write)_ — Rerun a backtest taking entries ONLY inside a chosen market regime (e.g. only in an uptrend / low volatility), the actionable payoff of regime analysis: prove… - `get_context_trades` _(read)_ — The trades behind a regime analysis: the paginated per trade context view for the whole run, or (with contextKey + dimensions) the trades in ONE regime bucket.… - `validate_indicator` _(read)_ — Compile check a Pine Script indicator: syntax/compile validation only, no run, no save. Use it while authoring a custom indicator to catch errors before… - `lint_indicator` _(read)_ — Offline diagnostics for a Pine Script indicator (quota free): style and correctness warnings without compiling or running. Complements validate_indicator when… - `preview_indicator` _(write)_ — Compile AND run a Pine Script indicator against real market data (no persist) to see its plotted series: the real data check before save_pine_indicator. Starts… - `get_indicator_preview` _(read)_ — Poll a preview_indicator job: returns progress while running and the compiled plot series + any runtime warnings when done. Read only. - `scan_market` _(read)_ — Scan the crypto market (RSPS engine): the current tradable universe with per token momentum/strength scores, price, 24h move and volume, to answer "what is… - `market_regime` _(read)_ — The crypto market's current regime verdict per timeframe (RSPS): RUN (broad risk on momentum), REVIEW (mixed), or SKIP (weak / risk off). Use it to judge… - `token_stats` _(read)_ — Per token forward outcome base rates from the screener: average return and win rate over the 1/3/7/30 bars AFTER a signal, for a timeframe + signal condition.… - `list_scan_alerts` _(read)_ — List your crypto scan alerts (the saved "notify me when tokens match X" rules), with their conditions, interval, active state, and last match. Read only. - `create_scan_alert` _(write)_ — Create a recurring crypto scan alert: get notified (Telegram/email) when tokens match a set of screener thresholds. Conditions keys: tf (e.g. "1d"), sectors… - `update_scan_alert` _(destructive)_ — Pause/resume, rename, recondition or retime an existing scan alert WITHOUT deleting it (delete loses the config). Pass the alert id (from list_scan_alerts) and… - `delete_scan_alert` _(destructive)_ — Delete one of your crypto scan alerts by id (from list_scan_alerts). Cannot be undone. - `market_sectors` _(read)_ — Crypto sector performance snapshot from the screener, which sectors are leading or lagging. Pass a date (YYYY-MM-DD) for a specific day, else the most recent… - `rsps_matrix` _(read)_ — Advanced: the pairwise RSPS dominance matrix for the top-k crypto tokens (who beats who) on a timeframe. Most tasks want scan_market or market_regime instead.… - `saved_scans` _(destructive)_ — Manage your saved screener filters. action:"list" (default) returns them; action:"create" persists one (name + filterJson, the screener filter state, upsert by… - `custom_benchmark` _(read)_ — Correlation and beta of the crypto universe against a benchmark symbol you choose (e.g. SUIUSDT) over a window, which tokens amplify it (high beta) and which… - `token_multitf` _(read)_ — One crypto token's recent OHLCV bars plus its multi timeframe screener rows (beta, percentile, forward returns) on a chosen timeframe. Raw series capped to… - `run_profiler` _(write)_ — Start the Perfect Token Profiler: it fingerprints what the top movers looked like BEFORE they ran (the indicator/return profile of winners over an H-bar… - `get_profiler` _(read)_ — Poll a run_profiler job: progress while running, and the full winner profile result once status is "done". Read only. - `get_candles` _(read)_ — Fetch raw OHLCV candles for ANY symbol/timeframe/date range, crypto (BTCUSDT) or stock (NASDAQ:AAPL). Use it to inspect price data directly or sanity check a… - `list_markets` _(read)_ — List the tradable crypto market universe (by market cap) so you can enumerate or VALIDATE a symbol before parse_strategy/run_backtest: reducing… - `get_notification_channels` _(read)_ — Show which notification channels (Telegram, email) are actually configured to deliver the user's scan alerts / backtest webhooks, so you can tell them where… - `export_candles` _(write)_ — Export a whole window of OHLCV candles as ONE CSV or JSONL file behind a short lived signed link: the bulk path when research needs every bar; get_candles… --- ## Connect Gateway URL: https://gateway.mewcp.com/personal/mcp Every request carries one header: Authorization: Bearer Replace `API_KEY` with your own key from the dashboard (Developer). ## Apps ### Claude Desktop Mac & Windows app - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json` - Windows: `%APPDATA%\Claude\claude_desktop_config.json` ```json { "mcpServers": { "mewcp": { "command": "npx", "args": [ "-y", "mcp-remote@latest", "https://gateway.mewcp.com/personal/mcp", "--header", "Authorization:${AUTH_HEADER}" ], "env": { "AUTH_HEADER": "Bearer API_KEY" } } } } ``` Already have an "mcpServers" section in your config? Just add the server entry inside it. 1. Open Claude Desktop → Settings → Developer → "Edit Config" 2. Paste the snippet inside the outer { } of the config file (merge with your existing "mcpServers" section if you have one) 3. Save the file, then quit Claude Desktop completely and reopen it 4. Start a new conversation — your tool will be available ### VS Code Copilot / Cline - Command Palette → "MCP: Open User Configuration" (opens mcp.json). For one project only, use .vscode/mcp.json instead. ```json { "mcp.servers": { "mewcp": { "type": "http", "url": "https://gateway.mewcp.com/personal/mcp", "headers": { "Authorization": "Bearer API_KEY" } } } } ``` Already have a "servers" section in your mcp.json? Just add the server entry inside it. 1. Open VS Code → Command Palette (Cmd+Shift+P / Ctrl+Shift+P) 2. Run "MCP: Open User Configuration" to open your mcp.json 3. Paste the snippet and save 4. Start the server when prompted (or from the MCP servers view) and use it in Copilot Chat ### Cursor AI-first editor - macOS: `~/.cursor/mcp.json` - Windows: `%USERPROFILE%\.cursor\mcp.json` ```json { "mcpServers": { "mewcp": { "url": "https://gateway.mewcp.com/personal/mcp", "headers": { "Authorization": "Bearer API_KEY" } } } } ``` Already have an "mcpServers" section in your mcp.json? Just add the server entry inside it. 1. Open Cursor → Settings → Cursor Settings → MCP 2. Click "Add new global MCP server" 3. Paste the snippet and save 4. Restart Cursor ### Codex OpenAI's CLI agent - Add the snippet to your Codex MCP config or your standard MCP config file for the CLI tool you use. ```json { "mcpServers": { "mewcp": { "type": "http", "url": "https://gateway.mewcp.com/personal/mcp", "headers": { "Authorization": "Bearer API_KEY" } } } } ``` Codex generally reads a standard MCP server block, so you can add this alongside your other configured servers. 1. Open your Codex MCP config or project-level config file 2. Paste the MewCP server block inside the config JSON/TOML structure your tool expects 3. Save the file and restart Codex 4. Verify the tool is available inside a fresh session ### Claude Code Anthropic's CLI agent - ~/.claude.json (user scope) or .mcp.json in your project root — create it if it doesn't exist. Or skip the file and use the CLI command below. ```json { "mcpServers": { "mewcp": { "type": "http", "url": "https://gateway.mewcp.com/personal/mcp", "headers": { "Authorization": "Bearer API_KEY" } } } } ``` Already have an "mcpServers" section in your config? Just add the server entry inside it. 1. Open ~/.claude.json (or .mcp.json in your project root) in a text editor 2. Paste the snippet inside the outer { } (merge with your existing "mcpServers" section if you have one) 3. Save the file and start (or restart) Claude Code 4. Or skip the file entirely and run the CLI command below instead ### OpenCode Open-source terminal agent - ~/.config/opencode/opencode.json (global) or opencode.json in your project root — create it if it doesn't exist. ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "mewcp": { "type": "remote", "url": "https://gateway.mewcp.com/personal/mcp", "enabled": true, "headers": { "Authorization": "Bearer API_KEY" } } } } ``` Already have an "mcp" section in your opencode.json? Just add the server entry inside it. 1. Open ~/.config/opencode/opencode.json (or opencode.json in your project root) in a text editor 2. Paste the snippet inside the outer { } (merge with your existing "mcp" section if you have one) 3. Save the file and start (or restart) OpenCode ### OpenClaw Self-hosted agent gateway - ~/.openclaw/openclaw.json — create it if it doesn't exist. ```json { "mcp": { "servers": { "mewcp": { "transport": "streamable-http", "url": "https://gateway.mewcp.com/personal/mcp", "enabled": true, "headers": { "Authorization": "Bearer API_KEY" } } } } } ``` Already have an "mcp" section in your openclaw.json? Just add the server entry inside "servers". 1. Open ~/.openclaw/openclaw.json in a text editor 2. Paste the snippet inside the outer { } (merge with your existing "mcp" section if you have one) 3. Save the file and restart OpenClaw ### Antigravity Google's agentic IDE - ~/.gemini/config/mcp_config.json (global) or .agents/mcp_config.json (workspace-local) — create it if it doesn't exist. ```json { "mcpServers": { "mewcp": { "serverUrl": "https://gateway.mewcp.com/personal/mcp", "headers": { "Authorization": "Bearer API_KEY" } } } } ``` Already have an "mcpServers" section in your config? Just add the server entry inside it. Remote servers must use the "serverUrl" field — the legacy "url"/"httpUrl" fields aren't supported. 1. In the editor's agent side panel, click "…" → "MCP Servers" → "Manage MCP Servers" → "View raw config" (Antigravity CLI: type /mcp instead to open the Interactive MCP Manager) 2. Paste the snippet inside the outer { } (merge with your existing "mcpServers" section if you have one) 3. Save the file — the server connects automatically ### Hermes Nous Research's CLI agent - config.yaml in your Hermes config directory (~/.hermes) — add this under a top-level "mcp_servers:" key. ```yaml mcp_servers: mewcp: url: "https://gateway.mewcp.com/personal/mcp" headers: Authorization: "Bearer API_KEY" ``` Already have an "mcp_servers" section in your config.yaml? Just add the server entry inside it. 1. Open config.yaml in your Hermes config directory 2. Paste the snippet under the top-level "mcp_servers:" key (merge with existing entries if you have any) 3. Save the file, then run /reload-mcp in Hermes (or start a fresh session) 4. Ask Hermes "Tell me which MCP-backed tools are available right now" to confirm it connected ### DeepSeek Harness DeepSeek's agent harness - cordis.yml in your DSH project — or the patch file you mount plugins from. ```yaml - id: mcp-mewcp name: '@deepseek-ai/dsh-mcp-client' config: serverName: mewcp transport: streamable-http url: https://gateway.mewcp.com/personal/mcp headers: Authorization: "Bearer API_KEY" ``` One plugin instance = one MCP server. Add this entry to your plugin list; don't nest it inside another entry. 1. Open cordis.yml (or your patch file) in your DSH project 2. Paste the entry into your plugin list, keeping the leading dash and indentation 3. Restart DSH (or let HMR reload) — tools register as mcp__mewcp__ 4. Verify with: dsh web --dump-config | grep -A3 mcp ## SDKs ### Python fastmcp client ```python import asyncio from fastmcp import Client from fastmcp.client.transports import StreamableHttpTransport SERVER_URL = "https://gateway.mewcp.com/personal/mcp" API_KEY = "API_KEY" transport = StreamableHttpTransport( url=SERVER_URL, headers={ "Authorization": f"Bearer {API_KEY}", } ) async def main(): client = Client(transport) async with client: tools = await client.list_tools() print(tools) asyncio.run(main()) ``` 1. Install fastmcp: pip install fastmcp 2. Copy the snippet into your project 3. Replace API_KEY with your key from the dashboard 4. Run your script ### TypeScript MCP SDK ```typescript import { Client } from "@modelcontextprotocol/sdk/client/index.js"; import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"; const SERVER_URL = "https://gateway.mewcp.com/personal/mcp"; const API_KEY = "API_KEY"; const transport = new StreamableHTTPClientTransport(new URL(SERVER_URL), { requestInit: { headers: { Authorization: `Bearer ${API_KEY}`, }, }, }); const client = new Client({ name: "mewcp-client", version: "1.0.0" }); await client.connect(transport); const tools = await client.listTools(); console.log(tools.tools.map((t) => t.name)); ``` 1. Install: npm install @modelcontextprotocol/sdk 2. Copy the snippet into your project 3. Replace API_KEY with your key from the dashboard 4. Run with Node 18+ as an ES module (e.g. npx tsx script.ts)