How to Use the Nodereal MCP in OpenAI Agents SDK

Build production-grade agents using the OpenAI Agents SDK that query live blockchain data via Nodereal without manual schemas.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Nodereal MCP to OpenAI Agents SDK

Create your Vinkius account to connect Nodereal to OpenAI Agents SDK and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Nodereal with OpenAI Agents SDK

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Direct EVM State Queries

`eth_get_balance` fetches raw address balances directly from Ethereum and compatible EVM chains. Your OpenAI agents read live on-chain state during conversational runs without requiring manual JSON-RPC boilerplate. By exposing standard execution tools like `eth_call` alongside gas estimation via `eth_estimate_gas`, your agent system simulates transactions and reads state in a single turn. This setup lets specialized agents hand off tasks based on live balances. For example, a routing agent checks balances first, then hands the execution path to a transaction-signer agent. The OpenAI dashboard traces these tool calls, giving you full visibility into what the agent queried before it acted.

Aptos Transaction Simulation for OpenAI Agents SDK

`aptos_simulate_transaction` runs dry-run simulations of Move entry functions before broadcasting them to the network. This MCP server exposes the simulator to your agent, letting it analyze potential execution failures or gas consumption beforehand. Your agent checks the output against safety guardrails defined in your Python code before moving forward. The agent also uses `aptos_get_ledger_info` and `aptos_get_account_resources` to verify account state. If a simulation returns an unexpected error, the guardrails halt the run automatically. This prevents your production agent from submitting broken or malicious transactions to the Aptos mainnet.

Enhanced Token and NFT Indexing

`nr_get_token_holders` retrieves historical holder distributions for ERC20 tokens without scanning raw blocks. The MCP server offloads heavy indexing tasks from your local environment to Nodereal's optimized data layer. Your agent calls `nr_get_nft_inventory` to map out user portfolios on the fly, making multi-chain asset tracking fast. Instead of writing custom database syncers, you let the OpenAI Agents SDK auto-discover these endpoints. The agent dynamically decides whether to fetch token balances using `nr_get_token_balance_20` or pull full block receipts via `nr_get_transaction_receipts_by_block_number`. This cuts down on custom backend code.

Setup guide

Set up Nodereal MCP in OpenAI Agents SDK

Prerequisites

Python 3.10+ installed
openai-agents package (pip install openai-agents)
Active Vinkius subscription with a valid endpoint token

1

Install the SDK

Run pip install openai-agents to install the OpenAI Agents SDK. The MCP integration is built-in — no extra dependencies needed.
2

Connect via SSE transport

Use MCPServerSse with your Vinkius endpoint URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. The SDK auto-discovers all Nodereal tools at runtime.
3

Create your Agent

Pass the MCP to Agent(mcp_servers=[server]). The agent receives Nodereal tools as native definitions — JSON schemas resolve automatically.
4

Run the agent

Call Runner.run(agent, prompt) to execute. The agent invokes the appropriate Nodereal tools and returns structured results. Copy the full example on the right to get started.

agent.py

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerSse

async def main():
    async with MCPServerSse(
        url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
    ) as server:
        agent = Agent(
            name="Nodereal Agent",
            instructions="You have access to Nodereal tools.",
            mcp_servers=[server],
        )
        result = await Runner.run(agent, "List recent transactions")
        print(result.final_output)

asyncio.run(main())

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by NodeReal. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Nodereal now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Nodereal MCP in OpenAI Agents SDK

Install the SDK via pip, then initialize the server using the streamable HTTP class pointing to your Vinkius endpoint. Pass this instance in the servers list when creating your Agent. The SDK automatically registers all 24 tools, making them instantly available for your agent to call.

Yes. This single server exposes tools for both networks, such as EVM block queries and Aptos account resources. Your agent routes queries to the correct chain based on the user's prompt without needing separate server configurations.

The SDK uses strict schema validation based on the JSON schemas exposed by this server. When your agent attempts to run a query, the SDK forces the model to match the exact filter parameters. This stops the agent from sending malformed hex strings or invalid block ranges.

Latency depends on your network connection, but Nodereal typically returns block data in under 150ms. Enabling tool list caching in your SDK configuration avoids repeating discovery requests, keeping execution times low.

This server handles public blockchain data like transaction hashes, account resources, and token balances. Vinkius runs the server in an ephemeral V8 sandbox that does not store your queries. No private keys or sensitive payloads are ever cached or logged on Vinkius infrastructure.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript