MCP for DeFi: Connecting AI Agents to On-Chain Data

TL;DR

Decentralized finance protocols generate millions of on-chain events every day: swaps, liquidity shifts, lending rate changes, vault deposits, governance votes. For technical teams building DeFi products, the challenge is not access to this data. RPCs and indexers handle that. The real challenge is making this data actionable in real time, especially as AI agents become central to how teams monitor, analyze, and respond to market conditions. Model Context Protocol (MCP) provides the integration layer that connects AI agents directly to on-chain state, turning raw blockchain data into structured context that language models can reason about and act on.

This post covers how to build MCP servers that expose DeFi protocol data to AI agents, including reading on-chain state, streaming real-time events, and constructing transaction payloads. Whether you are building monitoring dashboards, risk engines, or automated response systems, MCP gives your AI layer structured access to the data it needs.

DeFi protocols are complex systems with state spread across multiple accounts, programs, and chains. A single lending protocol might track collateral ratios, interest rate curves, oracle price feeds, liquidation thresholds, and governance parameters, all updated in real time. Traditional dashboards and alerts handle known scenarios, but they struggle with the combinatorial complexity that emerges when multiple protocols interact.

AI agents excel at exactly this kind of reasoning: synthesizing multiple data streams, identifying patterns across protocols, and suggesting responses to novel situations. But agents need structured access to protocol state. They cannot parse raw RPC responses or decode account data without a well-defined interface. MCP provides that interface through tools (actions the agent can invoke), resources (data the agent can read), and prompts (templates that guide agent reasoning about domain-specific tasks).

The gap today is not intelligence. Language models are already capable of sophisticated financial reasoning. The gap is connectivity: getting the right data to the model in the right format at the right time. An MCP server for DeFi closes that gap by acting as a translation layer between on-chain state and AI context windows.

A DeFi MCP server sits between your blockchain data sources and your AI clients. The architecture has three layers.

Data ingestion layer. This connects to RPCs, indexers (like Helius, The Graph, or custom Geyser plugins), and oracle feeds. It handles account deserialization, event parsing, and price feed normalization. For Solana programs built with Anchor, you can use the IDL to automatically deserialize account data into typed structures. For EVM chains, ABI decoding serves the same purpose.

Context formatting layer. Raw on-chain data is not useful to an AI agent. Account balances in lamports, token amounts in raw decimals, timestamps in Unix epochs: none of this is immediately interpretable. The formatting layer converts raw data into human-readable (and therefore LLM-readable) representations. A vault position becomes a structured object with fields like collateral_usd, debt_usd, health_factor, and liquidation_price. This is where domain knowledge gets encoded.

MCP interface layer. This exposes the formatted data through MCP primitives. Tools let the agent query specific protocol state (get_vault_position, get_pool_liquidity, get_lending_rates). Resources provide continuously updated data feeds (current prices, TVL snapshots, rate histories). Prompts encode domain expertise about how to analyze specific scenarios (evaluate_liquidation_risk, compare_yield_strategies).

The most fundamental capability of a DeFi MCP server is reading protocol state. Here is how to structure tools for common DeFi data access patterns.

Vault and lending position queries. Define a tool that takes a wallet address and protocol identifier, then returns the user’s positions with calculated metrics. The tool should handle the full pipeline: fetch relevant accounts from the RPC, deserialize using the protocol’s IDL or ABI, calculate derived values (health factor, liquidation price, accrued interest), and return a clean JSON response. Include both raw values and human-readable formatting so the agent can reason about the numbers naturally.

Liquidity pool analysis. AMM pools require specific queries: current reserves, fee tiers, tick ranges (for concentrated liquidity), volume history, and impermanent loss calculations. A well-designed tool returns pool state alongside derived analytics. Instead of just returning reserve_a: 1000000 and reserve_b: 500000, include the computed price, 24h volume, fee APR, and TVL. The agent should not need to do arithmetic to understand the pool’s status.

Cross-protocol aggregation. The real power emerges when your MCP server can query across protocols. A tool like get_yield_opportunities can scan multiple lending protocols and liquidity pools, normalize the data into comparable metrics, and return ranked results. This is where AI agents add genuine value: they can reason about the tradeoffs between yield, risk, lock-up periods, and protocol maturity in ways that simple sorting cannot.

Static queries are necessary but not sufficient. DeFi moves fast, and agents need real-time awareness. MCP resources with subscription support enable this pattern.

Event-driven resources. Define MCP resources that update when on-chain events occur. A resource like defi://protocol/events can stream parsed transaction logs: swaps above a threshold, liquidation events, large deposits or withdrawals, governance proposal submissions. On Solana, Geyser plugins or WebSocket subscriptions on program accounts provide the raw event stream. On EVM chains, event log subscriptions serve the same role. Your MCP server parses these into structured events and pushes them to subscribed clients.

Price and oracle feeds. Expose oracle price data as MCP resources with frequent updates. Include not just the current price but also confidence intervals, staleness indicators, and source attribution. Agents monitoring DeFi positions need to know when oracle data is reliable and when it might be stale or manipulated. A resource like defi://oracles/sol-usd should include price, confidence, last_update_slot, num_sources, and deviation_from_twap.

Rate change monitoring. Lending rates, fee parameters, and collateral factors change based on utilization and governance. Track these parameters over time and expose the history as a resource. An agent evaluating a lending position should see not just the current borrow rate but the trend: is it climbing, stable, or dropping? How does current utilization compare to the protocol’s interest rate curve inflection points?

Reading data is half the equation. For agents that need to take action (rebalancing positions, executing swaps, adjusting collateral), your MCP server needs tools that construct transaction payloads.

Transaction construction tools. Define tools that take high-level intent (swap 100 USDC for SOL on Jupiter, deposit 50 SOL into Marinade vault) and return unsigned transaction payloads. The MCP server handles route optimization, account resolution, instruction building, and compute budget estimation. The agent receives a ready-to-sign transaction along with a human-readable summary of what the transaction does, the expected outcome, and any risks (slippage, MEV exposure, priority fee requirements).

Important safety consideration. MCP servers should construct and simulate transactions but never sign or submit them autonomously. The signing step must remain with the user or a separate, audited authorization service. Your MCP tools should return the unsigned transaction, a simulation result showing expected state changes, and clear warnings about any unusual conditions (high slippage, low liquidity, untested program interactions). This keeps the human in the loop for all value-transferring actions.

Simulation and preview. Before constructing a transaction, run it through simulation. On Solana, simulateTransaction shows the expected account state changes. On EVM chains, eth_call or trace_call serve the same purpose. Return the simulation results alongside the transaction payload so the agent (and ultimately the user) can verify the expected outcome before signing.

One of the highest-value applications of MCP integration services in DeFi is continuous risk monitoring. AI agents can synthesize multiple risk signals that would overwhelm a traditional dashboard.

Liquidation risk assessment. Combine position data with price feeds, volatility estimates, and protocol-specific liquidation mechanics. A prompt template for liquidation analysis should guide the agent through checking health factors, estimating time-to-liquidation at current volatility, evaluating available exit routes (which pools have sufficient liquidity for the collateral asset), and recommending specific actions (add collateral, reduce debt, or exit the position entirely).

Protocol health monitoring. Beyond individual positions, agents can monitor protocol-level health metrics. Total utilization rates, bad debt accumulation, oracle deviation patterns, governance proposal impacts: these signals often interact in ways that single-metric alerts miss. An MCP server that exposes protocol health as a composite resource gives agents the context to identify systemic risks early.

Cross-chain exposure tracking. Many DeFi strategies span multiple chains. Your MCP server can aggregate position data across Solana, Ethereum, and L2s into a unified view. The agent sees total exposure, concentration risk, bridge dependencies, and chain-specific risks in a single context window.

Building MCP servers for DeFi production environments introduces specific challenges.

RPC reliability and rate limits. DeFi MCP servers make heavy RPC calls. Implement connection pooling, request batching, and intelligent caching. Cache account data with slot-aware invalidation: data is valid until a new slot updates the relevant accounts. Use multiple RPC providers with automatic failover. Monitor RPC latency and error rates as first-class metrics.

Data freshness guarantees. Different use cases have different freshness requirements. A portfolio overview can tolerate data that is a few seconds old. A liquidation monitor needs sub-second accuracy. Design your MCP resources with explicit freshness metadata so agents can assess whether the data is current enough for their task. Include last_updated_slot, data_age_ms, and freshness_guarantee fields in every response.

Error handling for financial data. In DeFi, incorrect data can lead to incorrect financial decisions. Handle errors explicitly: if an oracle price is stale, flag it. If an RPC call fails, do not return cached data without indicating its age. If a calculation produces unexpected results (negative TVL, health factor above theoretical maximum), surface the anomaly rather than silently returning bad data. Financial MCP servers should fail loudly and clearly.

Access control. DeFi MCP servers often expose sensitive data (wallet positions, trading strategies, portfolio composition). Implement OAuth 2.1 scoping so that different agents get different levels of access. A monitoring agent might have read-only access to positions, while a rebalancing agent gets transaction construction permissions. Rate limiting by scope prevents any single agent from overwhelming your data infrastructure.

A well-built DeFi MCP server transforms how teams interact with on-chain protocols. Instead of checking dashboards, teams ask agents to summarize their positions. Instead of writing custom scripts for each new analysis, they describe what they want to know and the agent queries the right tools. Instead of building alert systems for every possible scenario, agents monitor positions continuously and surface anomalies they were never explicitly programmed to detect.

The technical teams building DeFi products today are already managing enormous complexity. MCP does not reduce that complexity, but it gives AI agents the structured access they need to help manage it. The result is faster response times, broader monitoring coverage, and analysis that draws on the full context of your on-chain activity rather than the narrow slice visible in any single dashboard.

Exo Technologies builds production MCP integrations for technical teams working with complex systems, including DeFi protocols, AI infrastructure, and enterprise platforms. If your team needs AI agents with structured access to your on-chain data and protocol state, reach out at [email protected].