AI agents are increasingly asked to make decisions based on what a wallet holds on-chain. Does this user qualify for a discount? Does this wallet meet a compliance threshold? Is this counterparty trustworthy? The problem is that agents cannot run RPC nodes or parse contract ABIs. MCP servers solve this by giving agents typed, discoverable tools they can call directly.

The problem: agents need on-chain data but cannot get it

An AI agent operating in a commerce workflow needs to know whether a wallet holds enough of a token to qualify for a discount tier. To answer that question directly, the agent would need to connect to an RPC endpoint, know the token contract address, understand the ERC-20 ABI, call balanceOf, parse the result, and handle chain-specific quirks across dozens of networks.

No agent framework is built for that. LLMs work with text and structured tool calls, not raw blockchain RPC. The agent needs someone else to do the on-chain work and return a clean, typed result.

This is where MCP comes in.

What is MCP?

The Model Context Protocol (MCP) is an open standard created by Anthropic for connecting AI models to external tools and data sources. Think of it as a universal adapter between an AI agent and the outside world.

An MCP server exposes a set of tools, each with a name, a description, and a typed input schema. When an agent connects to the server, it discovers these tools automatically. The agent reads the descriptions, understands what each tool does, and calls the right one when a task requires it. No hardcoded HTTP calls. No JSON parsing. The model treats MCP tools the same way it treats its own built-in capabilities.

MCP is supported natively by Claude Desktop, Cursor, Windsurf, and a growing number of agent frameworks. Any agent that speaks MCP can pick up new tools just by connecting to a new server. For how MCP fits into emerging on-chain attestation patterns, see our overview of the concept.

What mcp-server-insumer does

The mcp-server-insumer package is an MCP server that exposes InsumerAPI's on-chain verification, wallet trust profiling, and merchant discovery as typed tools. It turns the entire InsumerAPI surface into something any MCP-compatible agent can call without writing a single line of HTTP code.

The server exposes 26 tools. Here are the ones most relevant to on-chain verification:

Additional tools cover merchant onboarding, API key management, credit purchases, compliance templates, batch trust profiles, and discount code generation. The full list maps one-to-one to the OpenAPI spec.

Installation

Run the server with a single command. No cloning, no building:

npx -y mcp-server-insumer

The server reads your API key from the INSUMER_API_KEY environment variable. To connect it to Claude Desktop, add this to your Claude Desktop configuration file:

{
  "mcpServers": {
    "insumer": {
      "command": "npx",
      "args": ["-y", "mcp-server-insumer"],
      "env": {
        "INSUMER_API_KEY": "insr_live_your_key_here"
      }
    }
  }
}

After saving the config and restarting Claude Desktop, the 26 tools appear in the model's tool list. Ask Claude to "verify whether wallet 0x... holds at least 1000 UNI on Ethereum" and it will call insumer_attest automatically.

How an agent uses it

Here is the flow when an agent receives a task that requires on-chain data:

  1. Task arrives. "Check if this wallet qualifies for a discount at MerchantX."
  2. Tool discovery. The agent sees insumer_merchant_detail in its tool list, reads the description, and calls it with the merchant ID to learn the token conditions and discount tiers.
  3. Verification. The agent calls insumer_attest with the wallet address and the conditions from the merchant. The tool returns a signed result: met or not met, with the discount tier if applicable.
  4. Decision. The agent uses the result to proceed. If the wallet qualifies, it generates a discount code or presents the offer. If not, it explains why.

At no point did the agent parse blockchain data, manage RPC connections, or handle chain IDs. The MCP server abstracted all of that into a single typed tool call.

Using the MCP SDK in Python

If you are building a custom agent and want to connect to the MCP server programmatically (outside of Claude Desktop), you can use the MCP SDK. Here is an example that calls the attestation tool:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import asyncio

async def verify_wallet():
    server = StdioServerParameters(
        command="npx",
        args=["-y", "mcp-server-insumer"],
        env={"INSUMER_API_KEY": "insr_live_your_key_here"}
    )

    async with stdio_client(server) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            result = await session.call_tool(
                "insumer_attest",
                arguments={
                    "wallet": "0x1234...abcd",
                    "conditions": [
                        {
                            "type": "token_balance",
                            "chainId": 1,
                            "contractAddress": "0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4ce",
                            "threshold": 1000000,
                            "decimals": 18
                        }
                    ]
                }
            )
            print(result.content[0].text)

asyncio.run(verify_wallet())

The call_tool method sends the request to the MCP server, which calls InsumerAPI, and returns the signed attestation result. The agent never touches an RPC endpoint.

Where to find mcp-server-insumer

The package is listed on multiple MCP directories:

Alternative integration surfaces

MCP is one of several ways to connect agents to InsumerAPI. If your stack does not use MCP, two other agent-native integrations exist:

All three surfaces hit the same 26 API endpoints, return the same ECDSA-signed results, and work across the same 32 blockchains. The only difference is the transport: MCP tools for Claude and compatible agents, Python tools for LangChain, and OpenAPI Actions for GPTs.

For a complete walkthrough of every endpoint, integration pattern, and pricing tier, see the AI Agent Verification API guide. You can also try a live XRPL attestation to see signed boolean results returned in real time.

Why this matters

Agents need verifiable on-chain data, and they need it through interfaces they already understand. MCP gives agents typed tools with built-in discovery. The agent does not need documentation. It reads the tool description, understands the input schema, and calls it when the task requires on-chain verification.

For developers building agent workflows that involve token gating, compliance checks, wallet auth for AI agents, or merchant discovery, mcp-server-insumer is the fastest path from "my agent needs blockchain data" to "my agent verifies on-chain holdings." One npx command, one environment variable, 26 tools, 33 chains.

Add blockchain verification to your agent

InsumerAPI is free to start. 10 verification credits, 33 chains, 25 MCP tools. Run npx -y mcp-server-insumer and your agent can verify on-chain holdings in minutes.

View Developer Portal