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.

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?

• Dual nature leads to sloppy wording
  Officially Claude Desktop is a Host. But it bundles several MCP Client implementations to reach different Servers. When people say “Claude’s MCP client”, they often mean those internal Client processes, not the whole app.
• Early blog posts used inconsistent terms
  Before the March 2025 MCP spec clarified the Host/Client/Server split, many tutorials just said “MCP client” for any software on the user’s machine—including entire hosts like Claude Desktop—so the label stuck in places.
• Perspective matters
  Server authors care only about “who’s connecting to me”, so they lump Host + Client together and call the other side “the client”. End-users open Claude Desktop’s settings and see “Enable X client”, reinforcing that mental model.

MCP’s communication mechanisms

• The transport layer is responsible for converting MCP protocol messages into JSON-RPC format for transmission and converting received JSON-RPC messages back into MCP protocol messages.
• Standard Input/Output (stdio): enables communication through standard input and output streams. This is particularly useful for local integrations and command-line tools.
• Server-Sent Events (SSE): enables server-to-client streaming with HTTP POST requests for client-to-server communication.

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

• Features
  • Resources: allow servers to expose data and content that can be read by clients and used as context for LLM interactions
  • Prompts: define reusable prompt templates and workflows that clients can easily surface to users and LLMs, provide a powerful way to standardize and share common LLM interactions
  • Tools: enable servers to expose executable functionality to clients. Through tools, LLMs can interact with external systems, perform computations, and take actions in the real world.
  • Discovery: handshake that lets a Client understand which Tools, Resources, and Prompts a Server supports—no hard-coded contracts.
  • Sampling: allows servers to request LLM completions through the client, enabling sophisticated agentic behaviors while maintaining security and privacy.
  • Roots: URI-like scopes that delimit where a Server is allowed to operate
• Links: Example Clients - Model Context Protocol
• Recommendation: Raycast, Chatwise. Isolate the privacy data. Not windsurf for now

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.

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

• Developers at Anthropic who build servers for common tools and data sources
• Open source contributors who create servers for tools they use
• Enterprise development teams building servers for their internal systems
• Software providers making their applications AI-ready
  Standard is not complicated at all, but push it into mass adoption is the key for MCP to win

The emerging MCP killed some of the vertical fields

Anthropic

Everything

• exercise all the features of the MCP protocol, test server for builders of MCP clients. It implements prompts, tools, resources, sampling, and more to showcase MCP capabilities.

Filesystem 🌟

• Features
  • Read/write files
  • Create/list/delete directories
  • Move files/directories
  • Search files
  • Get file metadata

Git 🌟

• provides tools to read, search, and manipulate Git repositories via Large Language Models.

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 🌟

• persistent memory using a local knowledge graph. This lets Claude remember information about the user across chats.

Fetch 🌟

• provides web content fetching capabilities. This server enables LLMs to retrieve and process content from web pages, converting HTML to markdown for easier consumption.

Time

• provides time and timezone conversion capabilities. This server enables LLMs to get current time information and perform timezone conversions using IANA timezone names, with automatic system timezone detection.

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:

• search, extract, map, crawl tools
• Real-time web search capabilities through the tavily-search tool
• Intelligent data extraction from web pages via the tavily-extract tool
• Powerful web mapping tool that creates a structured map of website
• Web crawler that systematically explores websites

Paypal

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

• Running the MCP server locally. This option enables developers to download, install, and run the MCP server locally.
• Using the MCP server remotely. This option is for users who prefer not to install the MCP server locally. With remote MCP server support, users can continue their tasks across devices with a single login after authentication.

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

• A one-stop portal for foundation models, agent builders and, since March 2025, a fully managed MCP Marketplace
  • 100+ pre-built servers (Amap Maps, Hologres, GitHub, etc.) can be “opened” with one click; each entry shows price and quota

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

• Choose A2A when product must coordinate heterogeneous agents (possibly from different vendors) and you value open, vendor-neutral collaboration flows.
• Choose MCP when LLM needs broad, secure access to data & actions—and you want re-usability across AI platforms with minimal custom glue code.
• Use Both in layered systems: MCP to fetch context or execute atomic actions, A2A for the higher-order dialogue and delegation across agents.

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

• Foundation should be responsible for the building open-source MCP server to let contributors in

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:

• Wallet management (retrieving addresses, listing balances)
• Asset transfers (ETH, ERC20 tokens, NFTs)
• Smart contract interactions (deployments, function calls)
• DeFi operations (Morpho protocol interactions)
• Fiat onramps via Coinbase
• Farcaster username resolution
• OpenRouter credit purchasing

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

• MPC Wallet Implementation (Coinbase-based)
  • Development Environment
    • Developer-Managed (1-of-1) Wallets
      • Optimized for rapid testing and prototyping
  • Production Environment
    • Coinbase-Managed (2-of-2) Wallets
      • Dual-domain security architecture:
        • Private key shares split between two parties
      • Developer Infrastructure:
        • AWS-hosted Server-Signer
        • Required credentials:
          • CDP Secret API Key
          • AWS SSH Keypair
      • Coinbase Infrastructure:
        • Secure server-side key management
          
• Enhanced AI Agent Capabilities (CDP + OpenAI Integration)
  • Streamlined Development Process:
    • Eliminates AWS service management complexity
    • Simplified account funding through CDP
  • AI-Driven Automation:
    • Function-based execution model
    • Automated trigger system based on specified parameters
      
• Comparison with Smart Wallet

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

• Solana Mobile developers can easily integrate the Solana Agent Kit in both iOS and Android mobile apps.
• Integrate multiple wallet provider: Privy, Phantom, Crossmint, Para

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

• Secure token & native transfers via CLI or MCP
• Interact with smart contracts (ABI/function-based)
• PancakeSwap integration for swaps & liquidity
• Create meme tokens & deploy BEP-20 smart contracts
• Native Claude Desktop integration via MCP
• CLI-ready, MCP-compliant, developer-friendly
• Password-protected private keys, but still need private keys

{
    "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

• Reading blockchain state (balances, transactions, blocks, etc.)
• Interacting with smart contracts
• Transferring tokens (native, ERC20, ERC721, ERC1155)
• Querying token metadata and balances
• Chain-specific services across 30+ EVM networks
• ENS name resolution for all address parameters (use human-readable names like 'vitalik.eth' instead of addresses)

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

BNB Chain

• Blocks: Query and manage blockchain blocks
• Contracts: Interact with smart contracts
• Network: Network information and management
• NFT: NFT (ERC721/ERC1155) operations
• Tokens: Token (ERC20) operations
• Transactions: Transaction management
• Wallet: Wallet operations and management
• Common: Shared utilities and types
• Greenfield: Support file management operations on Greenfield network including, uploading, downloading, and managing files and buckets
• Future features (Greenfield, Swap, Bridge, etc.)

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

Near MCP

• Near MCP is built by the near.ai, separate team from Near Protocol
  1. Manage NEAR accounts on behalf of users
  2. Check account balances and status
  3. Sign and send transactions
  4. Create new accounts and manage access keys
  5. Inspect and execution smart contracts

{
  "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.

• Reading blockchain state (balances, transactions, blocks)
• Interacting with Cairo smart contracts
• Transferring tokens (ETH, STRK, and other ERC20 tokens)
• Working with NFTs and token metadata
• Resolving StarknetID domains (similar to ENS for Ethereum)
• Making both read and write operations with proper transaction handling

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

Base

Bork

• Pure Meme after Base MCP server launch, pump and dump quickly.
• Launch through Claude Desktop

Mozaiq

• Integrates MPC with X, allowing users to create, swap, send, and track tokens directly through posts without needing a separate wallet.
• Vader Research initially ranked Mozaiq in Tier 3 but downgraded it to Tier 4 by June 2, 2025, labeling it a scam. The main issue was a LinkedIn profile linked to a fake phone number purchased via Fragment, raising transparency concerns. Mozaiq has not directly addressed and denying scam allegations and urging a review of their work. The community is divided
• 10% of total supply is allocated to staking incentives.
• Keep an eye on it, because no more progress in product and price since TGE

Lyra

• By Opulous team, Pivot from Story, and many AI project has done in the past months, not only MCP related. Opulous has migrated from Algorand.
• New AI, New Token
  • Lyra is built on a groundbreaking AI stack including GAME SDK, Opus Genesis OS, and a few other secret modules we are developing at Opus Genesis AI.
  • Lyra is connected to real-time music industry news and follows dozens of top artists and music industry figures on X.
• Product Pipeline
  • Lyra Token ($LYRA): Used for participation, governance, and rewards within the ecosystem. It is central to the Lyra Music DAO, requiring staking for governance and revenue sharing.
  • Music Fungible Tokens (MFTs): Track rights holders and ensure transparent royalty distribution, revolutionizing how music royalties are managed.
  • Lyra AI Agent: A dynamic, engaging digital persona built on Virtuals Protocol, connecting with the music community, sharing insights, and inspiring collaboration.
  • AI Music Agents API: Facilitates seamless music registration, management, and distribution, integrated with the ecosystem's partners.
• MCP related: no publice repo, Lyra MCP by Opus Genesis, quite tricky
  • allowing people to upload, register assets, and monetize directly.

MOEW

• Official AI token by Bitget Wallet.
• Pure Meme turned into AI Agent, BASE chain native token, which is also bridged to Solana and TON network.
• Role in Bitget Wallet is like AI marketing account, cover both English and Chinese channel
• Other Functionality
  • Alpha Sharing: Advanced market analysis and trend identification on social media
  • Interactive Chatbot: Personalized entertainment enabling users to talk with MOEW
  • Meme maker: Creative content creation for community engagement. Users can generate MOEW memes by sending text prompts.
  • Web3 customer service agent: serves as a knowledgeable guide, assisting newcomers and veterans in navigating cryptocurrency transactions with ease and confidence
• MCP Related: claim the adoption of the following part, but hard to verify
  • Enhanced context awareness: Improves AI's understanding of context by allowing access to current data and specialized tools.
  • Standardized interaction: Establishes a common language for AI models and external tools, promoting interoperability.
  • Simplified development: Reduces the need for custom integrations, streamlining AI application development.
  • Lower computational load: Eliminates the need for embeddings and vector searches, leading to improved efficiency and lower costs.
  • Scalability: Allows easy connection of new tools and data sources without extensive code changes.
• Highly depending on the controllability of Bitget wallet, MCP, RAG, TEE is not important here.

Solana Eco

Dark

• MCP
  • Dark Forest MCP: Empowers an AI agent named SPUTNIK to explore unknown areas in a fog-of-war map and formulate planetary jump routes, as part of an on-chain strategy game.
  • Solana MCP: fork "sendaifun,", provides capabilities to interact with the Solana blockchain, the configuration is same as Send AI
• Vision 0: establish a network infrastructure where users can create, host, and profit from MCP services, creating a marketplace for AI agents. Examples of MCP capabilities include AI agents determining the highest USDC yield pool, investing $1000, and rebalancing automatically
• Vision 1: Build useful agents. The first product, "Scout," a realtime information agent for web3, is set to launch in June 2025, as per the official website.
• Price is going down, and first wave pretty hype, and too many KOLs yapped it's the best MCP projects at that time
• After pivoting, they delete CA on their profile, and barely talk about token and price

DeepCore

• Independent Developer
• A comprehensive platform for building, deploying, and managing intelligent agents specifically designed for Web3 applications, is built on the innovative MCP (Model-Context-Protocol) architecture, a design pattern that enables us to build highly flexible and powerful intelligent agent systems.
  1. Web3 Agent Store Layer
     • Analysis Agent - For data analytics and insights generation
     • Trade Agent - For executing trading strategies on various platforms
     • Media Agent - For content creation and media interaction
     • DeepResearch Agent - For in-depth research and knowledge discovery
     • Additional specialized agents - Extensible for various domain-specific tasks
  2. DeepCore Agent Protocol Layer
     1. Service Components
        • MCP Service - Implements the Model-Context-Protocol pattern
        • SSE (Server-Sent Events) - Provides real-time communication
        • CMD - Command interface for agent control
        • HTTP Service - RESTful API endpoints for integrations
        • OpenAPIs - Standardized API interfaces for external connectivity
        • SDKs - Software Development Kits for various programming languages
     2. Agent Orchestration
        • Planner Agent - Central coordinator that breaks down complex tasks
        • TaskAgents - Specialized agents that execute specific subtasks
        • Tools Integration - Various tool categories available to agents:
          • CodeAct - For code generation and execution
          • Browser - For web browsing and information retrieval
          • Initial Tools - Basic built-in tooling
          • Search - Search capabilities across various sources
          • Custom Tools - User-defined or domain-specific tools
     3. Client Integration
        • Tools Center - Central registry for tool discovery and management
        • Authorization - Security and permissions management
        • MCP Service for Client - Client-facing interfaces for various platforms (APP | WEB | Desktop)
  3. Chain Foundation Layer
     • Multi-chain Support - Integration with major blockchains (BASE, BTC, ETH, BNB, SOL, APT, SUI, etc.)
     • Social Media Integration - Connections to platforms like X and Telegram
     • DeFi Integration - Support for DEX and CEX interactions
     • Third-party Platform Support - Extensible integration with external platforms
       
• Separates concerns and provides clear interfaces between components. The system is built using FastAPI for the API layer, SQLAlchemy for database models, and Redis for memory management.
  
• The API layer serves as the entry point for all client interactions with DeepCore:
  
• Product Pipeline
  • DeepMatrix AI Agent Store: AI Agent application store for end-users
    
  • DeepCore MCP Store: enabling the publishing of Web3 data and AI Agents as services, Deploy successful AI Agents from DeepCore as monetizable MCP services
    
  • A2A(80% Complete): enables seamless interaction between agents built on different frameworks, supporting streamlined task management, multi-format messaging, and real-time streaming capabilities.
  • Developer Toolkit Suite: deploy successful AI Agents from DeepCore as monetizable MCP services
    
• Development is highly depending on single developer, but the progress is impressive so far, shortage is the marketing.

DeMCP

• More focuses on providing Agents with self-developed and open-source MCP services, offering MCP developers a deployment platform with commercial revenue sharing, and enabling one-stop access to mainstream large language models (LLMs).
• Supporting crypto payments (USDT, USDC), DeMCP allows global developers to participate easily.
• The Architecture is more straightforward than DeepCore
  
• MCP Development: latest report on 2025.04.25, MCP Deployment feature doesn't work
  • Submit PR to Swarms to provide MCP capabilities for DeFiLlama.
  • Optimize the prompt and limit token count for the DeFiLlama MCP. Code repository: https://github.com/demcp/defillama-mcp
  • Debug the browser-use MCP and make start.sh compatible with Mac, Windows, and Linux.
  • MCP development for Ankr Solana RPC is in progress.
  • DeBank MCP development is complete. Code repository:
  • DeBank MCP PR submitted to the official examples repo. PR:
• Tokenomics is public: team allocation is 5%(still hold), fair launch is 85%, ecosystem 10%(hard to track)
• Sponsor Nigeria hackathon in MCP track
• For this project, delivery is a big concern

SWARMS

Swarms release 0417

• Standardized Interface: Using MCP eliminates the need for custom integrations, allowing seamless incorporation of Swarms API into applications.
• Advanced AI Capabilities: Multi-agent systems can handle complex tasks that single agents might struggle with, enhancing application functionality.
• Support and Resources: The Swarms World platform provides additional documentation, resources, and community support for developers working with Swarms API and MCP.
  Swarms 7.8.0 introduces advanced integration capabilities for MCP servers, enabling seamless configuration within agent workflows. Key technical enhancements include:
• Single-Line MCP Integration: Configure MCP servers by specifying the server endpoint via the Agent.mcp_url parameter.
• Automated Tool Schema Conversion: Tools are dynamically fetched from the MCP server and transformed into the model's schema for compatibility.
• Automated Function Invocation: The run(task) method triggers automatic execution of the described function.
• Support for Multiple Function Calls: When multiple function calls are specified, the agent executes them concurrently, optimizing task throughput.
  Swarms actually did bidirectional integration, not only add MCP capability to Swarms, but also expose its agents capability as a MCP server

BNB

MyShell

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

• BNB Chain: Powering MCP Integration Across the BNB Ecosystem. -
• GitHub: Direct Repository Management & Workflow Integration. -
• OpenAI : Integration via ChatGPT, APIs & SDKs.
• Gemini: Connecting to Gemini & Google Cloud.
• Figma: Converting Figma Designs to Code.

General upgrade on MCP feature for MyShell

Skyai

• Meme first, then MCP utility
• Roadmap
  • May, 2025
    • Release Extended MCP
    • Launch Playground (MVP)
  • Q2, 2025
    • Support ETH and Base (BSC and Solana already supported)
    • Enable SKYAI data MCP Service
  • Q3, 2025
    • Release IDE plug-ins (Cursor, Cline)
    • Release official LLM client MCP server (Claude)
  • Q4, 2025
    • MCP Marketplace
    • More official tools and services
• Version 0.15 20250530, first Version 0.1.0 20250508
  • Important feature updates: Framework for AI to render interactive components.
  • Share feature: Users can now share conversations with others. Of course, users need to decide whether to enable the sharing function.
  • Optimized some UI, fixed some bugs
    
• BNB chain wallet bought it, and pick this as the leader? Still hold 0.22%

CA

• CAILA by Nubila Network
  • The AI-powered Financial Layer for Weather Data
  • Previously Weather DePin
• TGE via Meme, pick a good tick
• Features
  • Decentralized Sensor Network: Nubila’s Marco devices act as edge weather stations deployed across communities, capturing real-time environmental data including temperature, UV, humidity, wind, and air quality.
  • AI-Powered Reasoning: Caila processes user prompts—directly or via MCP—against live data to deliver scenario-specific recommendations. No assumptions. No static rules.
  • Open Agent API: External agents, mobile apps, and platforms can call Caila to retrieve personalized insights for use in Web2 or Web3 environments.
  • MCP Integration: Fully compatible with BNB Chain’s Modular Chain Protocol, Caila functions as a composable agent module in decentralized agent networks.
    

REVOX

• Previous ReadOn, LBank listing
• Product Pipeline is so complicated, Proposed a oMCP
  • Phase 1: Establishing the core framework for AI-blockchain interaction via MCP.
  • Phase 2: Expanding Web3 capabilities and releasing an SDK (v1.0) to simplify application development for developers.
  • Phase 3: Enhancing security and governance, using Trusted Execution Environments (TEE) for secure AI execution.
• Pivot and pivot again, stats and product is not so bad, but few of people around are actually use it.
  

Termix

• MVB project, not TGE yet, team from ZJU, invested by Yiming Wang
• TermiX is described as an "AI Web3 OS," a platform designed to automate and simplify interactions within decentralized finance (DeFi) and centralized finance (CeFi). Its mission is to lower the technical barriers of Web3, making it accessible to users regardless of their expertise. By leveraging artificial intelligence, particularly Large Language Models (LLMs), TermiX enables users to perform complex operations—such as asset inquiries, transfers, currency exchanges, cross-chain actions, and NFT minting
• Integrations with projects like Aster_DEX, plus a partnership with ButterNetwork for omnichain interoperability.
• MCP Server:
  • BSC TermiX has been integrated into official Claude MCP server repo!
  • the TermiX Server handles key management, signatures, and transaction execution, eliminating the need for browser extensions. This is highlighted on the website as a way to streamline wallet operations.
  • MCPHub is a platform for plug-and-play Web3 protocols. It allows users to build, publish, and reuse custom MCPs, which are standalone protocols for DeFi to CeFi operations. The website notes support for protocols like TRON MCP, TON MCP, BNBChain MCP, Solana MCP, and SUI MCP, ensuring a unified experience across chains.
    
• Team is solid and in the first wave to integrate AI into crypto on-chain operation.

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:

• Narrative mapping links social conversations with on-chain reality to surface emerging storylines.
• Anomaly detection flags suspicious wallet movements or sudden social bot-bursts.
• Token life-cycle tracking situates each asset in launch, growth, or maturity, guiding risk weightings.
• Opinion tracking scores sentiment momentum across influential accounts.
  Together these steps produce an enriched, structured situational picture.
  4. Persona Output Layer translates insight into actionable language.
  The raw reasoning is adapted for specific “personas” (e.g., risk manager, growth lead, trader). Each persona receives only the angles and recommended actions they care about—buy, hedge, broadcast news, or stay put. This is where the system becomes agentic rather than merely analytic
  5. Agent-as-a-Service delivers the actions.
  Those persona-specific outputs power a fleet of modular agents: embedded monitors inside individual projects, public briefing bots, or custom modules that third-party developers wire up via the Model Context Protocol (MCP). Delivery can be chat, webhook, dashboard widget—whatever endpoint the user chooses.
  6. Continuous feedback closes the loop.
  Every agent action and every new market datapoint flows back into the perception and memory layers, refining models over time. The cycle—observe, reason, react, learn—runs nonstop, keeping Janitor AI aligned with the fluid crypto narrative landscape.

MCP related: in later stage, integrate MCP/A2A

Others

• Rug Pull: Botzilla, MCP, SentiAI, ...

Awesome Crypto MCP

• Bankless Onchain- Query Onchain data, like ERC20 tokens, transaction history, smart contract state.
• magnetai/mcp-free-usdc-transfer - Send USDC on Base for free using Claude AI! Built with Coinbase CDP's MPC wallet tech.
• coin_api_mcp - Provides access to coinmarketcap cryptocurrency data.
• crypto-feargreed-mcp - Providing real-time and historical Crypto Fear & Greed Index data.
• cryptopanic-mcp-server - Providing latest cryptocurrency news to AI agents, powered by CryptoPanic.
• Dappier - Connect LLMs to real-time, rights-cleared, proprietary data from trusted sources. Access specialized models for Real-Time Web Search, News, Sports, Financial Data, Crypto, and premium publisher content. Explore data models at marketplace.dappier.com.
• DexPaprika - Access real-time data for over 5 million tokens across 20+ blockchain networks including Solana, Base, BSC, and Ethereum. Get token prices, liquidity pool information, historical data and DEX analytics. Full documentation for developers DexPaprika Docs
• whale-tracker-mcp - A mcp server for tracking cryptocurrency whale transactions.
• Heurist Mesh Agent - Access specialized web3 AI agents for blockchain analysis, smart contract security, token metrics, and blockchain interactions through the Heurist Mesh network.
• EVM MCP Server - Comprehensive blockchain services for 30+ EVM networks, supporting native tokens, ERC20, NFTs, smart contracts, transactions, and ENS resolution.
• GOAT - Run more than +200 onchain actions on any blockchain including Ethereum, Solana and Base.
• Solana Agent Kit - This MCP server enables LLMs to interact with the Solana blockchain with help of Solana Agent Kit by SendAI, allowing for 40+ protcool actions and growing
• More: GitHub - demcp/awesome-web3-mcp-servers: DeMCP is the first Decentralized MCP network, offering SSE proxies for MCP services and mainstream LLMs, tackling trust and security with TEE and blockchain.

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).