How to Use the Ankr (Web3 Node API) MCP in LlamaIndex

Q: How do I ingest Ankr (Web3 Node API) data into a LlamaIndex vector store?

Use the MCP tool spec to run tools like ankrgetBlocks and convert the JSON outputs into Document objects. You can then pass these documents to your vector indexer for semantic retrieval.

Q: Can LlamaIndex query Solana and EVM data simultaneously using Ankr (Web3 Node API)?

Yes, the tool spec exposes both getBalance for Solana and ethgetBalance for EVM chains. LlamaIndex can query both endpoints and index the combined results into a single unified vector index.

Q: How do I prevent hallucinations in my Web3 RAG app using Ankr (Web3 Node API)?

Force your LlamaIndex agent to check live data using ethgetTransactionReceipt or getTransaction before answering. Grounding the response in live RPC data ensures the agent doesn't guess transaction statuses.

Q: Does the tool spec support filtering which RPC methods are exposed?

Yes, you can use the allowedtools filter during initialization to restrict the agent. For example, you can expose only read-only tools like ankrgetNFTMetadata and block write tools like sendTransaction.

Index live Web3 data from the Ankr MCP Server directly into LlamaIndex vector stores for real-time RAG queries.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Ankr (Web3 Node API) MCP to LlamaIndex

Create your Vinkius account to connect Ankr (Web3 Node API) to LlamaIndex 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 Ankr (Web3 Node API) with LlamaIndex

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Indexing real-time RPC data into LlamaIndex

LlamaIndex agents don't just execute blockchain queries; they convert the results into searchable vector embeddings. When your agent runs `ankr_getNFTMetadata` or `ankr_getBlocks`, the returned JSON is indexed on the fly. This lets you build RAG applications that answer complex questions about on-chain history without re-querying the network. You can feed the output of `ankr_getNFTHolders` directly into your document indexers. This creates a semantic layer over raw ledger data, allowing your agent to quickly search past wallet profiles and token distributions.

Context-grounded Web3 search with this MCP Server

Avoid hallucinations when analyzing smart contracts. By exposing `eth_getCode` and `eth_getLogs` to your LlamaIndex query engine, the agent grounds its answers in actual deployed bytecode and event history. It retrieves the exact logs from the network and matches them against your local vector database. This setup is perfect for auditing tools. The agent pulls live storage values using `eth_getStorageAt`, indexes them, and compares the current state against historical contract documentation to flag anomalies.

Unified wallet profiling and balance indexing

Combine off-chain user profiles with live ledger balances. Your LlamaIndex agent can fetch wallet token holdings via `ankr_getAccountBalance` and transaction histories with `ankr_getTokenTransfers`, then index this data alongside your customer CRM files. The agent can then answer natural language queries about a user's net worth and historical trading patterns via the MCP Server. It uses `ankr_getTokenPrice` to calculate real-time portfolio valuations before writing the structured summary back to your index.

Setup guide

Set up Ankr (Web3 Node API) MCP in LlamaIndex

Prerequisites

Python 3.10+ installed
llama-index-tools-mcp package
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install llama-index-tools-mcp llama-index-llms-openai. The MCP tools package provides BasicMCPClient and McpToolSpec.
2

Connect with BasicMCPClient
Point BasicMCPClient to your Vinkius endpoint URL. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. Supports SSE and Streamable HTTP transports.
3

Convert to LlamaIndex tools
Call mcp_tool_spec.to_tool_list_async() to convert all Ankr (Web3 Node API) MCP tools into native FunctionTool objects that any LlamaIndex agent can use.
4

Run with any LLM
Create a FunctionAgent with the tools and your preferred LLM. Swap OpenAI for Anthropic, Gemini, or any LlamaIndex-supported provider.

agent.py

from llama_index.tools.mcp import BasicMCPClient, McpToolSpec
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI

# Connect to the MCP
mcp_client = BasicMCPClient(
    "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
)
mcp_tool_spec = McpToolSpec(client=mcp_client)

# Convert MCP tools to LlamaIndex tools
tools = await mcp_tool_spec.to_tool_list_async()

# Create and run the agent
agent = FunctionAgent(
    tools=tools,
    llm=OpenAI(model="gpt-4o"),
    system_prompt="You have access to Ankr (Web3 Node API) tools.",
)
response = await agent.run("List recent Ankr (Web3 Node API) data")

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 Ankr. 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 Ankr (Web3 Node API) 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 Ankr (Web3 Node API) MCP in LlamaIndex

Use the MCP tool spec to run tools like `ankr_getBlocks` and convert the JSON outputs into Document objects. You can then pass these documents to your vector indexer for semantic retrieval.

Yes, the tool spec exposes both `getBalance` for Solana and `eth_getBalance` for EVM chains. LlamaIndex can query both endpoints and index the combined results into a single unified vector index.

Force your LlamaIndex agent to check live data using `eth_getTransactionReceipt` or `getTransaction` before answering. Grounding the response in live RPC data ensures the agent doesn't guess transaction statuses.

Yes, you can use the allowed_tools filter during initialization to restrict the agent. For example, you can expose only read-only tools like `ankr_getNFTMetadata` and block write tools like `sendTransaction`.

Vinkius executes all RPC queries through a secure MCP Server sandbox. Your indexed wallet addresses and transaction payloads are stored locally in your LlamaIndex vector database, never on the external RPC nodes.

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