Model Context Protocol (MCP) is an open standard that lets AI assistants connect to outside tools and data through one common format. Its reach is no longer theoretical: a 2025 measurement study collected 8,060 MCP servers and 341 clients, and a comparative study of MCP collections counted 26,404 servers in the MCPWorld collection by September 2025, the largest among the collections it compared.
Why does an assistant that can write a convincing token thesis fail to name the wallets that bought in the last hour?
The usual explanation is that the model hallucinated. A simpler cause sits underneath: the assistant never had a channel to ask anyone. A language model answering from training data does recall, not research, like a sharp analyst locked in a room with last year's newspapers. No prompt repairs a connection that was never built.
MCP builds that connection, but a connection is not a guarantee. The useful split for a crypto reader is between read-only questions, such as which wallets bought or how holdings shifted, and anything that signs, sends or trades. The first is safe to explore once you learn to check the answers. The second deserves far more caution.
Table of Contents
- What Model Context Protocol Is and How It Emerged
- The Problem MCP Solves for AI Assistants
- MCP Versus Direct APIs and Function Calling
- The Building Blocks MCP Servers Expose
- Local vs Remote Connections and How Access Is Controlled
- What MCP Changes for Crypto Research and Building
- Test One Read-Only MCP Connection Before You Trust It
What Model Context Protocol Is and How It Emerged
The shortest way to hold MCP in your head is a port, not a product. USB-C is the closest everyday parallel: one connector standard lets a monitor, a camera and a charger plug into any laptop, so a hardware maker builds one cable instead of five different plugs for five machines. Anthropic announced and open-sourced the Model Context Protocol on November 25, 2024 as an open protocol for connecting large-language-model applications with external data sources and tools, shipping the specification and software-development kits, local MCP server support in Claude Desktop, and an open-source repository of reference servers alongside it.
The port analogy stops at one important detail. MCP is neither a model nor a database. It standardizes the connection layer between an AI agent and an outside system, which is why the same protocol can front a document store, a ticketing tool or a wallet analytics service without changing shape on either side.
Three roles in one request path
Every MCP interaction has three parts, and confusing them is where most early misunderstandings come from.
- The host is the application a person talks to, such as a chat assistant, a code editor or a desktop app.
- The client lives inside the host and manages one connection to one server at a time.
- The server exposes something useful: a file system, a database, an API, or a specialized dataset like blockchain analytics.
The host asks, the client connects, and the server answers with structured results the assistant can use in the same reply. That timing matters. The assistant calls the server while it is answering, so it works from current records rather than guessing from weights frozen at training time.
One limit of the port analogy matters for crypto readers. The standard says nothing about what a server is allowed to do. One server exposes read-only lookups, such as fetching wallet holdings or token flows. Another exposes tools that act, such as signing or sending a transaction. Both travel over the same connection, so checking which kind you are adding is part of deciding whether to trust it.
A dated timeline of changes
MCP has moved fast, and the version dates are worth knowing because a server built against an early draft may not support newer features. The initial specification dated November 5, 2024 established JSON-RPC messaging, capability negotiation, the host-client-server architecture, and the core primitives for tools, resources and prompts. The March 26, 2025 revision added OAuth 2.1-oriented authorization work, Streamable HTTP, tool annotations, audio and completions. The June 18, 2025 release added structured tool output, elicitation, resource links and a more formal OAuth resource-server model.
Governance shifted as the protocol matured. Anthropic opened an official community-driven registry for discovering servers and donated the protocol to a foundation associated with the Linux Foundation, so the standard's direction no longer sits with a single company.

Version gaps between those releases are handled at connection time. Client and server declare their capabilities before any tool runs, so an older client talking to a newer server gets fewer features rather than a failed session.
Why the dates matter: when you evaluate a data provider, ask which specification version its server targets. Structured tool output only exists from the June 2025 revision onward, and remote authorization support arrived in March 2025.
The Problem MCP Solves for AI Assistants
Before the standard, connecting an AI assistant to market data meant writing a custom connector for that one app. A trader asking which wallets bought a token in the last hour would open a block explorer, scroll a social feed, copy numbers into a chat window and hope the paste was accurate. Every assistant needed its own integration, and every integration broke on its own when an upstream API changed shape.
The reason the connector problem got solved rather than tolerated is scale. A 2025 measurement study of the MCP ecosystem collected 8,401 distinct entries, 8,060 servers and 341 clients, according to the study's authors. A separate study comparing server collections found the MCPWorld collection listed 26,404 servers as of September 2025, the largest count among those compared. That many servers only makes sense if one client can speak to all of them.
| Situation | Without MCP | With MCP |
|---|---|---|
| Connecting a new data source | Custom connector built for each AI app | One MCP server reused by any supported host |
| Answer freshness | Relies on training data or pasted numbers | Calls the server at answer time for current results |
| Maintenance when an API changes | Each connector breaks and is fixed separately | The server is updated once and hosts keep the same interface |
| Crypto lookup example | Trader copies wallet and token data from explorers | Assistant requests holdings and trader PnL as structured data |
| Checking the source | Hard to tell where a figure came from | Results arrive as tool output that names the server |
That last row is the one people skip. A standard connection does not certify the answer. The protocol carries whatever the server sends, so a badly attributed wallet or a stale index travels just as smoothly as a good one.
For teams deciding who gets to hold and call these connections in production, controlling agent access with Sickle covers the permission side of the same problem: how an agent's reach is scoped, logged and limited once several tools sit behind one assistant.
The tradeoff in one line: MCP removes the connector work. It does not remove the need to check where a number came from.
MCP Versus Direct APIs and Function Calling
Take one task, looking up a wallet's realized PnL, and give a model access to it three different ways. The differences show up in who writes what code and who maintains it later.
Direct REST call. Your own application calls the endpoint, parses the JSON and hands the result to the model. This is the most controlled option and the least portable, because every application that needs the same figure writes its own version of that call.
Function calling inside one app. You define a tool schema in the application and the model picks it when relevant. It works well within that product and has to be rebuilt in the next one.
MCP. The server publishes its tools, resources and prompts in a standard form, and any compliant host discovers and calls them after connecting. Write the server once, and Claude, ChatGPT, Cursor and a custom agent can all use it.
None of these replaces the others. A data provider can keep a REST API for dashboards, bots and backfills, then add an MCP server for AI hosts, both wrapping the same underlying records. If you are comparing data sources at the API level first, this breakdown of crypto data APIs is the place to start before deciding whether an MCP layer sits on top.
The cost is real. MCP adds a protocol layer and a process to run and monitor. It pays off when several assistants or agents reuse the same data, and a single app making one fixed call may not need it at all.
The Building Blocks MCP Servers Expose
Inside one connection, MCP runs on JSON-RPC, a plain request-and-response message format. When a host and server first meet they negotiate capabilities, so each side knows which features the other supports before anything is called. After that the server lists what it offers through three primitives, and the separation between them is what makes the architecture useful rather than decorative.
| Primitive | What the server provides | Crypto example |
|---|---|---|
| Tools | Executable operations the model calls with inputs | Parameterized PnL lookup for one wallet address |
| Resources | Contextual data the host can read | Token metadata or a wallet's recent transaction records |
| Prompts | Reusable interaction templates the user can select | A standard checklist for reviewing a token's holder concentration |
The distinction has practical consequences. A crypto data server can return wallet or market records as resources, expose parameterized analytics as tools, and offer repeatable investigation workflows as prompts, all without embedding those functions inside the model itself. The MCP architecture specification describes this as separating protocol semantics from transport, which is why one server can serve several different hosts at once.
For a reader browsing servers rather than building them, directories help. The Mcpgram entry on AI Tool Seekers is an example of how a single server gets catalogued so you can see what it exposes before you connect it to anything.
Where the protocol stops helping
This is the part to internalize. MCP standardizes invocation and capability discovery. It does not make the underlying data real-time or correct. Freshness, chain indexing, wallet attribution, PnL methodology, rate limits and per-tool authorization all remain the responsibility of whoever operates the server.
Practical rule: before trusting any figure that arrives through a tool, ask the provider four questions. How are wallets attributed to a person or entity? How is realized and unrealized PnL calculated? How quickly are new blocks indexed? What rate limits apply to your plan?
If a provider cannot answer those plainly, treat its output as a lead to verify, not a finding to act on.
Local vs Remote Connections and How Access Is Controlled
Two connection types cover almost every real deployment, and they carry different security assumptions.
| Connection type | Where it runs | Typical use | Access control |
|---|---|---|---|
| Stdio | Local process on the user's machine | Desktop tools and local files | Runs with the user's own local permissions |
| Streamable HTTP | Remote server reached over HTTPS | Hosted data services used from several AI apps | OAuth 2.1 bearer tokens scoped to that server |
Local servers suit files and desktop tools because they inherit your machine's permissions and stay off the network. Remote servers suit hosted data used from several assistants at once, which means authorization becomes the design problem rather than an afterthought.
The MCP authorization specification treats a protected server as an OAuth 2.1 resource server and the client as an OAuth 2.1 client acting for the user, with bearer tokens, authorization-server metadata, dynamic client registration and resource indicators. Three rules follow from that model and are worth stating flatly.
Use HTTPS for authorization endpoints. Anything else leaks tokens in transit.
Scope tokens to one server. A credential minted for one MCP resource should never be replayed against another, and the server should validate that the token was issued specifically for it.
Keep credentials out of prompts. Anything the model can see can end up in a transcript, a log or a third party's context window.
Read-only tools can supply holdings, flows, trader profiles or social signals without touching a private key, which is the whole reason research use of MCP is the safe half of the story. If an application later adds execution, signing belongs in a separately governed component with explicit user approval, policy checks and audit logging. Our own security guide walks through how that separation is meant to work in practice.
Capability negotiation narrows integration ambiguity, but it does not replace schema validation, prompt-injection defenses, output provenance or independent confirmation of high-impact actions. Those stay with the people running the system.
What MCP Changes for Crypto Research and Building
A live connection changes the shape of a research session, not just its speed. Instead of hopping between explorers and feeds, you ask the question once and the assistant calls the tools it needs.

Three workflows cover most of what people do in practice. A trader researching a token asks for the wallets behind it, the positions those traders hold and the flows in the past hour, and gets one assembled answer instead of a manual sweep. An analyst tracking influential traders keeps a single conversation open and asks what changed in holdings since the last check. A builder exposes read-only analytics as MCP tools so a dashboard, a bot and a chat assistant all reuse one integration rather than three.
The verification list shrinks to four items, and each one is answerable. Attribution: how does the provider decide that a wallet belongs to a named trader or entity? PnL method: what counts as realized versus unrealized, and at what price marks? Indexing lag: how long after a block lands does the data reflect it? Rate limits: how many calls does your plan allow, and what happens when you hit the ceiling?
Get those four answers in writing and you know what kind of tool you are holding. Skip them and you are trusting a number because it looked tidy in a table.
MCP makes live data easy to reach. A research conclusion still needs a human check against the source.
Test One Read-Only MCP Connection Before You Trust It
The safe way to adopt this is a single controlled test, not a migration. Work through the checklist below in order, and stop at any step that fails.
- Confirm the scope is read-only. Research tasks should use tools that cannot move funds. Any trade action belongs to a separate wallet with its own approval step.
- Inspect the exposed tools. Coverage differs by tool, so check which chains, datasets and permissions each one offers before assuming a query will work.
- Check the authorization method. For a remote server, confirm HTTPS endpoints and tokens scoped to that server, then keep the credential out of anything the model can read.
- Ask one question you can verify by hand. Pick a wallet whose holdings you already know from an explorer, and compare the assistant's answer against it.
- Watch the cost side. Track per-call spend and remaining balance so a long research session does not turn into a surprise.
- Rotate anything that leaks. If a credential appears in a prompt, a transcript or a shared screenshot, replace it.
Connection itself is short work. With StalkChain, you copy our MCP link into your AI client once, and that same link works across Claude, ChatGPT, Grok, Cursor, Claude Code and any other MCP client, so you connect once and inspect the tools discovered for your account. Chain coverage and permissions vary by tool, which is exactly why the manual check comes before the wider rollout. The connect Claude guide walks through the setup step by step, and if you are wiring an agent rather than a chat window, this guide on how to configure MCP access for your agent covers the client-side mechanics.
Then run the comparison. Ask the verifiable question, put the answer beside your hand-checked source, and look at whether the coverage, freshness and attribution meet what you need. If they match, widen the workflow to a second question and a second chain. If they do not, stop there and ask the provider how it attributes and calculates the data. Treat that first connection as a test with a pass mark, not a commitment.
StalkChain runs a hosted MCP server and a REST API over the same data, so you can connect one link to the assistant you already use and ask about wallets, traders, holdings and flows in plain English, with cost and remaining balance shown on every answer. The tools are read-only research tools, which keeps analysis well away from signing authority. Paste the StalkChain MCP link into your client and run one question you can check by hand at StalkChain.