MCP Server

Tenzro Network runs a Model Context Protocol server at mcp.tenzro.network that exposes 146 tools across 26 categories covering wallets, identity, payments, AI models, agents, task marketplace, governance, cross-chain bridges, staking, tokens, contracts, NFTs, compliance, crypto primitives, TEE attestation, ZK proofs, and more. Any MCP-compatible client — Claude Desktop, Claude Code, Cursor, Windsurf, or a custom LLM — can connect and interact with the Tenzro Ledger through natural language.

What is MCP?

The Model Context Protocol (MCP) is an open standard for connecting LLMs to external tools and data sources. Tenzro's MCP server exposes every major subsystem — wallet creation, identity registration, payment challenges, inference routing, bridge transfers — as structured tool calls that any MCP-compatible assistant can invoke directly.

• Transport: Streamable HTTP (MCP 2025-03-26) at /mcp
• Implementation: rmcp crate, session-based with automatic reconnect
• Authentication: JWT bearer tokens for authenticated operations, anonymous read access for public data
• Endpoint: https://mcp.tenzro.network/mcp (live testnet)

Connect Claude Desktop

Add the Tenzro MCP server to your Claude Desktop config file at ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "tenzro": {
      "type": "http",
      "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.tenzro.network/mcp"]
    }
  }
}

Restart Claude Desktop. You should see tenzro listed under connected MCP servers, with all 146 tools available to Claude.

Connect Claude Code

# Add Tenzro MCP server via claude mcp add
claude mcp add tenzro https://mcp.tenzro.network/mcp

# Or locally during development
claude mcp add tenzro http://localhost:3001/mcp

Tools Overview

The 146 tools are organized into 26 categories. Each tool returns structured JSON that the LLM can parse and reason over. Below are the core categories with examples. For the full listing, connect to the MCP server and invoke tools/list.

Wallet & Ledger (4 tools)

// Call the get_balance tool
{
  "name": "get_balance",
  "arguments": {
    "address": "0xdfa52b634363dc604065ef5dbce468125ff6e704039f7896079811f93fc78910"
  }
}

// Response
{
  "address": "0xdfa52b634363dc604065ef5dbce468125ff6e704039f7896079811f93fc78910",
  "balance": "100000000000000000000",
  "balance_tnzo": "100.0",
  "asset": "TNZO"
}

Network & Blocks (3 tools)

Identity & Delegation (3 tools)

// Register a human identity
{
  "name": "register_identity",
  "arguments": {
    "identity_type": "human",
    "public_key": "0xed25519-public-key-hex",
    "display_name": "Alice",
    "kyc_tier": "Enhanced"
  }
}

// Register a machine identity with controller DID
{
  "name": "register_identity",
  "arguments": {
    "identity_type": "machine",
    "public_key": "0xed25519-public-key-hex",
    "controller_did": "did:tenzro:human:alice-uuid",
    "capabilities": ["inference", "trading"]
  }
}

// Set delegation scope for a machine
{
  "name": "set_delegation_scope",
  "arguments": {
    "did": "did:tenzro:machine:alice:bot-uuid",
    "max_transaction_value": "100000000000000000000",
    "max_daily_spend": "500000000000000000000",
    "allowed_operations": ["inference", "payment"],
    "allowed_payment_protocols": ["mpp", "x402"],
    "allowed_chains": ["tenzro", "ethereum"]
  }
}

Payments (3 tools)

// Create an MPP session-based challenge
{
  "name": "create_payment_challenge",
  "arguments": {
    "protocol": "mpp",
    "resource": "/api/inference/gemma3-270m",
    "amount": "1000",
    "asset": "USDC",
    "recipient": "0xrecipient..."
  }
}

// Or a stateless x402 challenge
{
  "name": "create_payment_challenge",
  "arguments": {
    "protocol": "x402",
    "resource": "/api/download/model.safetensors",
    "amount": "5000",
    "asset": "USDC",
    "chain": "tenzro"
  }
}

AI Models & Inference (3 tools)

Cross-Chain Bridge (3 tools)

// Bridge TNZO from Tenzro to Ethereum
{
  "name": "bridge_tokens",
  "arguments": {
    "from_chain": "tenzro",
    "to_chain": "ethereum",
    "token": "TNZO",
    "amount": "1000000000000000000000",
    "recipient": "0xevm-recipient...",
    "adapter": "layerzero"
  }
}

// Get all routes between two chains
{
  "name": "get_bridge_routes",
  "arguments": {
    "from_chain": "tenzro",
    "to_chain": "solana"
  }
}

Verification (1 tool)

// Verify a Groth16 ZK proof
{
  "name": "verify_zk_proof",
  "arguments": {
    "proof_type": "Groth16",
    "proof": "0xproof-bytes-hex",
    "public_inputs": ["0xinput1...", "0xinput2..."],
    "verifying_key_id": "inference-verification-circuit"
  }
}

Staking & Providers (4 tools)

// Stake as a validator
{
  "name": "stake_tokens",
  "arguments": {
    "address": "0xvalidator...",
    "amount": "100000000000000000000000",
    "role": "Validator"
  }
}

// Register as a model provider with initial stake
{
  "name": "register_provider",
  "arguments": {
    "address": "0xprovider...",
    "role": "ModelProvider",
    "stake_amount": "10000000000000000000000"
  }
}

Tokens & Contracts (7 tools)

// Create an ERC-20 token via the factory
{
  "name": "create_token",
  "arguments": {
    "name": "My Token",
    "symbol": "MTK",
    "decimals": 18,
    "initial_supply": "1000000000000000000000000",
    "creator": "0xcreator-address..."
  }
}

// Response
{
  "token_id": "tok_abc123...",
  "symbol": "MTK",
  "evm_address": "0xtoken-contract-address...",
  "vm_type": "EVM",
  "initial_supply": "1000000000000000000000000"
}

// Atomic cross-VM token transfer (TNZO pointer model)
{
  "name": "cross_vm_transfer",
  "arguments": {
    "from_vm": "EVM",
    "to_vm": "SVM",
    "token": "TNZO",
    "amount": "5000000000000000000",
    "sender": "0xevm-sender...",
    "recipient": "solana-recipient-pubkey..."
  }
}

// Response
{
  "transfer_id": "xvm_abc123...",
  "from_vm": "EVM",
  "to_vm": "SVM",
  "amount": "5000000000000000000",
  "status": "completed"
}

Task Marketplace (7 tools)

Agent Template Marketplace (7 tools)

Agent Spawning & Swarms (5 tools)

Agent Advanced (5 tools)

Model Lifecycle (5 tools)

Governance (5 tools)

Provider Config (4 tools)

Settlement (5 tools)

Canton / DAML (3 tools)

NFTs (6 tools)

Compliance / ERC-3643 (3 tools)

Cross-Chain Advanced (5 tools)

Events (3 tools)

Crypto Primitives (9 tools)

TEE (6 tools)

ZK Proofs (3 tools)

Wallet Advanced (8 tools)

Apps & Sponsorship (5 tools)

deBridge DLN (5 tools)

Usernames & Utility (4 tools)

Authentication

Tenzro's MCP server uses a tiered access model. The auth mode is controlled by the TENZRO_MCP_AUTH environment variable on the node. The public testnet runs in tiered mode by default.

Tiered Access Modes

# Default — read-only tools are public, write tools require auth
TENZRO_MCP_AUTH=tiered

# Open access — all tools public (testnet / local development)
TENZRO_MCP_AUTH=false

# Locked down — all tools require auth
TENZRO_MCP_AUTH=full

Public Tools (no auth required in tiered mode)

The following tools are freely accessible without any credentials on the public testnet:

Onboarding Keys (primary auth method)

Onboarding keys are the primary authentication method for both humans and agents. They are decentralized — no central authority issues or validates them. Any node can issue a key and any node can validate it, because they are tied to a TDIP DID and wallet address stored in RocksDB.

# Step 1 — join the network; an onboarding key is issued automatically
tenzro-cli join --name "Alice" --rpc https://rpc.tenzro.network

# Output:
#   DID:     did:tenzro:human:a1b2c3d4-...
#   Wallet:  0xdfa52b634363dc604065ef5dbce468125ff6e704...
#   Key:     tenzro_a1b2c3d4e5f6...  ← save this

# Step 2 — use the key to call any write tool
curl -X POST https://mcp.tenzro.network/mcp \
  -H "Authorization: Bearer tenzro_a1b2c3d4e5f6..." \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "send_transaction",
      "arguments": {
        "from": "0xdfa52b...",
        "to": "0xrecipient...",
        "amount": "1000000000000000000"
      }
    },
    "id": 1
  }'

Keys can also be issued programmatically and managed via JSON-RPC:

// Issue a new onboarding key programmatically
{
  "method": "tenzro_issueOnboardingKey",
  "params": { "did": "did:tenzro:human:alice-uuid" }
}
// → { "key": "tenzro_a1b2c3..." }

// List all keys for a DID
{
  "method": "tenzro_listOnboardingKeys",
  "params": { "did": "did:tenzro:human:alice-uuid" }
}

// Revoke a key
{
  "method": "tenzro_revokeOnboardingKey",
  "params": { "key": "tenzro_a1b2c3..." }
}

// Validate a key (returns the bound DID + wallet)
{
  "method": "tenzro_validateOnboardingKey",
  "params": { "key": "tenzro_a1b2c3..." }
}
// → { "valid": true, "did": "did:tenzro:human:alice-uuid", "address": "0xdfa52b..." }

OAuth 2.1 (browser-based flows)

For interactive browser-based applications, the node also implements a full RFC-compliant OAuth 2.1 authorization server. This is the appropriate auth path when building web apps where users approve access interactively rather than passing a pre-issued key.

The JWT access token encodes the user's DID in the sub claim and wallet address in the address claim. All tool calls made with this token are delegation-scope-checked against the registered identity, identical to the onboarding key path.

# 1. Discover the authorization server
GET /.well-known/oauth-authorization-server
# → { "authorization_endpoint": "/authorize", "token_endpoint": "/token", ... }

# 2. Register a client (RFC 7591 dynamic registration)
POST /register
Content-Type: application/json
{ "client_name": "My App", "redirect_uris": ["https://myapp.com/callback"] }
# → { "client_id": "cli_abc123", "client_secret": "..." }

# 3. Redirect the user to the approval page
GET /authorize?response_type=code
  &client_id=cli_abc123
  &redirect_uri=https://myapp.com/callback
  &scope=mcp:write
  &state=random_state

# 4. Exchange the code for a JWT
POST /token
Content-Type: application/x-www-form-urlencoded
grant_type=authorization_code&code=AUTH_CODE&...

# JWT payload contains:
# { "sub": "did:tenzro:human:alice-uuid", "address": "0xdfa52b...", ... }

Running Your Own MCP Server

When you run a Tenzro node, the MCP server starts automatically on 0.0.0.0:3001. Override the bind address with the --mcp-addr CLI flag or by setting mcp_addr in config.toml:

# Run a node with MCP on a custom port
cargo run --bin tenzro-node -- \
  --role validator \
  --listen-addr /ip4/0.0.0.0/tcp/9000 \
  --mcp-addr 0.0.0.0:4001

# Or via config.toml
[server]
mcp_addr = "0.0.0.0:4001"

Related Resources

• A2A Protocol Server — agent-to-agent communication on port 3002
• JSON-RPC API Reference — the underlying RPC methods each MCP tool wraps
• Tutorial: Use Tenzro with Claude via MCP — hands-on walkthrough
• TDIP Identity Protocol — how DIDs are registered and resolved
• MPP Payment Protocol — details on the session-based payment flow invoked by create_payment_challenge