Giving an AI agent a new capability used to mean writing a custom tool-calling layer, handling auth inside your codebase, and babysitting the integration every time the upstream SDK shipped a breaking change. The Model Context Protocol (MCP) replaces that entire loop with a single mcp add command. Point a client at a server URL, complete one OAuth hop, and every tool the server exposes becomes a tool your agent can call. In practice, EmblemAI runs a hosted MCP server at https://emblemvault.ai/api/mcp that exposes 200+ crypto tools across 7 blockchains. This tutorial walks through installing it in Claude Code, the OAuth handshake underneath, the first real wallet operation, and how the same install works in every MCP-compliant client.
What is MCP and why does it matter for AI agents?
MCP is an open protocol from Anthropic, released in November 2024, that standardizes how AI agents discover and call external tools. Before MCP, every agent framework invented its own tool-calling glue — OpenAI function calling, LangChain tool wrappers, custom JSON schemas, framework-specific adapters. An integration written for one agent was not portable to another, and every wallet SDK, database driver, or API client had to be wrapped separately for each framework.
MCP solves this by treating tool exposure as a network protocol, not a code import. A server publishes its tools over HTTP or stdio using a standard schema (tools/list, tools/call, resources/list). A client — Claude Code, Cursor, Windsurf, Gemini CLI, any MCP-compliant agent — discovers the server, handles authentication, and forwards tool invocations on behalf of the agent. The agent never sees HTTP requests; it only sees a list of callable tools with JSON-schema inputs.
This shift is the same one that happened when databases went from "ship a driver" to "expose a network endpoint." Developers stopped caring about the client library and started caring about the contract. MCP does that for AI tool integrations.
Why does a crypto wallet belong on MCP?
A crypto wallet is the archetypal capability you want behind a network contract rather than inside your agent's codebase. There are two hard reasons:
- Chain fragmentation. Every chain has its own signing model, gas idioms, RPC endpoints, and SDK quirks. Gluing Solana, Ethereum, Base, BSC, Polygon, Hedera, and Bitcoin SDKs into one agent is a part-time job. A server-side abstraction hides those seven codebases behind one tool list.
- Key custody. Handing an agent raw private keys is an obvious non-starter for anyone with a real bag. An OAuth-scoped MCP server keeps the keys server-side and only exposes scoped, revocable capabilities to the agent. A read-only scope lets the agent roam your portfolio without risk; write scopes require explicit per-operation approval.
EmblemAI's MCP server implements both. One deterministic wallet identity spans all 7 supported chains. OAuth 2.0 with PKCE controls capability scope. Write operations route through the client's approval UI, so a human (or a policy engine) confirms every state-changing action before it hits a chain.
How do you install the EmblemAI MCP server in Claude Code?
You install it with one command. Claude Code handles the OAuth redirect, token storage, and server registration automatically. Prerequisites are minimal: Claude Code installed (npm i -g @anthropic-ai/claude-code or the IDE extension) and a browser for the one-time auth hop. No API key to paste and no .env file to edit.
claude mcp add --transport http emblem https://emblemvault.ai/api/mcp
Claude Code prints an OAuth authorization URL. Open it in any browser, approve the default vault:read scope, and the token flows back to Claude Code automatically via a loopback redirect. Verify the server is live:
claude mcp list
The emblem entry should appear with a connected status. From this point forward, every Claude Code session in this workspace has access to the EmblemAI tool surface.
What happens during the OAuth hop?
The authorization flow is standard OAuth 2.0 + PKCE public-client, which is why Claude Code's generic mcp add just works — no custom client registration required. The sequence is four steps:
1. Claude Code discovers the authorization server:
GET https://api.emblemvault.ai/.well-known/oauth-authorization-server
2. It generates a PKCE code_verifier and code_challenge, then redirects
the user to the authorize endpoint:
GET /oauth/authorize
?response_type=code
&code_challenge=<S256 hash>
&code_challenge_method=S256
&redirect_uri=http://127.0.0.1:<port>/callback
&scope=vault:read
3. The user approves in the browser. The server redirects back to the
loopback URI with an authorization code.
4. Claude Code exchanges the code for an access token:
POST /oauth/token
grant_type=authorization_code
code=<code>
code_verifier=<original verifier>
The returned token is bound to the vault:read scope. Write scopes (vault:trade, vault:transfer) are negotiated on demand with explicit user approval in the client UI. Because the entire flow is standards-compliant, the exact same install works in Claude Desktop, Cursor, Windsurf, Gemini CLI, GitHub Copilot in MCP client mode, or any other MCP-compliant client. A full OAuth internals walkthrough lives in a separate post — this one stays focused on the install path.
What does the tool surface look like once installed?
After mcp add completes, Claude Code exposes every EmblemAI tool as a native tool call. The categories match the agent wallet tool catalog: portfolio and balance queries, DEX swaps, cross-chain bridges, DeFi positions, NFT operations, conditional and limit orders, market intelligence feeds, memecoin discovery, and prediction-market tools. 200+ tools across 14 categories, organized so the agent can pick the right one from the query context without manual tool configuration.
A representative slice of the tool list:
| Tool name | What it does |
|---|---|
portfolio.summary |
Aggregate holdings across all 7 chains in one call |
balance.get |
Balance for a specific chain or token |
swap.execute |
Execute a DEX swap (Jupiter on Solana, routers on EVM) |
bridge.crosschain |
Bridge an asset between supported chains |
order.conditional |
Place a limit or stop order |
defi.positions |
List open DeFi positions and current yields |
market.trending |
Trending tokens (CoinGlass, Birdeye, DeFiLlama feeds) |
nft.list |
List NFTs held across all chains |
The agent does not need to know these are wallet tools. They are tools with names and JSON-schema inputs, identical in shape to a filesystem MCP server or a browser MCP server. That uniformity is the whole point of the protocol.
How do you run your first on-chain operation?
Ask Claude Code a natural-language question. The agent selects the right tool, Claude Code invokes it over MCP, and the result comes back as structured data the agent summarizes. A read-only query first:
"What tokens do I hold across all chains?"
Claude invokes portfolio.summary. You get aggregated holdings across Solana, Ethereum, Base, BSC, Polygon, Hedera, and Bitcoin in one response — not seven separate round trips. This is the first query worth trying because it proves the OAuth scope is live and the server is actually seeing your wallet.
Now try something with write intent:
"Swap 0.1 SOL to USDC on Jupiter."
EmblemAI's wallet requires explicit approval for every write action. Claude Code shows the full transaction preview: amount in, expected amount out, slippage tolerance, and the routing path. Confirm once, and the swap fires. No browser extension to install, no seed phrase to paste, no chain-specific client. The whole flow lives inside Claude Code's approval UI.
For agents that need to operate without a human in the loop, EmblemAI supports policy-scoped tokens with per-operation limits — a scoped vault:trade token can cap daily spend, restrict to specific tokens, or require multi-sig approval above a threshold. That is beyond the scope of this install tutorial but documented at emblemvault.dev.
How does this compose with the rest of the agent stack?
The install gives you one agent identity that composes cleanly with the rest of the EmblemAI stack:
- Deterministic wallets. One password produces one persistent wallet identity across all 7 chains. Different passwords produce different wallets, so you can issue each agent its own isolated identity by assigning a unique password.
-
x402 micropayments. The same wallet that signs swaps can pay for external x402-protected APIs in USDC per-call. An agent running a trading loop can spend $0.01 on a Birdeye query, execute a swap, and settle both through the same identity. The x402 discovery endpoint is live at
/.well-known/x402. - A2A interoperability. The MCP tool surface is additionally exposed via Google's Agent-to-Agent protocol, so one agent can call another agent's EmblemAI tools directly.
- 200+ tools. The tool surface covers 14 categories across trading, DeFi, market data, NFTs, bridges, memecoins, predictions, and more.
In practice, combining the wallet SDK (article 1 in this series), x402 micropayments (article 2), and MCP tool exposure (this article) gives a complete agent commerce primitive: the agent has an identity, can pay for external data, and can execute on-chain actions, all through a single wallet.
Which MCP clients does it work with?
Every MCP-compliant client. The server is built against the public MCP specification and the standard OAuth 2.0 + PKCE public-client flow, so there is no client-specific logic on the server side. Current clients confirmed working:
- Claude Code (this article's path)
- Claude Desktop
- Cursor
- Windsurf
- Gemini CLI
- GitHub Copilot in MCP client mode
- Any custom MCP client that speaks the spec
The mcp add invocation in each of these clients uses the same server URL: https://emblemvault.ai/api/mcp.
What are the current limitations?
Three worth naming before building production agents on this path. First, the default scope is vault:read; write scopes require browser approval today, which is a friction point for fully autonomous agents — policy-scoped tokens address this but are an advanced setup. Second, MCP registries are still maturing — the Official MCP Registry, Glama, and PulseMCP have varying discovery guarantees, and EmblemAI is in the process of submitting to each. Third, the MCP transport stack (HTTP vs. stdio vs. SSE) is still settling in the spec, so transport choices may evolve over the next year.
None of these are blockers for the install flow above. They are the edges to watch if you are shipping something on top of this.
Where does this go next?
EmblemAI is moving toward being the default wallet surface for MCP clients. The near-term roadmap:
- Transaction tool with opt-out (currently on a feature branch, pending merge).
- Submission to the Official MCP Registry at
registry.modelcontextprotocol.io, plus Glama, PulseMCP,mcp.so, and Anthropic's Claude Directory. - Deeper policy-scope documentation for headless agent setups.
The install path will not change. claude mcp add --transport http emblem https://emblemvault.ai/api/mcp is the contract.
Links
- EmblemAI welcome: emblemvault.ai/welcome
- Full docs: emblemvault.dev
- Agent Wallet SDK:
npm install -g @emblemvault/agentwallet - GitHub: EmblemCompany/EmblemAi-AgentWallet
- Agent Skills: EmblemCompany/Agent-skills
- MCP specification: modelcontextprotocol.io
Article 3 in the AI Agent Infrastructure series. Article 1 covered the EmblemAI agent wallet install. Article 2 covered x402 micropayments. The next article in the series goes deep on EmblemAI's OAuth implementation for MCP clients.
Top comments (0)