Introduction to Model Context Protocol (MCP)

Model Context Protocol (MCP) is an open standard (released by Anthropic in late 2024) that defines a universal method for AI models (especially LLMs) to connect with external data sources and tools. Think of MCP as the “USB-C of AI applications” – a standardized interface for context that allows AI assistants to securely access databases, files, APIs, and even blockchain networks without bespoke connectors. This protocol addresses a critical limitation of traditional AI systems: their isolation from real-time data and services. By following MCP, developers avoid the M×N integration problem (where each new model–tool pair needs custom code) and instead reduce complexity to M+N by conforming to one common interface.
At its core, MCP follows a client–server architecture. An MCP Client (embedded in a host AI application, e.g. a chat interface or IDE) can talk to one or more MCP Servers, each of which exposes a specific data source or capability (for example, a database, a web service, or a blockchain node). The communication uses a structured transport layer with a two-way handshake for security – the AI must explicitly request access and get permission before any action is taken. This ensures that integrations remain secure and auditable by design. In practice, when an AI agent needs external information or needs to perform an action, it sends a standardized request to the MCP server, which in turn fetches or executes the requested operation and returns results in a consistent format. Figure 1 illustrates this architecture at a high level, with host applications containing MCP clients that interface via the MCP transport layer to various MCP servers (each server “wraps” a tool or data source).

_Figure 1: Simplified MCP client–server architecture. The AI host (e.g. an assistant like Claude or ChatGPT, or an IDE) runs an MCP client that communicates over a secure transport to an MCP server. Each MCP server is a lightweight process exposing a specific tool, database, or service via the standardized protocol. This design decouples AI models from hard-coded integrations and allows context to flow from many sources in a uniform way.

Role Core Responsibility Typical Examples
Host Runs the user-facing app, starts and manages one or more MCP Clients inside a secure sandbox, shows the UI, and mediates between the LLM and Clients/Servers. Claude Desktop, Cursor, ChatGPT Desktop
Client A lightweight connector that lives inside the Host. Each Client sets up a dedicated 1-to-1 JSON-RPC channel to one Server, handles capability negotiation, request forwarding, and error handling. The internal “Claude Client” processes that Claude Desktop spins up—one per enabled Server.
Server Exposes real-world capabilities—tools, data sources, prompts, APIs, local files—through the MCP spec. Multiple Hosts (and thus multiple Clients) can connect to the same Server. A Dockerised retrieval Server; an “OS tools” Server exposing shell commands; a code-intelligence Server, etc.
Local Data Sources Your computer’s files, databases, and services that MCP servers can securely access Mac local files
Remote Services external systems available over the internet (e.g., through APIs) that MCP servers can connect to Google Services

Design Principles: MCP was inspired by the success of protocols like the Language Server Protocol (LSP) in software development. By standardizing the format of requests and responses (for tool invocation, data retrieval, etc.), MCP makes integrations plug-and-play – any MCP-compliant client can interface with any MCP server. This fosters an ecosystem of interchangeable “context providers.” Security and permissioning are built-in: because AI agents can potentially execute powerful operations via MCP, the protocol emphasizes explicit user consent and sandboxing of tools. Every tool invocation is logged and structured, simplifying auditing and trust. In essence, MCP elevates context integration to a first-class layer of the AI stack, much like HTTP did for web resources. The significance of MCP in digital architecture is that it decouples AI logic from data connectors – enabling more scalable, maintainable, and collaborative AI systems. As Anthropic’s introduction put it, instead of dozens of fragmented APIs and plugins, a single open protocol now acts as the bridge between AI models and the “world’s” data and services

Integrating all kinds of API is necessary and unavoidable for developers. Even in AI era before MCP emerging, developers still need to deal with these things. Now, MCP is the abstraction of API for clients, and future agents

For those has MCP narrative projects, we need to figure out which part they are building. Most of them are building servers to integrate into the existing ecosystem

  1. Host
  2. Client
  3. Server
┌─────────────┐
│  User / LLM │
└─────▲───────┘
      │ (1) tool call
┌─────┴───────┐
│  Claude Host│  ⇆  multiple Client instances (processes/threads)
└─────▲───────┘                     │
      │ (2) JSON-RPC                │ (3) dedicated 1-to-1 channels
┌─────┴──────────────┐   ┌──────────┴──────────────┐
│    MCP Server A    │   │     MCP Server B       │   …
│   (file system)    │   │   (terminal tools)     │
└────────────────────┘   └────────────────────────┘

Why does Claude Desktop sometimes get called a Client?

MCP’s communication mechanisms

General Application and Landscape of MCP in the Non-Crypto World

Outside of crypto, MCP is already reshaping how AI systems are deployed across cloud services, enterprise data environments, and consumer applications. The general landscape of MCP adoption includes use cases in AI model deployment, cloud-based contextual data frameworks, data pipeline orchestration, and a host of enterprise integration scenarios. In all these, MCP serves as the connective tissue that links AI models with the tools and information they need in real time.

AI and Cloud Integrations: Modern AI deployments often require hooking into cloud resources – from querying databases and data lakes to calling external APIs (for example, an AI assistant that integrates with a CRM or an email service). Traditionally, developers had to wire up each integration with custom code or use framework-specific plugins. Frameworks like LangChain or LlamaIndex have provided some abstraction, but they still involve one-off connectors for each new service. MCP offers a cloud-agnostic standard instead. For example, Anthropic’s Claude now supports connecting to “remote MCP servers” over the internet, meaning a Claude-based app can fetch data from a cloud service if that service has an MCP server interface. This is analogous to how any web browser can talk to any website via HTTP – here any AI agent can talk to any data source via MCP. OpenAI’s ChatGPT is also moving in this direction: a recent leak confirmed that ChatGPT is testing MCP support (with an “Add Connector” option in its interface), allowing it to connect to third-party apps like Gmail, internal databases, etc., and use them as context for answers. Microsoft has likewise indicated plans to incorporate MCP for its AI offerings, seeing it as a way to securely plug enterprise data into copilots (imagine Office 365 copilots retrieving company-specific data via MCP). The broad interest from cloud and AI providers signals that MCP is becoming an industry standard for AI tool interoperability.

Enterprise Applications and Data Pipelines: Many early MCP integrations have focused on enterprise data sources and developer tools. Anthropic released pre-built MCP servers for Google Drive, Slack, GitHub, Postgres, and more, aimed at giving businesses immediate ways to connect AI assistants with their content repositories and workflows. This means an AI assistant could, for instance, retrieve relevant documents from a company’s Google Drive during a conversation, or query an internal knowledge base – all through a secure, standardized protocol call. Companies like Block (formerly Square) and Apollo Global were early adopters testing MCP in secure data environments. In these scenarios, MCP acts as a context broker behind the scenes: rather than opening up direct database or API access to an AI (which could be risky and complex), organizations run MCP servers that carefully mediate what the AI can see and do. The result is simpler and safer integration of AI into enterprise software.

Developers of IDE and coding tools have also embraced MCP to enrich AI coding assistants. For example, IDEs like Replit and Zed, and tools like Sourcegraph’s Cody, have worked with MCP so that an AI coding assistant can pull in a project’s broader context (multiple files, git history, documentation) on demand. Sourcegraph noted that by using MCP, their AI (Cody) could retrieve relevant code from a repository to better understand a coding task. This dynamic retrieval improves the quality of code suggestions significantly. Likewise, Claude Desktop (Anthropic’s desktop AI app) now includes a built-in MCP client and even a GUI for browsing available MCP servers. Developers can run local MCP servers (e.g. one that indexes their filesystem or runs shell commands) and Claude can use them to answer questions about local code or automate tasks.

In data pipeline and orchestration contexts, MCP is enabling real-time insights. Confluent (the company behind Apache Kafka streaming) built an MCP server to feed streaming data to AI agents. This integration lets an AI query live event streams or even manage the data pipeline through natural language. For instance, a data engineer could ask an AI (via MCP) to “show last hour’s error rates in our payment transactions topic,” and the AI (through the Confluent MCP server) can fetch that from Kafka in real time. Confluent’s MCP server also allows natural-language management of the streaming platform – e.g. an AI can create new data topics or run stream processing jobs on request. These capabilities demonstrate MCP’s value in cloud and DevOps: bridging AI with operations tools that have traditionally required specialized knowledge. A similar example is the integration of MCP in the Theia IDE (an open-source code editor platform), where AI-driven code assistants can use MCP to interface with development tools and resources, enhancing features like autocompletion with live data from code repos and documentation.

Leading Frameworks and Best Practices: While MCP is new, it builds on lessons from earlier integration approaches. Best practices are emerging, such as hosting MCP servers within one’s own infrastructure for security (so the AI connects to a company-run endpoint, not directly to external APIs). Another practice is using MCP as a layer in AI agent orchestration: Projects are combining MCP with agent frameworks (like langchain agents or custom planners) so that the agent can discover available tools and invoke them systematically. In other words, MCP provides the “universal plug”, but you still need logic to decide when and how the AI uses a tool – that’s an active area of development.

It’s worth noting that security tooling is rising alongside MCP. Researchers (e.g., at Tenable) have examined how prompt injection attacks could target MCP tool interfaces, since an AI with access to tools could be misled into misuse. The silver lining is they also showed such techniques can be used defensively (to test and harden MCP servers against abuse). In response, companies are developing “firewall” layers for AI (Meta’s LlamaFirewall for instance) to filter or monitor tool-using agents. These trends indicate that MCP is becoming an integral part of AI systems, and the ecosystem (cloud providers, enterprises, security firms) is coalescing around making it robust. The fact that OpenAI, Anthropic, and others are aligning on MCP or similar protocols suggests that standardization of AI context exchange is inevitable and underway.

In summary, outside of crypto, MCP’s general applications include: improving AI assistants with up-to-date information (e.g. pulling in live data or private knowledge bases), enabling AI to perform actions (execute code, manipulate documents, configure services) in a controlled manner, and simplifying the integration of AI into existing software workflows. The landscape features big cloud players, enterprise software, and open-source communities all experimenting with MCP – from using it in cloud AI services (OpenAI’s forthcoming connectors), to embedding it in desktop apps and IDEs (Claude, Cursor, VS Code extensions), to leveraging it in data engineering and analytics. This sets the stage for applying MCP in the crypto world, where the need for AI to interface with decentralized systems is particularly acute.

MCP Clients

Client Resources Prompts Tools Discovery Sampling Roots Notes
5ire ❌ ❌ ✅ ❓ ❌ ❌ Supports tools.
AgentAI ❌ ❌ ✅ ❓ ❌ ❌ Agent Library written in Rust with tools support
AgenticFlow ✅ ✅ ✅ ✅ ❌ ❌ Supports tools, prompts, and resources for no-code AI agents and multi-agent workflows.
Amazon Q CLI ❌ ✅ ✅ ❓ ❌ ❌ Supports prompts and tools.
Apify MCP Tester ❌ ❌ ✅ ✅ ❌ ❌ Supports remote MCP servers and tool discovery.
BeeAI Framework ❌ ❌ ✅ ❌ ❌ ❌ Supports tools in agentic workflows.
BoltAI ❌ ❌ ✅ ❓ ❌ ❌ Supports tools.
Claude.ai ✅ ✅ ✅ ❌ ❌ ❌ Supports tools, prompts, and resources for remote MCP servers.
Claude Code ❌ ✅ ✅ ❌ ❌ ❌ Supports prompts and tools
Claude Desktop App ✅ ✅ ✅ ❌ ❌ ❌ Supports tools, prompts, and resources for local and remote MCP servers.
Cline ✅ ❌ ✅ ✅ ❌ ❌ Supports tools and resources.
Continue ✅ ✅ ✅ ❓ ❌ ❌ Supports tools, prompts, and resources.
Copilot-MCP ✅ ❌ ✅ ❓ ❌ ❌ Supports tools and resources.
Cursor ❌ ❌ ✅ ❌ ❌ ❌ Supports tools.
Daydreams Agents ✅ ✅ ✅ ❌ ❌ ❌ Support for drop in Servers to Daydreams agents
Emacs Mcp ❌ ❌ ✅ ❌ ❌ ❌ Supports tools in Emacs.
fast-agent ✅ ✅ ✅ ✅ ✅ ✅ Full multimodal MCP support, with end-to-end tests
FLUJO ❌ ❌ ✅ ❓ ❌ ❌ Support for resources, Prompts and Roots are coming soon
Genkit ⚠️ ✅ ✅ ❓ ❌ ❌ Supports resource list and lookup through tools.
Glama ✅ ✅ ✅ ❓ ❌ ❌ Supports tools.
GenAIScript ❌ ❌ ✅ ❓ ❌ ❌ Supports tools.
Goose ❌ ❌ ✅ ❓ ❌ ❌ Supports tools.
gptme ❌ ❌ ✅ ❓ ❌ ❌ Supports tools.
HyperAgent ❌ ❌ ✅ ❓ ❌ ❌ Supports tools.
Klavis AI Slack/Discord/Web ✅ ❌ ✅ ❓ ❌ ❌ Supports tools and resources.
LibreChat ❌ ❌ ✅ ❓ ❌ ❌ Supports tools for Agents
Lutra ✅ ✅ ✅ ❓ ❌ ❌ Supports any MCP server for reusable playbook creation.
mcp-agent ❌ ❌ ✅ ❓ ⚠️ ❌ Supports tools, server connection management, and agent workflows.
mcp-use ✅ ✅ ✅ ❓ ❌ ❌ Support tools, resources, stdio & http connection, local llms-agents.
MCPHub ✅ ✅ ✅ ❓ ❌ ❌ Supports tools, resources, and prompts in Neovim
MCPOmni-Connect ✅ ✅ ✅ ❓ ✅ ❌ Supports tools with agentic mode, ReAct, and orchestrator capabilities.
Microsoft Copilot Studio ❌ ❌ ✅ ❓ ❌ ❌ Supports tools
MindPal ❌ ❌ ✅ ❓ ❌ ❌ Supports tools for no-code AI agents and multi-agent workflows.
Msty Studio ❌ ❌ ✅ ❓ ❌ ❌ Supports tools
NVIDIA Agent Intelligence toolkit ❌ ❌ ✅ ❓ ❌ ❌ Supports tools in agentic workflows.
OpenSumi ❌ ❌ ✅ ❓ ❌ ❌ Supports tools in OpenSumi
oterm ❌ ✅ ✅ ❓ ✅ ❌ Supports tools, prompts and sampling for Ollama.
Postman ✅ ✅ ✅ ❓ ❌ ❌ Supports tools, resources, prompts, and sampling
Roo Code ✅ ❌ ✅ ❓ ❌ ❌ Supports tools and resources.
Slack MCP Client ❌ ❌ ✅ ❓ ❌ ❌ Supports tools and multiple servers.
Sourcegraph Cody ✅ ❌ ❌ ❓ ❌ ❌ Supports resources through OpenCTX
SpinAI ❌ ❌ ✅ ❓ ❌ ❌ Supports tools for Typescript AI Agents
Superinterface ❌ ❌ ✅ ❓ ❌ ❌ Supports tools
Superjoin ❌ ❌ ✅ ❓ ❌ ❌ Supports tools and multiple servers.
TheiaAI/TheiaIDE ❌ ❌ ✅ ❓ ❌ ❌ Supports tools for Agents in Theia AI and the AI-powered Theia IDE
Tome ❌ ❌ ✅ ❓ ❌ ❌ Supports tools, manages MCP servers.
TypingMind App ❌ ❌ ✅ ❓ ❌ ❌ Supports tools at app-level (appear as plugins) or when assigned to Agents
VS Code GitHub Copilot ❌ ❌ ✅ ✅ ❌ ✅ Supports dynamic tool/roots discovery, secure secret configuration, and explicit tool prompting
WhatsMPC ❌ ❌ ✅ ❌ ❌ ❌ Supports tools for Remote MCP Servers in WhatsApp
Windsurf Editor ❌ ❌ ✅ ✅ ❌ ❌ Supports tools with AI Flow for collaborative development.
Witsy ❌ ❌ ✅ ❓ ❌ ❌ Supports tools in Witsy.
Zed ❌ ✅ ❌ ❌ ❌ ❌ Prompts appear as slash commands

MCP Servers

Classifications

  1. Tools, Resources, Prompts are the formal MCP primitives; Claude’s UI simply mirrors them.
  2. Logs exist solely for developer ergonomics; they are not part of the protocol.
  3. Other primitives (Sampling, Roots) stay hidden until you need them, keeping the interface clean without sacrificing security controls.
Claude tab What you see Under-the-hood MCP object Where it comes from
Tools A catalogue of buttons or JSON forms that let the model “do things” tools/list ➜ individual tool schemas The server publishes them; the Client retrieves and renders them (modelcontextprotocol.io, modelcontextprotocol.io)
Resources Read-only files, documents, vector chunks etc. resources/list + resources/get Data-centric servers (RAG, filesystem, cloud drive) expose them (modelcontextprotocol.io, github.com)
Prompts Named, parameterised prompt templates prompts/list + prompt schema Servers share best-practice workflows this way (modelcontextprotocol.io, medium.com)
Logs A live tail of each server’s STDOUT/STDERR Not an MCP primitive; just the Host piping output to the UI Helps users debug connection or runtime errors (github.com, modelcontextprotocol.io)
Combinations
Claude Tab Combination Likely Server Role Typical Examples
Tools Action-oriented servers that call external systems (DevOps, SaaS, productivity apps) GitHub, Slack
Resources Data / Retrieval providers that supply static or dynamic context (RAG, file or cloud-drive readers) Vector DB, Google Drive reader
Tools + Resources Read–write systems where the LLM can both inspect data and modify it (file systems, databases) Local Filesystem server, Postgres server
Prompts Prompt-library or workflow assistants that expose reusable prompt templates Prompt-Library server
Tools + Prompts Action servers wrapped with built-in safety or workflow prompts (“guard-railed” execution) Shell server with a safety prefix prompt
Logs (only) Debugging / monitoring toolkits that don’t expose LLM-facing capabilities Logger MCP server
Builders
For server builders, they are typically focusing on
  1. Resources: File-like data that can be read by clients (like API responses or file contents)
  2. Tools: Functions that can be called by the LLM (with user approval)
  3. Prompts: Pre-written templates that help users accomplish specific tasks
    Currently, there are mainly four forces are contributing to the MCP ecosystem

The emerging MCP killed some of the vertical fields

Anthropic

Everything

Filesystem 🌟

Git 🌟

Sequential Thinking 🌟

- provides a tool for dynamic and reflective problem-solving through a structured thinking process.
 - Breaking down complex problems into steps
- Planning and design with room for revision
- Analysis that might need course correction
- Problems where the full scope might not be clear initially
- Tasks that need to maintain context over multiple steps
- Situations where irrelevant information needs to be filtered out

Memory 🌟

Fetch 🌟

Time

Official Integrations

Official integrations are maintained by companies building production ready MCP servers for their platforms.
Link: GitHub - modelcontextprotocol/servers: Model Context Protocol Servers

Tavily 🌟

The Tavily MCP server provides:

Paypal

PayPal provides two ways for merchants to set up the MCP server:

Stripe

Stripe’s official Model Context Protocol server—a plug-and-play service that lets any MCP-compatible host (Claude Desktop, Cursor, VS Code, etc.) call Stripe APIs and search Stripe’s knowledge base through standardised Tools, Resources, and Prompts. By exposing payments, customers, refunds and more as JSON-schema tools, Stripe MCP turns large-language-model “agents” into first-class Stripe integrations without requiring developers to ship secret keys or boiler-plate SDK code

MCP.so

MCP.so is a community-run hub dedicated to the Model Context Protocol (MCP) ecosystem.
Think of it as an “App Store” for MCP servers: the site catalogues hundreds of open-source servers, lets anyone publish new ones, and provides lightweight hosting so developers and power-users can plug those servers straight into Claude Desktop, Cursor, VS Code, Copilot Studio, or any other MCP-compatible host.

Aliyun Bailian

Dimension Aliyun Bailian MCP.so
Operator Alibaba Cloud first-party Independent community
Primary audience Mainland-China enterprises & Tongyi ecosystem devs Global open-source developers
Hosting model One-click deployment to Function Compute (serverless, per-request billing) Beta container hosting; otherwise self-host or local
Transport layers SSE (with affinity), stdio, Streamable HTTP preview Any transport accepted by the listed server; no infra opinion

Comparison with A2A

Google’s Agent-to-Agent (A2A) protocol, is focused on direct agent-to-agent communication, allowing autonomous agents to talk, collaborate, and coordinate tasks with each other. MCP, in contrast, provides a model-to-tool interface, standardizing how large language model (LLM) agents connect to external data sources and tools

iPhone is the agents, A2A like the Airdrop, MCP like Type-C Standard

Landscape of MCP Crypto Projects

MCP reduces development time and complexity when building AI applications that need to access various data sources. With MCP, developers can focus on building great AI experiences rather than repeatedly creating custom connectors.

But the MCP narrative is not targeted to general users, so not so hype so far, when some SuperApp emerging then people may realize the MCP behind it.

While Model Context Protocol (MCP) will not, by itself, ignite the next “Crypto-AI” hype cycle, it is rapidly becoming a table-stakes capability for any serious AI-enabled Web3 project. In other words, MCP is less of a price catalyst and more of a quality filter

  1. In general, MCP server serves as the middleware between normal Host/Clients and on-chain transactions. Fetching data from blockchain doesn't involve the private key and other privacy/security issues, but need additional security assumption if operates transaction on chain.
  2. Without similar standard like MCP, it is hard for agents in crypto to connect to the real world, and will be restricted in trading.
  3. For those ecosystem projects, most of them are meme first, then utility.

Official Chain Server Support

Base MCP

Base Chain + Coinbase MCP server

Base MCP serves as a middleware layer that translates natural language requests from AI assistants into blockchain operations and returns the results in a format the AI can understand. It implements the Model Context Protocol standard, enabling seamless communication between AI models and external blockchain services.

The system provides tools for:

Each key serves as one service provider, and wallet seed phrase is stored locally in clients

{
  "mcpServers": {
    "base-mcp": {
      "command": "npx",
      "args": ["-y", "base-mcp@latest"],
      "env": {
        "COINBASE_API_KEY_NAME": "your_api_key_name",
        "COINBASE_API_PRIVATE_KEY": "your_private_key",
        "SEED_PHRASE": "your seed phrase here",
        "COINBASE_PROJECT_ID": "your_project_id",
        "ALCHEMY_API_KEY": "your_alchemy_api_key",
        "PINATA_JWT": "your_pinata_jwt",
        "OPENROUTER_API_KEY": "your_openrouter_api_key",
        "CHAIN_ID": "optional_for_base_sepolia_testnet"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

The AgentKit core is designed to be framework-agnostic, with dedicated extension packages for popular AI frameworks

Feature Smart Wallet
(Frontend)		 MPC Wallet API
(Backend)
Primary Use End-user wallets for connecting to applications Developer-controlled wallets for programmatic blockchain interactions
Control End-user controlled and managed Developer controlled and managed
Security Secured by user's passkey (biometric) Secured via single key (1-of-1) or Multi-Party Computation (2-of-2)
Key Features • Sponsored gas for users using Paymaster
• Spend using Coinbase App balance through Magic Spend
• Use across the onchain ecosystem
• Free USDC sends on Base		 • 2-of-2 wallet private keys secured via Multi-Party Computation
• Fully programmable and customizable
• CDP SDK support for Transfers, Trades, Staking, and Arbitrary Message Signing & Smart Contract Invocations
• Free USDC sends on Base
Example Use Cases • User authentication for applications
• Cross-app interactions
• Collecting NFTs and tokens		 • AI agent wallets
• Wallets for your company or your users
• Programmatic asset management (e.g. rewards distribution, one-to-many payouts)
Supported Networks Base, Arbitrum, Optimism, Zora, Polygon, BNB, Avalanche, Ethereum Ethereum, Base, Polygon, and Arbitrum with more coming soon

The Model Context Protocol is a natural complement to AgentKit. AgentKit itself has full capacity, But Base MCP server repo itself didn't update since 2 months ago, and no integration of MPC wallet provider. The future extending MPC rely on the community contributors, following the guideline

  1. Create a new directory in the src/tools directory for tool
  2. Implement the tool following the existing patterns:
    • index.ts: Define and export tools. Tools are defined as AgentKit ActionProviders.
    • schemas.ts: Define input schemas for your tools
    • types.ts: Define types required for your tools
    • utils.ts: Utilities for your tools
  3. Add tool to the list of available tools in src/main.ts
  4. Add documentation for tool in the README.md
  5. Add examples of how to use tool in examples.md
  6. Write tests for tool

Solana MCP by Send AI

Solana Foundation didn't dig into MCP by themselves, but rely on Send AI team again to build the Solana MCP server, just like Solana agent kit before.

Solana Foundation official repo only demonstrates a simple implementation of a Model Context Protocol (MCP) server for Solana development.

{
  "mcpServers": {
    "solana-dev": {
      "command": "ts-node",
      "args": ["<full-path-to-repo>/index.ts"]
    }
  }
}

Send AI repo implementation is based on the Solana Agent Kit and enables AI agents to perform blockchain operations seamlessly.

{
  "mcpServers": {
    "solana-mcp": {
      "command": "npx",
      "args": ["solana-mcp"],
      "env": {
        "RPC_URL": "your_solana_rpc_url_here",
        "SOLANA_PRIVATE_KEY": "your_private_key_here",
        "OPENAI_API_KEY": "your_openai_api_key"  // OPTIONAL
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Specialized MCP server serves as a bridge between AI agents (Claude AI + Open AI Response) and the Solana blockchain ecosystem. It leverages the Solana Agent Kit framework to provide a standardized interface for blockchain operations through the Model Context Protocol specification.
Compared with Base MCP, only on-chain activity, not involved with exchange and web3 wallet capacity, just look at the configuration.

Solana Agent Kit v2 Hightlights

Embedded wallets enhance security by removing the need to handle private keys directly in application code. They typically offer user-friendly authentication methods (email, social logins, etc.) and provide "human-in-the-loop" confirmation for transactions, which is especially important for AI-driven applications.

Although Send AI is Indian team, and price pump and dump, but they are building the right direction and shipping right product.

BNB MCP

BNB chain is slightly different. Original MCP server is build by ecosystem project first, TermiX and mcp.direct. Then BNB chain building their own repo.

TermiX Server

{
    "mcpServers": {
        "bsc-mcp": {
            "command": "node",
            "args": [
                "/Users/Username/Desktop/bsc-mpc/build/index.js"
            ],
            "env": {
                "BSC_WALLET_PRIVATE_KEY": "BSC_WALLET_PRIVATE_KEY",
                "BSC_RPC_URL": "BSC_RPC_URL"
            },
            "disabled": false,
            "autoApprove": []
        }
    }
}

mcp.direct EVM Server

{
  "mcpServers": {
    "evm-mcp-server": {
      "command": "npx",
      "args": [
        "-y",
        "@mcpdotdirect/evm-mcp-server"
      ]
    }
  }
}

BNB Chain

{
  "mcpServers": {
    "bnbchain-mcp": {
      "command": "npx",
      "args": ["-y", "@bnb-chain/mcp@latest"],
      "env": {
        "PRIVATE_KEY": "your_private_key_here. (optional)"
      }
    }
  }
}

Near MCP

{
  "mcpServers": {
    "near-mcp": {
      "command": "npx",
      "args": ["-y", "@nearai/near-mcp@latest", "run"],
      "env": {}
    }
  }
}

Starknet MCP by mcp.direct

General server provides AI agents with the ability to interact with Starknet networks, query blockchain data, manage wallets, and interact with smart contracts.

{
  "mcpServers": {
    "starknet-mcp-server": {
      "command": "npx",
      "args": [
        "@mcpdotdirect/starknet-mcp-server"
      ]
    }
  }
}

Base

Bork

Mozaiq

Lyra

MOEW

Solana Eco

Dark

DeepCore

DeMCP

SWARMS

Swarms release 0417

BNB

MyShell

ShellAgent widget delivers centralized access to a premier suite of MCP capabilities, including:


General upgrade on MCP feature for MyShell

Skyai

CA

REVOX

Termix

Janitor

Positioning: MCP-Driven Chain Consciousness, but MCP and A2A is at the last step of roadmap.

1. Signals come in from three places.
Janitor AI listens to on-chain events (wallet transfers, contract calls, liquidity changes), social chatter (Twitter/X, Discord, Telegram), and token-specific events (listings, burns, vesting unlocks). These streams form the raw input the system will reason about
2. Perception, Memory, and Feedback—the “cognitive core.”
Incoming data first hits a perception layer that cleans, tags, and unifies the different formats so they’re comparable. Relevant features are written into a long-term memory layer that stores historical sentiment, anomaly baselines, and token life-cycle state. External feedback—either user corrections or real-world market outcomes—loops in here too, so the system can learn from its hits and misses.
3. AI Reasoning Engine turns data into insight.
Using the normalized inputs plus memory context, the engine runs four core analyses:

MCP related: in later stage, integrate MCP/A2A

Others

Awesome Crypto MCP

Appendix

  1. Anthropic, “Introducing the Model Context Protocol,” Nov. 2024 – Open-source release announcement of MCP.
  2. Model Context Protocol Official Docs – Introduction and Architecture.
  3. TRIVE VC (D. Lim), “MCP: Bridging AI and Blockchain for Smarter Crypto Projects,” Mar. 2025 – Overview of MCP’s implications for Web3.
  4. Medium (TRIVE), “Real-World Examples of MCP in Blockchain,” 2025 – Examples including Block, Solana, EVM multi-chain connector.
  5. DigitalOcean (M. Maheswaran), “MCP 101 – An Introduction,” Mar. 2025 – Explains MCP vs LSP analogy and standardization benefits.
  6. Confluent (E. Vaisman et al.), “Powering AI Agents with Real-Time Data Using MCP,” Mar. 2025 – Use of MCP to connect AI with Apache Kafka streams.
  7. BleepingComputer (M. Parmar), “Leak confirms OpenAI’s ChatGPT will integrate MCP,” May 2025 – MCP support in ChatGPT for third-party connectors.
  8. Hacker News (Tenable report via TheHackerNews), “MCP prompt injection – Attack and Defense,” Apr. 2025 – Security considerations of MCP and its architecture.
  9. CoinEx Academy, “What Is MCP: AI Integration in Crypto Projects,” May 2025 – (Reference on MCP concept in crypto, discussed narrative).
  10. Coinbase Developers, “Model Context Protocol (MCP) AgentKit Extension,” 2024 – Coinbase documentation for MCP in AgentKit.
  11. Awesome-MCP (GitHub list by @badkk), “Awesome Crypto MCP Servers,” updated 2025 – Curated list of MCP servers for crypto (Bankless, Dappier, DexPaprika, Heurist, EVM, GOAT, Solana, etc.).
  12. ArcBlock Blog, “ArcBlock Integrates MCP,” 2025 – (ArcBlock plans to make MCP default in Blocklets; content via search snippets).
  13. The Big Whale, “What is ArcBlock?” Feb. 2023 – Overview of ABT token usage in ArcBlock (services payment, governance).
  14. CoinBureau, “ArcBlock Review,” Mar. 2023 – Background on ArcBlock’s platform architecture and goals.
  15. Fetch.ai Whitepaper & Tech Docs, 2019–2022 – Describes agent-based architecture, CoLearn, and search/discovery (background for integrating MCP).
  16. Bankless DAO, “Onchain MCP Server (GitHub),” 2024 – On-chain data query tool via MCP.
  17. Magnet Labs, “Solana Agent Kit MCP Server,” 2024 – Solana blockchain MCP integration allowing 40+ protocol actions.
  18. Binance BNB Chain Blog, “Leveraging MCP for AI on BNB Chain,” May 2025 – Announcement of BNB’s MCP server for BSC/opBNB and hackathon (MCP context in DeFi example).
  19. U.Today Press Release, “DeMCP – Decentralized MCP network,” Apr. 2025 – Introduction of DeMCP using TEE and blockchain for trust.
  20. Heurist Network GitHub, “Heurist Mesh MCP Server,” 2025 – Specialized MCP server for blockchain analytics and security (as referenced in Medium).
  21. TRIVE Medium, “Future Use Cases: MCP in Next-Gen Blockchain Applications,” 2025 – Speculative use cases (AI DeFi trading, AI auditing, AI DAO assistants).