What is MCP in plain English?

MCP is a small specification, a JSON-RPC protocol, that lets any AI model talk to any external tool the same way. The model says "call get_order_book", the MCP server runs it, the answer comes back as structured data. It is to AI agents what HTTP is to websites.

Why does MCP matter for trading specifically?

Because trading is the application where the cost of bespoke connectors is highest. A modest agent already needs price data, order books, on-chain state, news, and execution: five separate APIs each with its own auth and quirks. MCP collapses that to one client and one server interface. The integration tax drops by an order of magnitude.

Is MCP just another API standard like CCXT?

No. CCXT is a Python library that normalises exchange APIs for human-written code. MCP is a model-facing protocol designed for autonomous agents: every tool ships with structured descriptions LLMs can read, and the protocol assumes the caller is an AI choosing which tool to invoke. The two are complementary; many MCP servers wrap CCXT internally.

Do I need MCP if I am writing a Python bot?

Only if your bot includes an LLM that should choose its own tools. For a deterministic strategy, raw APIs are simpler. The moment you want the model to decide whether to fetch order books, query on-chain data, or place an order, MCP turns three weeks of glue code into a config file.

How does MCP relate to function calling in OpenAI / Anthropic APIs?

Function calling is the model-side capability, the LLM knows how to emit a tool call. MCP is the infrastructure-side standard, how that tool call reaches the actual code. They compose: an Anthropic or OpenAI model can talk to any MCP server, and the same MCP server can serve any of those models.

What is the smallest possible MCP setup for trading?

A single MCP server exposing three tools: get_price, get_order_book, place_order. That is enough for an LLM to express almost any first-pass strategy. From there you add news ingestion, on-chain queries, and risk caps: each as an additional tool the model can call.

MCP for Trading: The Model Context Protocol, Explained

The term, defined

The Model Context Protocol (MCP) is an open specification, originally published by Anthropic in late 2024, for connecting AI models to external tools and data sources. A model talks to an MCP client; the client talks to one or more MCP servers; each server exposes a typed list of tools the model is allowed to call. The protocol itself is JSON-RPC over stdio or HTTP: boring, on purpose.

For trading the relevant property is uniformity. Whether the agent wants to read a Polymarket book, place a Binance order, query a Polygon RPC, or fetch a Coinglass funding-rate snapshot, the call shape is identical: tools/call({ name, arguments }). One client, many servers, no glue code.

What MCP replaced

Before MCP, every agentic trading project converged on the same three-week detour: write Python wrappers around five exchange APIs, retry-wrap them, normalise their error shapes, and document the result for the LLM in a system prompt that grew to 8000 tokens. Every new venue meant another wrapper, another prompt update, another regression. The combinatorial explosion is the n-by-m problem: n models × m data sources × k changes per quarter.

MCP collapses it to n + m. Each model speaks one client; each data source ships one server. New venue = drop in a server. New model = drop in a client. The integration cost stops growing quadratically.

Architecture, in three boxes

Component	Role	What lives here
Server	Wraps a data source or venue and exposes typed tools.	Connector code, auth, rate limits, schemas.
Client	Connects to N servers and forwards model tool calls.	Routing, multiplexing, capability negotiation.
Model	Decides which tool to call, when, with what arguments.	Reasoning, prompting, tool selection.

The model never knows or cares which server actually serves a tool. The server never knows or cares which model is asking. That decoupling is the entire point.

Five things a trader can do with MCP today

Plug an exchange into Claude or GPT in 5 lines. Spin up a CCXT-backed MCP server, configure the client, ask the model to "show me the BTC order book on Binance". It works on the first try.
Add news as a tool. A small MCP server that wraps the X firehose or a Reuters API turns "what just happened to oil prices" into a tool call instead of a 12-step custom pipeline.
Mix venues in one prompt. Buy spot on Coinbase if the Polymarket inflation market dislocates: the model issues two tool calls to two MCP servers in a single reasoning step.
Audit every action. Because every interaction with the outside world goes through MCP, your audit trail is structured, replayable, and not your problem to invent.
Swap models without rewriting. Yesterday's Claude Sonnet, tomorrow's GPT, next quarter's whatever: the MCP layer doesn't change. Avoiding lock-in to a single frontier lab is the underrated commercial reason this protocol won.

The agent loop, drawn properly

while True: state = sense(mcp_clients) # call read-only MCP tools decision = reason(model, state) # multi-LLM consensus, prompts if decision.action: receipt = act(mcp_clients, decision.action) log(state, decision, receipt) sleep(decision.next_check)

Three primitives. Sense calls read-only MCP tools (price, book, news). Reason calls the model, ideally as a consensus across several. Act calls execution tools (place order, swap, alert). Every line above is replaceable; the loop is not.

Why MCP matters more than the next hot framework

Most "agentic trading" libraries from 2024 are dead, including the ones that raised. The reason is the same reason most CGI-bin frameworks died after CGI itself was standardised: when the underlying protocol becomes good enough, the layer above stops mattering. MCP is the protocol; whatever you call your runtime ten months from now will sit on top of it.

The implication for builders: invest in MCP-shaped code. Write your strategies as functions that consume tool outputs, not as code that depends on a specific exchange SDK. When the SDK breaks (it will) or the venue changes (it will), the cost is one MCP server, not your whole stack.

What this means for NickAI

Every NickAI agent is an MCP client. Polymarket is an MCP server, Coinglass is an MCP server, Etherscan is an MCP server, Claude / GPT / Gemini are MCP-aware models. The product is the runtime that schedules them, runs multi-model consensus across them, caps the risk on the way out, and stores every byte for replay. The protocol is the substrate; the value is in the orchestration above it.

That is also why we will not build proprietary connectors. Anything we wrap, we wrap as an MCP server, and we open-source the ones the community will benefit from. The protocol is a tide that lifts every credible runtime; fighting it is how you lose.