# QuickNode MCP

> QuickNode lets your AI agent manage complex Web3 infrastructure directly from natural language prompts. You can create real-time data streams for historical and live blockchain ingestion, deploy event webhooks based on templates (like EVM wallet filters), and execute fundamental RPC calls to read core network data like the latest block number.

## Overview
- **Category:** ship-it
- **Price:** Free
- **Tags:** web3, ethereum, rpc, data-streams, webhooks

## Description

Connecting QuickNode to your agent gives you command over high-performance blockchain data. Instead of jumping between a developer terminal, a dashboard, and an API key vault, your AI client handles all the complexity. You can build full Web3 data workflows right where you're writing code or asking questions. Want to monitor specific contract events? Your agent deploys webhooks using predefined templates, piping real-time alerts directly to your endpoint. Need to keep track of historical transactions? You configure and maintain streaming pipelines for live or archived blockchain ingestion. This capability means that the full power of QuickNode's infrastructure catalog is accessible through Vinkius, letting you manage everything from setting up a key-value store to checking the latest block number—all in one chat session.

## Tools

### create_kv_list
Builds a new list structure for storing key-value data pairs.

### create_kv_set
Creates a single, specific key-value pair in the storage system.

### create_stream
Sets up a new continuous data stream to monitor blockchain activity.

### create_webhook
Deploys an automated webhook listener based on a defined event template.

### delete_kv_set
Removes a specific key-value pair from the storage system.

### delete_stream
Shuts down and removes an existing data stream configuration.

### delete_webhook
Removes a previously deployed webhook listener.

### get_kv_list
Retrieves all the items currently stored in a key-value list structure.

### get_kv_set
Fetches the value associated with a specific key from the storage sets.

### get_stream
Retrieves full details about one specific, existing data stream.

### list_streams
Shows a list of all currently active blockchain data streams.

### list_webhooks
Retrieves the details for every deployed webhook listener.

### rpc_eth_blocknumber
Checks and returns the current number of the most recent block on the network.

### rpc_eth_call
Executes a read-only message call directly against the blockchain without making a transaction.

### rpc_eth_getlogs
Finds and returns an array of all logs that match a specific filter object.

### rpc_eth_gettransactionreceipt
Gets the complete receipt details for any transaction using its unique hash.

### update_kv_list
Adds or modifies items within an existing key-value list structure.

### update_stream
Makes changes to the configuration settings of a live data stream.

## Prompt Examples

**Prompt:** 
```
List all my active QuickNode streams.
```

**Response:** 
```
I've retrieved your streams. You have 2 active streams: 'Mainnet-Ingest' (ID: st_123) and 'Polygon-Archive' (ID: st_456). Would you like the details for one of them?
```

**Prompt:** 
```
Create a new webhook for EVM wallet filtering using the template 'evmWalletFilter'.
```

**Response:** 
```
I'm creating the webhook with the 'evmWalletFilter' template. Please provide the configuration JSON for the addresses you want to monitor.
```

**Prompt:** 
```
What is the current block number on the network?
```

**Response:** 
```
The most recent block number on the connected network is 18,452,910.
```

## Capabilities

### Manage Data Streams
Create, list, and update continuous data feeds for monitoring historical or live blockchain activity.

### Set up Event Webhooks
Deploy automated webhooks that listen for specific contract events (like wallet changes) and send real-time alerts to your service.

### Query Key-Value Data
Create, retrieve, and modify simple data points to power advanced filtering logic within your streaming pipelines.

### Access Core RPC Data
Run direct calls against the blockchain node to fetch fundamental information, such as the most recent block number.

## Use Cases

### Real-time monitoring of smart contract actions.
A compliance analyst needs to track every time a specific governance contract emits an event. The agent uses `create_webhook` with the appropriate template, directing all future events to a logging endpoint. They then use `list_webhooks` later to confirm the listener is active.

### Analyzing transaction failures.
A developer needs to check why a recent deployment failed. The agent uses `rpc_eth_gettransactionreceipt` with the hash and provides a full receipt, allowing the developer to pinpoint exactly where the transaction failed.

### Building a data lookup service.
A backend service needs temporary storage for mapping user IDs to contract addresses. The agent uses `create_kv_set` to store the pairs and later retrieves them using `get_kv_set`, making the data immediately available for stream processing.

### Debugging historical data flow.
A data engineer suspects a gap in their archived records. They ask the agent to run `rpc_eth_getlogs` with specific filters and time ranges, getting an array of all matching log events for validation.

## Benefits

- Instead of manually checking a dashboard to see if your data stream is running, you ask your agent to list all active streams. It runs the `list_streams` tool and gives you an instant status update.
- Stop building complex filtering logic in separate databases. You can use the system's key-value store—creating lists with `create_kv_list` or updating them with `update_kv_list`—to power your data pipelines directly.
- Need to know what happened on Ethereum? Use `rpc_eth_blocknumber` to get the latest block number immediately, or use `rpc_eth_getlogs` to filter for specific events without writing a single query.
- When a wallet changes its address, you don't need separate monitoring services. Your agent uses `create_webhook` with an EVM template to instantly capture and route that event data.
- You can perform advanced reads using `rpc_eth_call`, which executes a message call without the overhead of creating a full transaction, saving time and gas.
- If you need to pause or change how your pipeline works, simply use `update_stream` instead of logging into the web console to modify the existing data source.

## How It Works

The bottom line is that you manage complex Web3 infrastructure by simply telling your agent what you want done.

1. First, you subscribe to this MCP and provide your QuickNode API Key along with your RPC URL.
2. Second, tell your AI agent exactly what infrastructure change you need—for instance, 'I need a stream for Polygon data.'
3. The system executes the request via the appropriate tool, manages the configuration on the backend, and confirms success or failure back to your chat.

## Frequently Asked Questions

**How do I check if my data stream is working with QuickNode MCP?**
To see what's running, ask your agent to list all active streams. It runs `list_streams` and provides a summary of every configured pipeline.

**Can I use the Webhook tools in QuickNode MCP for testing?**
Yes. You can create webhooks using templates like 'evmWalletFilter' via `create_webhook`. Your agent will help you deploy these listeners and later, `list_webhooks` shows what you set up.

**What is the difference between rpc_eth_call and other RPC tools in QuickNode MCP?**
The `rpc_eth_call` tool executes a message call immediately, letting you read data without paying for a transaction. It's ideal for non-state-changing reads.

**How do I delete old resources in the QuickNode MCP?**
You use specific tools like `delete_stream` or `delete_webhook`. Just tell your agent which resource to remove, and it handles the cleanup for you.

**Can I query data using the KV Store in QuickNode MCP?**
Yes. You use tools like `create_kv_list` or `get_kv_set` to manage key-value pairs, which powers advanced filtering logic for your streams.