AlgoVesta MCP Server: Let Claude, ChatGPT, Cursor and Gemini Trade Your Real Exchange and MetaTrader 5 Accounts

What this is: AlgoVesta runs a hosted Model Context Protocol (MCP) server that gives an AI assistant twenty real trading tools over one HTTPS link. Paste that single link into Claude, ChatGPT, Cursor, Claude Code, Gemini CLI or any MCP-capable client, and the assistant can read balances, open and close positions, move stop-loss and take-profit, and audit its own actions across 16 crypto exchanges and MetaTrader 5 forex at the same time — using the risk settings you already saved in AlgoVesta, behind a server-side policy wall no prompt can override. Every connection starts on a $5,000 paper balance and every action returns an ed25519-signed receipt.

The Model Context Protocol is an open standard for connecting AI assistants to external systems. Most trading-related MCP servers stream market data into a chat window. This one executes: it is an order-routing layer with a deterministic risk engine in front of it, and the AI is the caller — never the authority.

Quick start

Setup is three steps and needs no code. The whole flow lives in the MCP Connection tab of your AlgoVesta panel.

Your connection URL looks like this:

https://api.algovesta.com/u/avmcp_<your-key>/mcp

That URL is a credential. Anyone holding it can act within its scope on your accounts. Treat it like a password: never paste it into a public chat, a screenshot, a shared repository or a support ticket. If it leaks, revoke it from the panel — revocation takes effect immediately for new connections and drops open event streams within seconds.

Which AI assistants can connect

Any client that speaks MCP over Streamable HTTP can connect. The table below records what was verified against the live server, including the real limitations — some of these are constraints of the AI product, not of AlgoVesta, and you will hit them regardless of which MCP server you use.

Cursor example (mcp.json):

{
  "mcpServers": {
    "algovesta": {
      "url": "https://api.algovesta.com/u/avmcp_<your-key>/mcp"
    }
  }
}

Gemini CLI example (~/.gemini/settings.json) — note httpUrl:

{
  "mcpServers": {
    "algovesta": {
      "httpUrl": "https://api.algovesta.com/u/avmcp_<your-key>/mcp"
    }
  }
}

Claude Code:

claude mcp add --transport http algovesta https://api.algovesta.com/u/avmcp_<your-key>/mcp

Transport and protocol

Authentication and scopes

There are two ways to connect, and both resolve to the same tenant context. Tools never accept a user ID as a parameter — identity is read only from the authenticated connection, which is what makes cross-account access structurally impossible rather than merely forbidden.

Secret link

A key of the form avmcp_<32-byte urlsafe random>, embedded in the URL path. It is stored as an Argon2id hash plus a SHA-256 lookup hash; the plaintext exists only at the moment of creation and is never recoverable afterwards. Each key carries its own scope, its own label and its own revocation state, so you can run one paper key in Cursor and one live key in Claude and kill either independently.

OAuth 2.1

For clients that prefer a proper authorization flow. Supported grants are authorization_code and refresh_token, with rotating refresh tokens. PKCE with S256 is mandatory — a request without it is rejected. Dynamic client registration is available, so most clients configure themselves. Discovery documents:

GET https://api.algovesta.com/.well-known/oauth-authorization-server
GET https://api.algovesta.com/.well-known/oauth-protected-resource
POST https://api.algovesta.com/mcp/oauth/register
GET  https://api.algovesta.com/mcp/oauth/authorize
POST https://api.algovesta.com/mcp/oauth/token

The three scopes

Scopes are ranked, so a tool requiring paper refuses a read key with insufficient_scope. The boundary between simulated and real money is therefore a property of the key itself, not of a prompt, a setting or the model’s judgement.

Tool reference — all 20 tools

These are the exact tools your assistant sees. Read tools are safe to call without asking you first; the six write tools raise a confirmation in clients that support it, and three of them — place_order, close_position and cancel_order — are additionally marked destructive in their annotations.

get_portfolio_context

Takes no parameters. Returns a normalized view of every exchange account, every MetaTrader 5 account and the paper account belonging to the authenticated key — and nothing else. This is the call that makes “how am I doing?” a single question instead of sixteen.

Two fields matter more than the rest. For crypto accounts, balance and equity describe the futures wallet only; spot money is reported separately in spot_balance, so an assistant that reads only balance can wrongly conclude you have nothing. For MetaTrader 5 accounts, positions_source is either live_ea, meaning the position list was verified against the terminal, or unavailable, meaning the terminal could not be reached. In the unavailable case an empty position list does not mean “no open positions” — it means unknown, and the tool description instructs the model to say so rather than reassure you.

get_market_price

Parameters: venue, symbol. Returns {ok, venue, symbol, last, bid, ask, ts, source, age_sec}. Prices come from a shared cache refreshed roughly every second; on a miss the server makes one live REST call to the exchange. If the value is older than 10 seconds or cannot be fetched at all, that is stated explicitly — a stale price is never dressed up as a live one. If the symbol exists on no connected exchange, an informational DEX price may be returned together with a clear warning that you cannot trade it on your connected venues.

simulate_order

Required: venue, symbol, side, order_type, idempotency_key. Sends no order. Returns the expected fill, the margin impact and the policy verdict, plus the absolute stop-loss and take-profit prices the server derived. It is a read operation, so a well-behaved assistant calls it without asking permission, shows you one summary, and asks for exactly one confirmation before placing anything.

place_order

Required: venue, symbol, side, order_type, idempotency_key. Optional: account, market, size_usd, margin_usd, risk_pct, lots, leverage, sl, tp, sl_pct, tp_pct, take_profits, entry_price.

The idempotency_key is not decoration. If the same key arrives twice for the same user, the stored response is replayed and no second order is opened — which is what protects you when a client retries after a timeout, a phone loses signal mid-confirmation, or a model calls a tool twice.

Sizing is explicit on purpose. For crypto you pass exactly one of three fields, and they mean different things:

For forex and MetaTrader 5, size is given in lots instead, and leverage is not sent at all — the product is unleveraged and sizing comes from lot volume. Your stated lot size is used exactly and never rounded to a convenient value; if it falls outside your broker’s limits the order is refused and the permitted range is reported back.

Order size tolerance. Exchanges only accept certain lot increments, so the requested amount is matched to the nearest valid step. If the deviation stays within 20% the order proceeds and the exact deviation is reported back to you; beyond 20% the order is not opened and you are told, in numbers, which nearby amounts would work. That threshold was chosen by re-running every real order ever placed through the sizing function, not picked by intuition.

Omitted fields fall back to your saved settings. If you do not state a stop-loss, take-profit or leverage, the assistant is instructed to leave those fields empty, and the server fills them from the preferences saved in your panel — the same values the manual panel and the Telegram bot use. The response reports which fields came from saved settings in prefs_used. This exists because of a measured failure: when those fields were mandatory the model had to invent values, and five out of five orders overrode a customer’s own configuration.

close_position

Required: venue, symbol, side, idempotency_key. Optional: fraction (0 to 1], account, ticket. Works for crypto and for MetaTrader 5. Closing reduces risk, so the policy wall never blocks it — only the kill switch does. Ten calls with the same idempotency key perform exactly one close. If no matching position exists you get POSITION_NOT_FOUND together with the positions that are open on that venue, so the assistant can correct itself instead of guessing.

MetaTrader 5 has no partial close — the Expert Advisor closes fully — so use fraction=1 there. When several MT5 positions are open on the same symbol, ticket becomes mandatory, and while the target is ambiguous nothing is closed.

modify_position

Required: venue, symbol, side, idempotency_key, plus at least one of new_sl / new_tp. The stop-loss cannot be removed — the mandatory-SL rule holds here too. Ordering is validated: a long needs new_sl < mark < new_tp, a short the reverse. Sending only one side leaves the other at its current value rather than deleting it. As with closing, an ambiguous MT5 ticket means nothing is modified.

list_open_orders

Optional: venue. Lists pending limit orders with order_ref, venue, symbol, side, entry price, size and creation time.

One caveat worth knowing before you ask an assistant to review your open orders: the pending orders this tool tracks live in the paper book. Orders placed on a live venue through MCP are sent as market orders, so they fill instead of resting, and an empty list on a live account means there is nothing pending rather than that something disappeared.

cancel_order

Required: venue, order_ref, idempotency_key. If the reference does not belong to you the answer is NOT_FOUND — never a hint that someone else’s order exists. Like closing, it is risk-reducing and the policy wall does not block it.

compile_policy

Required: natural_text. You write a rule in plain language — “never risk more than 2% on one trade, no leverage above 10, only BTC and ETH” — and it compiles to a JSON policy, returned as a preview. Compiling never activates anything. Activation is a separate, deliberate step from the panel or via POST /api/mcp/policies/{policy_id}/activate, which means a model cannot loosen your rules by talking about them.

verify_receipt

Required: receipt_id. Returns signature_valid and chain_valid; an action is verified only when both are true. Receipts are ed25519-signed and hash-chained per user, so altering an earlier receipt breaks every later one and chain_valid turns false. The public key is served at /mcp/receipts/pubkey, so you can verify independently without trusting this endpoint. Older HMAC-era receipts return legacy=true.

replay_channel

Required: channel_ref. Optional: days (up to 90, default 30), policy_override. Answers “what if I had followed this Telegram channel for the last X days under my rules?” by replaying its past signals paper-style, with every signal passing through the policy wall so rejected ones never open. Progress arrives as replay_progress events. Results are cached for 24 hours and the tool is limited to 5 replays per hour. Output: {trades:[...], summary:{total_pnl, win_rate, max_drawdown, avg_rr, policy_rejections}}.

get_trade_history

Optional: venue, symbol, days (1–365, default 30), limit (1–200, default 50), market (crypto / forex / paper). Returns closed trades from all three sources in one list, newest first, plus a summary. The summary is deliberately conservative: avg_rr is computed only from trades where entry, stop-loss and exit are all known and rr_sample reports how many that was; total_pnl is null when several account currencies are mixed, with pnl_by_currency given instead; commission is not recorded anywhere, so fee stays null and crypto PnL is gross. If a source cannot be read, incomplete_sources names it rather than returning a short list as if it were complete.

compare_venues

Required: symbol. Optional: market (futures default, or spot), side. Returns, for each connected crypto exchange, the live price and — on venues that publish bid/ask — the spread in basis points, plus the price gap between venues. It does not choose a venue: your order still names one. Trading fees, order book depth and slippage are listed under basis.not_measured and are never estimated, and a venue that did not publish bid/ask appears in not_comparable_on_spread instead of being ranked as if its spread were zero. cheapest_measured therefore means “lowest measured spread”, not “cheapest overall”.

list_strategies

No parameters. Returns your TradingView strategies with their settings, plan_limit and can_create_more. auto_trade is reported per strategy so the assistant can tell you which ones are live. The webhook URL, demo URL and HMAC secret are stripped from the response — only webhook_url_configured and has_hmac_secret are exposed, because the URL itself is a credential.

create_strategy

Optional: name. Required: idempotency_key. Creates a TradingView strategy with auto_trade off; the field is not writable over MCP, so a newly created strategy cannot place real orders until you arm it yourself in the panel. Subject to your plan’s strategy quota — over the limit it returns a coded plan-limit error rather than silently doing nothing.

update_strategy

Required: strategy_id, changes, idempotency_key. Changes leverage (clamped 1–20), risk percentage (0.1–50), stop-loss and take-profit percentages, trailing and break-even settings, allowed symbols, target account and whether the strategy accepts signals. auto_trade, status and ip_allowlist are refused and returned in refused_fields; deletion is panel-only. Turning on reverse_enabled returns a warning, because from then on a BUY signal opens a SHORT.

backtest_my_signals

Optional: days (1–90, default 30), source (all / telegram / tradingview), symbols, margin_usd, leverage, sl_pct, tp_pct, max_hold_minutes, taker_fee_bps, partial_tp. Answers “what would have happened to my own past signals with different settings?” by replaying the signals you actually received against historical 1-minute mainnet bars — once with each signal’s original stop-loss, take-profit and leverage, and once with your overrides, so the two are directly comparable. Returns a job_ref immediately; read the result with get_job_status. Every result carries coverage (how many signals could actually be simulated, and why the rest could not) and assumptions (fees, slippage, partial take-profit, and what is not modelled). Signals with no stop-loss, with a stop-loss on the wrong side of the entry, or with no historical price data are counted and skipped rather than guessed at.

simulate_policy

Optional: policy_text (plain language), rules (already compiled), days (1–365, default 90). Applies a risk policy to the trades you actually closed and reports which ones it would have rejected, by which rule, and the PnL difference. Returns a job_ref. Two limits are stated in every result: rules that depend on account state at order time (open position count, daily loss, balance) are evaluated with zeros because that state cannot be reconstructed from closed trades, so those rules are under-counted rather than over-counted; and PnL comes from your recorded realised results, reported per currency and never added across currencies.

import_tradingview_backtest

Required: csv_text. Optional: taker_fee_bps, slippage_bps, leverage. Takes the CSV you export from TradingView’s Strategy Tester (List of Trades) and recomputes it with real trading costs: taker fees and measured slippage on both entry and exit. Pine Script is never executed or interpreted — only your exported trade list is recomputed, and the entry and exit prices stay exactly as TradingView reported them. Rows without a quantity column cannot carry fees, so they stay optimistic and their count is reported. Returns a job_ref.

get_job_status

Optional: job_ref. With a reference it returns that job’s state and, once finished, its result; with no argument it lists your recent jobs. status is one of PENDING, RUNNING (with a progress percentage), DONE, FAILED (a retry is scheduled), DEAD or CANCELLED. Jobs run one at a time, so queue_position tells you how many are ahead of yours. A reference that is not yours returns the same “not found” answer as one that does not exist, so job references cannot be enumerated.

Results do not live forever, and the limits are worth knowing before you build on them. Only the 20 most recent finished jobs keep their full result; older ones are reduced to their summary and come back with result_pruned: true, meaning the detailed rows are gone and the job has to be run again to regenerate them. Everything is deleted after 30 days. Backtest and policy runs are also written to your account’s backtest history, and the result carries the run_id they were stored under.

The policy wall

This is the part that makes handing tools to a language model defensible. Your rules are compiled once into JSON, validated against a fixed schema, and then evaluated server-side and deterministically on every order. The model never evaluates them, never sees a way around them, and cannot be talked into relaxing them — not by you in a moment of impatience, and not by a prompt injected through a webpage or a Telegram message it happened to read. A violation is a hard reject with an audit entry.

A compiled policy that fails schema validation cannot be activated at all. There is no partially-valid policy.

Safety model

On leverage, plainly: AlgoVesta does not impose a leverage ceiling on your own account — your exchange does, and you can set your own ceiling with the leverage_cap policy rule. Forex through MetaTrader 5 is unleveraged in this path and sized by lots. Anyone telling you a platform “caps leverage at 20x” here is describing something that does not exist.

Errors

Domain-level refusals arrive as structured results rather than transport errors, so the assistant can act on them: VENUE_NOT_CONNECTED, ACCOUNT_REQUIRED, ACCOUNT_AMBIGUOUS, ACCOUNT_NOT_FOUND, POSITION_NOT_FOUND, MISSING_FIELDS, INVALID_SIDE, SL_REMOVAL_FORBIDDEN. Error messages never leak internal detail, and never reveal anything about another account.

Rate limits

Live events

A tenant-isolated server-sent event stream is available at /mcp/events (OAuth) and /u/<key>/events (secret link), with Last-Event-ID reconnection so a dropped connection resumes rather than restarts. Event types: fill, policy_rejected, position_closed, sl_hit, tp_hit, and replay_progress during a channel replay.

Venues — 16 exchanges and MetaTrader 5

One connection reaches all of them. A venue becomes available to the AI only after you connect it in AlgoVesta; asking for one you have not connected returns VENUE_NOT_CONNECTED rather than a guess.

Six of these — Binance, Bybit, OKX, Gate.io, KuCoin and Bitget — have been verified end to end with real money on both futures and spot, with stop-loss and take-profit confirmed to exist on the exchange itself and to match the recorded values exactly. Each exchange has its own quirks, and the differences are deliberate rather than gaps: Bybit and Bitget do not accept a second take-profit leg on spot, OKX spot is routed through the raw API to keep a cash account from silently becoming a margin account, Binance spot enforces a minimum notional before buying, and KuCoin market buys are placed in cost mode.

Spot and futures are always kept apart. The same symbol on the two markets is a separate row, a separate price feed and a separate key — one never bleeds into the other.

MetaTrader 5 with zero installation

You do not install anything for forex. There is no VPS to rent, no MetaTrader terminal to keep alive on your own machine, no Expert Advisor for you to attach and no third-party bridge account to buy. AlgoVesta runs the MetaTrader 5 terminals on its own managed servers and keeps them connected to your broker around the clock. You enter your account credentials once and your AI assistant can trade that account from then on. Position data returned to the assistant is verified against the terminal, and when it cannot be verified the tool says so instead of implying an empty account.

Roadmap — global equities

Measured latency

These are measurements, not marketing numbers.

Time spent inside your AI client — the model thinking, and you confirming — is not included and will usually dominate. This server is not a low-latency execution venue and is not sold as one.

Panel REST endpoints

Everything the AI cannot and should not do itself lives behind your normal logged-in session.

POST   /api/mcp/keys                            create a key (live requires 2FA)
GET    /api/mcp/keys                            list keys
DELETE /api/mcp/keys/{key_id}                   revoke a key
POST   /api/mcp/live-code                       send the live-scope confirmation code
POST   /api/mcp/freeze  |  /api/mcp/unfreeze    kill switch
GET    /api/mcp/status                          connection status
GET    /api/mcp/policies                        list policies
POST   /api/mcp/policies/compile                compile without activating
POST   /api/mcp/policies/{id}/activate          activate
POST   /api/mcp/policies/{id}/deactivate        deactivate
GET    /api/mcp/audit                           audit log
GET    /api/mcp/receipts                        receipts
GET    /api/mcp/receipts/{receipt_id}/verify    verify one receipt
GET    /api/mcp/pubkey                          receipt public key
GET    /api/mcp/paper  |  POST /api/mcp/paper/reset

What you need to have

The MCP connection itself is part of the product and is not sold separately. What gates you in practice is what the AI is meant to reach: paper trading needs only an account, while live trading needs an active paid plan and the connected accounts that plan allows — and live MetaTrader 5 trading on real money additionally requires you to opt in explicitly for that account. Plan limits on the number of exchange keys and MetaTrader accounts are listed on the pricing page. You can try everything on the $5,000 paper balance before any of that matters.

Frequently asked questions

Related: MCP for AI assistants · MCP server setup · supported exchanges · MetaTrader 5 forex · TradingView automation · what an MCP trading server is · security · pricing.

Trading carries risk. Automation does not remove it, and an AI assistant is not investment advice. Start on paper.