# BlockPi MCP

> BlockPi lets your AI agent monitor distributed blockchain RPC nodes across networks like Ethereum, Polygon, and Solana. You can check Request Unit balances, track consumption history, inspect resource package expirations, and run any standard JSON-RPC query directly through natural language.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** rpc-node, web3-infrastructure, ethereum-api, blockchain-data, json-rpc

## Description

This MCP connects your AI client to a network of decentralized RPC resources. Instead of opening multiple dashboards or writing boilerplate code just to check node health or read a block number, you simply ask your agent for the data. It handles the connection and runs the necessary calls across various chains. You can monitor how much resource capacity you have left in USD and Request Units (RU), track consumption over days, and even inspect when your current service packages expire. For those building complex dApps or running infrastructure simulations, this MCP provides a single point of access to execute generic JSON-RPC calls—whether it’s checking the latest block height on Ethereum or fetching an account balance on Polygon. Because Vinkius hosts this entire catalog, you don't have to connect individual services; you just plug into your preferred AI client and get immediate access to all these multi-chain utilities.

## Tools

### rpc_call
Send a generic JSON-RPC command, allowing you to query specific details like the current block number or an account balance on any supported network.

### get_package_expiration
Retrieves comprehensive details about all your active Request Unit packages and when they expire.

### get_ru_balance
Checks your current remaining balance of Request Units (RU) across the connected networks.

### get_ru_consumed
Provides a consumption report for Request Units, scoped to a specific endpoint or time frame.

### get_wallet_balance
Gets the current available wallet balance, reported in US Dollars (USD).

## Prompt Examples

**Prompt:** 
```
Check my current RU balance and wallet balance on Ethereum.
```

**Response:** 
```
I've checked your BlockPi account for the Ethereum network. You have 1,250,000 RU remaining and a wallet balance of $45.20 USD.
```

**Prompt:** 
```
Show me the RU consumption for the last 3 days on Polygon.
```

**Response:** 
```
In the last 3 days on the Polygon network, your endpoints have consumed a total of 450,000 RU.
```

**Prompt:** 
```
Get the latest block number on Arbitrum using an RPC call.
```

**Response:** 
```
Executing `eth_blockNumber` on Arbitrum... The current block height is 184,209,112.
```

## Capabilities

### Check Account Balances
You can immediately view both your remaining Request Unit (RU) balance and the associated wallet balance in USD.

### Monitor Usage Trends
Track how much RU you've consumed over set time periods, like three or seven days, helping predict cost spikes.

### Audit Service Packages
Inspect all active resource packages, seeing the SKU details and exact expiration dates for planning purposes.

### Execute Generic Blockchain Queries
Run standard JSON-RPC methods—like fetching a block number or checking an account balance—on multiple supported chains in one go.

## Use Cases

### Auditing Node Health Before Launch
A Web3 developer needs to verify if their staging environment has enough capacity. They ask the agent to run get_ru_balance and check the package expiration using get_package_expiration. The system responds instantly with current limits and renewal dates, confirming readiness.

### Troubleshooting Unexpected Costs
A Data Analyst notices usage spikes on Polygon. They prompt the agent to use get_ru_consumed for the last 7 days. This provides a clear consumption graph, allowing them to pinpoint exactly which endpoint caused the spike.

### Getting Live Transaction Data
A developer needs to know the absolute latest block height on Arbitrum. Instead of manually calling an RPC endpoint, they simply ask for it using rpc_call, and the current block number is returned immediately.

### Checking Financial Status Before Querying
Before running a complex query that might cost resources, a user asks the agent to first check their available funds with get_wallet_balance. They confirm they have enough USD before proceeding to run an rpc_call.

## Benefits

- Get immediate financial visibility. Instead of logging into a separate console to check resource limits, you can use the get_ru_balance and get_wallet_balance tools to see your RU and USD totals in one prompt.
- Audit infrastructure risk easily. The get_package_expiration tool lets you inspect every active package's details and precise expiration timestamps, helping prevent service outages before they happen.
- Run any standard blockchain query instantly. Using the rpc_call tool, you execute common methods like eth_blockNumber or eth_getBalance without writing boilerplate code for Ethereum, Polygon, or Solana.
- Track usage costs over time. The get_ru_consumed function helps you determine consumption rates over 1, 3, or 7 days, giving you the data needed to optimize your dApp's spending.
- Centralize node access. By connecting this MCP, your agent handles complex multi-chain connections, meaning you don't need separate credentials or tool chains for every blockchain.

## How It Works

The bottom line is that this MCP lets you manage complex blockchain infrastructure using simple conversation prompts instead of manual dashboard navigation or code snippets.

1. First, subscribe to the BlockPi MCP and provide your unique API key credentials.
2. Next, tell your AI client exactly what data you need (e.g., 'What's my RU usage for Polygon last week?').
3. The MCP handles the connection, runs the appropriate call against the distributed nodes, and returns a clean answer to your agent.

## Frequently Asked Questions

**How do I check if my current RU package expires soon using BlockPi (Distributed RPC Network)?**
You use the get_package_expiration tool to see all active resource packages. This will provide specific details, including the exact expiration timestamps for your services.

**Can I run an eth_call on Solana using BlockPi (Distributed RPC Network)?**
Yes, you can execute generic JSON-RPC calls across multiple networks. The rpc_call tool supports calling standard methods like `eth_call` on various supported blockchains.

**What does get_wallet_balance show me?**
get_wallet_balance shows you the remaining balance in US Dollars (USD). This is separate from your Request Units, giving you a view of your overall spending limit.

**Is BlockPi (Distributed RPC Network) only for Ethereum?**
No. The MCP supports multiple chains, including Polygon and Solana, allowing you to run queries across various decentralized networks from one place.

**How do I track my usage over a custom period with BlockPi (Distributed RPC Network)?**
You can use the get_ru_consumed tool. You specify the desired time window, and it returns your total Request Unit consumption for that endpoint.