Connect an MCP client

Tenzro Network serves the Model Context Protocol (MCP) at https://mcp.tenzro.com/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 authorize it, act on the network.

The server speaks MCP revision 2026-07-28, which has no initialize handshake and no session: a client sends server/discover or any request, and every request carries the protocol version and the client's capabilities in _meta. Use a client that implements this revision. See MCP server.

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 and implements revision 2026-07-28. A client that only speaks an earlier revision opens with initialize, which the server refuses with error -32022.
• Node.js 20+ if you want to follow the programmatic steps.

1. Check the server

Ask the server what it serves before you configure anything else:

curl -s -X POST https://mcp.tenzro.com/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2026-07-28' \
  -H 'Mcp-Method: server/discover' \
  -d '{"jsonrpc":"2.0","id":1,"method":"server/discover",
       "params":{"_meta":{
         "io.modelcontextprotocol/protocolVersion":"2026-07-28",
         "io.modelcontextprotocol/clientCapabilities":{}}}}'

The reply lists the revision the server serves. Any other revision in _meta, and any initialize request, comes back as error -32022 Unsupported protocol version.

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.com/mcp"
    }
  }
}

If your client only speaks the stdio transport or an earlier revision of the protocol, it cannot connect to this server directly. Call the server from code instead (step 4), or update the client.

Restart the client after you change its settings.

3. Try the read tools

Ask the assistant questions that map to read tools. The client lists the tools with tools/list and calls them with tools/call. For example:

The client shows each tool call and its structured result.

4. Call the server from code

The protocol is plain JSON-RPC over HTTP, so any HTTP client works. Each request carries the revision and capabilities in _meta, and the MCP-Protocol-Version and Mcp-Method headers (plus Mcp-Name for tools/call). There is no handshake and no session to keep.

const ENDPOINT = "https://mcp.tenzro.com/mcp";
const meta = {
  "io.modelcontextprotocol/protocolVersion": "2026-07-28",
  "io.modelcontextprotocol/clientCapabilities": {},
};

type McpResult = { tools?: { name: string }[]; structuredContent?: unknown; content?: unknown };

async function mcp(method: string, params: Record<string, unknown>, name?: string): Promise<McpResult> {
  const res = await fetch(ENDPOINT, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      accept: "application/json, text/event-stream",
      "MCP-Protocol-Version": "2026-07-28",
      "Mcp-Method": method,
      ...(name ? { "Mcp-Name": name } : {}),
    },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params: { ...params, _meta: meta } }),
  });
  const body = (await res.json()) as { result?: McpResult; error?: { code: number; message: string } };
  if (body.error) throw new Error(`${body.error.code}: ${body.error.message}`);
  return body.result ?? {};
}

const { tools = [] } = await mcp("tools/list", {});
console.log(tools.map((t) => t.name).slice(0, 10));

const status = await mcp("tools/call", { name: "get_node_status", arguments: {} }, "get_node_status");
console.log(status.structuredContent ?? status.content);

const block = await mcp("tools/call", { name: "get_block", arguments: { height: 0 } }, "get_block");
console.log(block.structuredContent ?? block.content);

An MCP SDK works the same way if it implements revision 2026-07-28.

5. Authorize 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 authorization specification:

• It publishes OAuth metadata at /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server, so clients that support MCP authorization 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, authorization and transports in detail.
• Use the A2A protocol: agent-to-agent messaging.
• Agent demo, start to finish.