Vordium MCP server

Connect any AI that speaks the Model Context Protocol — Claude, ChatGPT, Cursor, or your own agent — to Vordium. It can read markets, prices, order books, funding, accounts, agents, rewards and the explorer, and, once the network switches agent trading on, place, change, close and cancel orders as an agent whose limits the chain enforces — every order shown to you to confirm first.

No install: add https://mcp.vordium.com/testnet/mcp to your client as a remote MCP server (streamable HTTP, no account). That server is read-only; mcp.vordium.com has the steps for each client. Run this package on your own machine to trade as an agent.

Testnet first. The server reads the Vordium testnet unless you name the main network. Testnet tokens have no value.
Runs on your machine. It talks to your MCP client over stdio. No account, no API key.
Your keys stay with you. No tool takes a private key or recovery phrase, and the server refuses any argument that looks like one. To trade, the server uses an agent key from your OS keychain (or a file only you can read); it signs on your machine, and only the signature leaves it.
The chain enforces the limits. An agent trades under the policy and per-market limits set by its owner on-chain. This server only refuses early: while the network reports agent trading off, every tool that signs is refused before anything is signed.
Nothing is remembered. Every value is read from the network when a tool is called. The server also checks that the network it reads is the one it was started for, and refuses every tool if not.
Each network is pinned. This release carries the chain id and genesis of the testnet (101102) and the mainnet (101101). Before anything is signed, the network spec, the node's /status, the network's own answer and eth_chainId must report the pinned values; otherwise reads still work, get_network shows the difference, and every tool that signs is refused with the network, the expected and the reported values. A new genesis needs a new release.

Install

You need Python 3.9 or later. The simplest way to run it is uv, which fetches and runs the package in one step:

uvx vordium-mcp --version

Or install it with pipx or pip:

pipx install vordium-mcp

Reading needs nothing beyond the Python standard library. Trading needs the Vordium SDK for signing: uvx --from "vordium-mcp[trade]" vordium-mcp or pipx install "vordium-mcp[trade]".

Connect your client

Claude Desktop

Add this to claude_desktop_config.json (Settings → Developer → Edit Config), then restart Claude Desktop:

{
  "mcpServers": {
    "vordium": {
      "command": "uvx",
      "args": ["vordium-mcp"]
    }
  }
}

Claude Code

claude mcp add vordium -- uvx vordium-mcp

Cursor

Add this to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "vordium": {
      "command": "uvx",
      "args": ["vordium-mcp"]
    }
  }
}

If you installed with pipx or pip, use "command": "vordium-mcp" and "args": [] instead.

Then ask, for example: "What does the ETH order book on Vordium look like?" or "Is agent trading on?"

Tools

Tool	What it does	Where
`get_status`	Is the network live: block height, blocks per second, validators agreeing, and whether trading and deposits are open.	everywhere
`get_network`	Which Vordium network this server reads, checked against the network itself, and the facts it vouches for (chain id, genesis, finalized block, agent trading on or off), and whether it matches the chain id and genesis this release is pinned to (nothing is signed otherwise).	everywhere
`get_markets`	Every market the network lists, with its state, leverage, fees and trading rules (tick, lot, minimum size).	everywhere
`get_fees`	Maker and taker fees, maximum leverage, initial and maintenance margin, and the liquidation terms as the network publishes them (the fee, or none), for every market or one.	everywhere
`get_oracle`	Oracle and mark prices, for every market or one.	everywhere
`get_orderbook`	Resting bids and asks for one market, best first, with the spread.	everywhere
`get_candles`	Price candles (open, high, low, close, volume) for one market.	everywhere
`get_trades`	The latest trades in one market: time, side, price, size and value.	everywhere
`get_funding`	The funding rate, interval and next settlement for one market, and optionally its past settlements.	everywhere
`get_account`	One account at a glance: USDC balances, positions with entry, mark, unrealized PnL and liquidation price, and open orders.	everywhere
`get_fills`	An account's recent trades with price, size, fee and realized PnL, as the explorer records them.	everywhere
`get_balance`	An account's USDC: available to trade, in positions, reserved by orders, unrealized PnL.	everywhere
`get_positions`	An account's open positions as the chain stores them.	everywhere
`get_orders`	An account's resting orders, with their order ids.	everywhere
`get_agents`	An owner's AI agents: status, limits and policy, usage, and each agent's latest actions.	everywhere
`get_policy`	Each agent's policy and market limits as the chain stores them, and whether the network enforces them now.	everywhere
`get_risk`	Each agent's usage against its policy, as the chain accounts it.	everywhere
`get_tiers`	Agent limits by tier and the referral tier table, where the network serves them.	everywhere
`get_season`	The current rewards season: status, VORD budget, rules, participants and how many qualify.	everywhere
`get_points`	An address's season points by source, its rank, whether it qualifies and its VORD estimate.	everywhere
`get_leaderboard`	The season's points leaderboard, or the trading leaderboard by PnL, ROI or volume.	everywhere
`get_referrals`	An address's referral code, tier, referred volume and earnings.	everywhere
`get_tx`	One EVM transaction by hash: block, sender, receiver, value and result, with its explorer link. The hash is sent to the explorer to look it up, so give only a transaction hash, never a key.	everywhere
`get_block`	One block by height: time, proposer, operations, with its explorer link.	everywhere
`get_address`	An address summary: account value, open positions, agents and EVM transactions, with its explorer link.	everywhere
`get_order`	One resting order by its id: market, side, price, size left. An order that is not resting now (it filled or was cancelled) is reported as gone.	everywhere
`check_order`	Check an order against every rule the network runs (market, size, price band, margin, the agent's limits) for the configured owner and agent, without signing or sending anything: whether it would be taken, each rule it breaks with the real numbers, and fixes that pass.	local
`my_buying_power`	Per market, the largest long and short the configured owner can open at each allowed leverage, from free margin and the agent's limits together.	local
`place_order`	Place a market or limit order as the configured agent, after checking it against every network rule (an order the network would refuse is not signed).	local, signs
`close_position`	Close the owner's position in one market — all of it, or a fraction — with a reduce-only order (market by default), with the full pre-trade check.	local, signs
`set_tpsl`	Set, move or remove the take-profit and stop-loss of the owner's position in one market. A leg you do not name stays as it is; remove takes a leg off. A take-profit sits on the profit side of the mark, a stop-loss on the loss side.	local, signs
`modify_order`	Move one resting order to a new price and/or size: a signed cancel-and-replace (the new order gets a new id and no time priority); the new order is checked against the network's rules (its margin is the chain's to judge).	local, signs
`cancel_order`	Cancel one of the configured owner's resting orders, as the agent.	local, signs
`cancel_all`	Cancel every resting order of the configured owner — in one market, or in all of them — as the agent.	local, signs
`stop_all`	Stop this server from signing anything new (only cancels, until you run `vordium-mcp resume` on this machine), then cancel every resting order. Revoking the agent itself on the chain is the owner's step in Vordex → Agents.	local, signs

"Where": everywhere runs locally and on the hosted read-only server; local needs this server on your machine with --owner; local, signs also signs with your agent key and changes what the account holds.

Every successful result starts with summary, one plain sentence, and carries network, followed by the figures and the units they are in. Each tool publishes its result shape (outputSchema) and returns it as structured content as well as text. Each tool also says what it does to your account: read tools are marked read-only; the ones that sign are marked destructive and not safe to repeat, so your AI app knows to ask. The server also offers ready-made prompts (market overview, check an account, season standings, explain a transaction, compare markets) and resources (the network spec, a fees table, documentation links).

A tool that cannot read the network says so; it never answers from memory. A refusal comes back as a tool error that names the readings behind it, and says whether anything was signed or sent.

Trading as an agent (on your own computer, 24/7)

An agent is a key its owner registers on-chain and limits with a policy. The key is made on, and never leaves, the machine that runs this server; the owner's own key never goes into it. See Agents.

Make the agent key on this machine. Only its address is printed; the file is readable by you alone:
```
uvx --from "vordium-mcp[trade]" vordium-mcp new-agent-key ~/.vordium/agent.key
```
Move it into your OS keychain (macOS Keychain, Windows Credential Manager, or the Secret Service on Linux), then delete the file:
```
uvx --from "vordium-mcp[trade]" vordium-mcp key store --owner 0xYOUR_OWNER_ADDRESS --network testnet --from-file ~/.vordium/agent.key
```
On a machine with no secure keychain, keep the file instead (mode 600; the server refuses to start with a key file other users can read), or an encrypted keystore with --agent-key-passphrase-file.
In Vordex, open Agents → New agent → Use my own key, paste that address and set its limits (markets, largest order, leverage, daily loss) and what it may do (place, cancel, modify, take-profit / stop-loss, close). Your wallet signs; the limits are stored on-chain.
Start the server with trading allowed:

{
  "mcpServers": {
    "vordium": {
      "command": "uvx",
      "args": ["--from", "vordium-mcp[trade]", "vordium-mcp", "--allow-trading", "--owner", "0xYOUR_OWNER_ADDRESS"]
    }
  }
}

(With a key file instead of the keychain, add "--agent-key-file", "~/.vordium/agent.key".)

Every order asks you. Before an order is signed — place_order, close_position, modify_order, set_tpsl — your AI app shows it to you (MCP elicitation) and nothing is signed unless you confirm. An app that cannot ask is refused, with the reason. If you want orders within the agent's on-chain limits to go through without asking, start the server with --orders auto; that is your choice, never the default. Cancels (cancel_order, cancel_all) and stop_all take risk off and do not ask.

Stop everything. stop_all stops this server from signing anything new (only cancels, until you run vordium-mcp resume --owner 0x… --network testnet|mainnet on this machine) and cancels every resting order. To end the agent itself on the chain, revoke it in Vordex → Agents: an agent key cannot revoke itself.

Before it signs, the server checks, in this order:

The network reports agent trading on (agent_policy_active, read live from the network's own answer). If not, it refuses at once.
You started it with --allow-trading, an owner and an agent key (keychain or file), and it was not stopped.
The key is a registered agent of that owner, not revoked, not expired, and is not the owner's key; for modify_order and set_tpsl, the agent is allowed to do that. (The main network also asks for a confirmed session for the agent key; the test network takes the agent's own signature.)
The network reports trading open, and the market is trading.
The order passes every rule the network runs: the market's size steps and limits, the price band, the margin the account has free, and the agent's own limits. An order the network would refuse is not signed; the answer names each rule with the real numbers and fixes that pass.
You confirm it (unless you chose --orders auto).

check_order runs step 5 alone (nothing signed or sent) and my_buying_power shows, per market, the largest long and short at each allowed leverage. The chain then applies the agent's policy and limits on every validator and returns its answer unchanged; read get_orders and get_positions to see what was applied.

The main network

The main network is used only when you name it:

"args": ["vordium-mcp", "--network", "mainnet"]

Use --rest to read from your own node instead of the public one; the server still checks that the node serves the network you named, and signs only when it reports that network's pinned chain id and genesis.

Read-only over HTTP

vordium-mcp --http localhost:8770 serves the read tools over streamable HTTP at /mcp, for clients that connect to a URL. It lists no trading tools and takes no key or trading flag. It answers JSON (no event stream), limits each client to --rate-per-minute requests (default 120, --burst at once), refuses browser origins unless allowed with --allow-origin, and keeps no request log. Put it behind a proxy for anything beyond your own machine, and pass --trust-proxy there so the limit applies per client. --hosted sets it up as a public server behind a proxy: any origin, 60 requests a minute per connection with bursts of 20 (a connection is the Mcp-Session-Id the server gives at initialize; a client that sends none is counted by its address), at most 20 times that per address across its connections, and every read shared for at least 2 seconds. /health answers the server's counters (calls per tool; no address or argument).

Settings

Flag	Default
`--network testnet\|mainnet`	`testnet`
`--rest URL`	the network's public REST base
`--allow-trading`	off
`--owner 0x…`	none
`--agent-key-file PATH`	none: the OS keychain
`--agent-key-passphrase-file PATH`	none (encrypted keystores only)
`--orders ask\|auto`	`ask` (every order asks you)
`--state-dir PATH`	`~/.vordium-mcp` (where `stop_all` keeps its lock)
`--http HOST:PORT`	off (stdio)
`--rate-per-minute N`	120 (hosted 60)
`--burst N`	the per-minute rate (hosted 20)
`--allow-origin URL`	none (`*` allows any)
`--hosted`	off

Most flags can also be set in the environment; vordium-mcp --help prints each name. A flag wins over the environment. No setting holds a key: the key is in the keychain or a file the setting names.

Commands: vordium-mcp new-agent-key PATH, vordium-mcp key store|status|delete --owner 0x…, vordium-mcp resume --owner 0x… --network testnet|mainnet.

Upgrading

Each release in CHANGELOG.md says what changed and what to update in your setup.

Develop

pip install -e ".[trade]" pytest
pytest -q tests                        # no network
python -m vordium_mcp.toolsdoc check   # the tools match tools.lock.json
# the live testnet test reads the real testnet when switched on; nothing is signed or sent

vordium-mcp

Documentation