Connect an MCP client

Tenzro Network 1 serves the Model Context Protocol (MCP) at https://mcp.tenzro.xyz/mcp over Streamable HTTP. Any MCP client can connect: a desktop assistant, a code editor, an agent framework or your own program. Once connected, the client can read chain state, list and call models, resolve identities and, when you authorise it, act on the network.

Read tools need no authentication. Tools that move money or change state need a bearer token issued to an identity, using OAuth 2.1 with DPoP.

Prerequisites

• An MCP client that supports remote servers over Streamable HTTP. Examples include Claude Desktop, Cursor, VS Code and the MCP Inspector; any client that implements the protocol works the same way.
• Node.js 20+ if you want to follow the programmatic steps.

1. Check the server

Use the MCP Inspector to connect and list the tools before you configure anything else:

npx @modelcontextprotocol/inspector

In the Inspector, choose the Streamable HTTP transport, enter https://mcp.tenzro.xyz/mcp and connect. The tool list shows every tool the server exposes, each with its input and output schema. Call get_node_status with no arguments to confirm the connection; it returns the node's state, roles, block height and peer count.

2. Add the server to your client

Most clients register remote MCP servers in a JSON settings file under an mcpServers key. The exact file and key names depend on the client, so check its documentation; the entry itself looks like this:

{
  "mcpServers": {
    "tenzro": {
      "type": "http",
      "url": "https://mcp.tenzro.xyz/mcp"
    }
  }
}

If your client only speaks the stdio transport, bridge it to the remote server with a local proxy such as mcp-remote:

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

Restart the client after you change its settings.

3. Try the read tools

Ask the assistant questions that map to read tools. For example:

The client shows each tool call and its structured result.

4. Call the server from code

The same server works from any MCP SDK. With the TypeScript SDK:

npm install @modelcontextprotocol/sdk

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://mcp.tenzro.xyz/mcp"),
);
const client = new Client({ name: "my-agent", version: "1.0.0" }, {});
await client.connect(transport);

const { tools } = await client.listTools();
console.log(tools.map((t) => t.name).slice(0, 10));

const status = await client.callTool({ name: "get_node_status", arguments: {} });
console.log(status.structuredContent ?? status.content);

const block = await client.callTool({ name: "get_block", arguments: { height: 0 } });
console.log(block.structuredContent ?? block.content);

5. Authorise write tools

Write tools, such as send_transaction, post_task or spawn_agent, need a bearer token bound to an identity. The server follows the MCP authorisation specification:

• It publishes OAuth metadata at /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server, so clients that support MCP authorisation discover it on their own.
• Tokens are OAuth 2.1 access tokens bound to the holder's key with DPoP. Each request carries Authorization: DPoP <token> and a fresh DPoP proof header.
• A token issued to an agent carries its delegation scope, so the server refuses any call outside the limits its controller signed.

For an assistant that acts for you, create a delegated agent in /console/agents with the limits you want, and give the client that agent's token rather than any key of your own. See Create an agentic wallet.

When a controller has put an action on the always-ask list, the first call returns an approval id instead of executing; the call goes through once you approve it.

6. Run the MCP server yourself

Every node can serve MCP. On your own node the server listens on port 3001 at /mcp, and the same tools are available against your node's state:

{
  "mcpServers": {
    "tenzro-local": { "type": "http", "url": "http://127.0.0.1:3001/mcp" }
  }
}

Next steps

• MCP server: tools, authorisation and transports in detail.
• Use the A2A protocol: agent-to-agent messaging.
• Agent demo, start to finish.