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 and cancel orders as an agent whose limits the chain enforces.

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, you point the server at a file holding an agent key; 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, place_order and cancel_order are 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.

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

Every result starts with summary, one plain sentence, followed by the figures and the units they are in. 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 that nothing was signed or sent.

Trading as an agent

An agent is a key that its owner registers on-chain, gives a session, and limits with a policy. See Agents and Session keys. The owner's own key never goes into this server.

1. Register the agent and create its session from the owner's wallet.
2. Save the agent's private key in a file only you can read: chmod 600 ~/.vordium/agent.key.
3. Start the server with trading allowed:

{
  "mcpServers": {
    "vordium": {
      "command": "uvx",
      "args": ["--from", "vordium-mcp[trade]", "vordium-mcp", "--allow-trading",
               "--owner", "0xYOUR_OWNER_ADDRESS", "--agent-key-file", "~/.vordium/agent.key"]
    }
  }
}

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

1. The network reports agent trading on (agent_policy_active, read live from the network's own answer). If not, it refuses at once.
2. You started it with --allow-trading, an owner and an agent key file.
3. The key is a registered agent of that owner, not revoked, not expired, with a confirmed session, and is not the owner's key.
4. The network reports trading open, and the market is trading.

The chain then applies the agent's policy and limits on every validator. An order this server lets through can still be refused or dropped by the chain; the server returns the chain's answer unchanged and never reports a fill it did not see. 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.

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

vordium-mcp --help lists them, with the environment form of each.

Develop

pip install -e ".[trade]" pytest
pytest -q tests                        # no network
# the live testnet test reads the real testnet when switched on; nothing is signed or sent

Links

• Documentation: https://docs.vordium.com/build/mcp/
• Explorer: https://vordscan.io
• Python SDK: https://pypi.org/project/vordium/

MIT licensed.