# Irys MCP

> Irys MCP connects your AI agent to permanent data storage on Irys, the provenance layer for web3 assets. You can calculate exact data storage costs using specific tokens, query historical records with GraphQL filters, and manage wallet balances across multiple chains. This tool gives you direct access to transaction history and node metadata.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** permanent-storage, web3, arweave, data-provenance, graphql

## Description

Your AI client needs a way to see what happened on the permanent web without leaving your environment. This MCP handles that connection, allowing your agent to read data directly from Irys nodes. Instead of jumping between gas trackers, GraphQL explorers, and wallet dashboards, you can ask your agent questions like, 'How much will it cost to store 1GB using Solana?' or 'Show me all transactions tagged with App-Name: Vurb.' The system runs the complex queries for you. When you subscribe to this MCP through Vinkius, your agent gets immediate access to the entire catalog of tools needed to monitor data permanence and storage economics. You can track node health via `get_info`, get current wallet balances using `get_balance`, and even manage funding or withdrawals with dedicated functions.

## Tools

### get_balance
Checks the current crypto asset balance for a specific wallet address.

### fund_account
Submits a transaction receipt to add funds to the monitored account.

### get_transaction
Fetches detailed metadata for any single, known transaction ID.

### get_info
Retrieves real-time configuration data and supported features from the Irys node itself.

### get_price
Calculates the storage price for a given amount of data using specified tokens like Ethereum or Solana.

### query_transactions
Searches and filters historical transaction metadata by specific tags across GraphQL.

### submit_transaction
Sends a signed data transaction to the provenance layer.

### withdraw_account
Initiates a request to move funds out of the monitored account.

## Prompt Examples

**Prompt:** 
```
What is the storage price for 500MB using the solana token?
```

**Response:** 
```
I've checked the pricing for 500,000,000 bytes on Solana. The current cost is approximately 12,450,000 atomic units. Would you like to check the price for a different token?
```

**Prompt:** 
```
Find the last 3 transactions with the tag 'App-Name' set to 'Vurb'.
```

**Response:** 
```
I found 3 transactions matching your criteria. The most recent one has ID `zK9...` and was uploaded with the tag 'App-Name: Vurb'. Do you want the full metadata for any of these?
```

**Prompt:** 
```
Show me the metadata and supported tokens for this Irys node.
```

**Response:** 
```
Fetching node info... This node is running version 1.0.0 and supports tokens including ethereum, solana, arweave, and matic. It is currently healthy and accepting transactions.
```

## Capabilities

### Check permanent data storage costs
Calculates the exact cost for storing a specific amount of data using various crypto tokens.

### Query historical on-chain activity
Searches and filters through past transactions by specific tags or criteria using GraphQL.

### Monitor wallet balances and funding
Retrieves current crypto asset balances for an address, or submits a transaction to fund the account.

### Retrieve detailed transaction metadata
Pulls specific status details, tags, and information related to any given transaction ID.

## Use Cases

### A new project needs to estimate deployment costs.
The developer asks their agent, 'What is the storage price for 10MB using Matic?' The agent uses `get_price` and returns a precise cost figure, allowing the dev to budget immediately without leaving their terminal.

### Investigating suspicious on-chain behavior.
A data analyst asks the agent to 'Find all transactions tagged with 'Project X' that occurred last month.' The agent runs `query_transactions` and returns a list of IDs, enabling rapid investigation.

### Automating node maintenance checks.
The DevOps engineer asks the agent to check the node status. The agent uses `get_info` and confirms that the current node version is active and reports all supported tokens, ensuring compliance.

### Verifying a specific data upload record.
A user provides a transaction ID and asks for details. The agent calls `get_transaction`, which returns the full metadata, confirming the status and tags attached to that permanent record.

## Benefits

- Know your costs before you commit. Use `get_price` to calculate the exact, atomic-unit cost for storing any amount of data on tokens like Ethereum or Solana.
- Track down specific historical activity instantly. Run complex searches using `query_transactions` with GraphQL filters to find records tied to unique tags.
- Keep your node running smoothly. You can monitor current wallet funds via `get_balance` and initiate funding or withdrawals through dedicated tools.
- Get deep details on any event. Use `get_transaction` to pull all the specific metadata, status, and tags associated with a single transaction ID.
- Maintain operational visibility. The `get_info` tool provides real-time data about the Irys node's version and what features it supports.

## How It Works

The bottom line is that your agent gets a direct pipeline into permanent web data, eliminating manual lookups across multiple developer dashboards.

1. Subscribe to this MCP and provide your Irys Node URL (Mainnet or Devnet).
2. Direct your AI agent to perform a task, such as finding the price for 1GB of storage.
3. The agent executes the necessary tool call, and you receive the real-time data back in plain text.

## Frequently Asked Questions

**How do I use the Irys MCP to check storage pricing?**
You call the `get_price` tool. You must provide three pieces of information: the desired data size, the specific crypto token (like Solana), and the function will return the exact cost in atomic units.

**Can I use query_transactions to find a record by date?**
Yes, `query_transactions` is designed for filtering. You can set up GraphQL filters within your prompt to target specific time ranges or tags associated with the data.

**What is the difference between get_transaction and query_transactions in Irys MCP?**
Use `query_transactions` when you are searching a broad set of records by criteria (like 'all transactions tagged X'). Use `get_transaction` only when you already know the exact ID.

**Do I need to use submit_transaction every time I make changes?**
No. You use `submit_transaction` when you actively want to push new signed data to the provenance layer. Other tools, like `get_balance`, are read-only.

**How do I ensure my node account is funded before submitting data?**
Check balances first using `get_balance`. If funds are low, you can run `fund_account` to submit the necessary funding transaction receipt.