MCP explained: giving AI agents real-time Solana data

If you are building an AI agent in 2026 and your agent needs to know what is happening on Solana, you face a choice. Either you ship a custom indexer — Helius for RPC, Jito for MEV, your own Postgres for joins, and per-DEX adapters for Jupiter, Raydium, Orca, and Meteora — and maintain four integrations, four auth flows, and four rate limits. Or you give your agent native MCP tools and stop writing indexer code forever.

This post walks through what MCP actually is, why Solana data turned out to be the natural fit for it, and how techkern delivers every Solana DEX swap, every pump.fun launch, every dev wallet, and every tracked KOL to any agent with one MCP install.

What MCP is, briefly

The Model Context Protocol is Anthropic's open standard (open-spec, multi-vendor) for plugging external tools into an LLM agent. The architecture is server / client. An MCP server exposes a set of tools, each with a JSON schema for inputs and a stable return shape. An MCP client — Claude Desktop, Cursor, Cline, Continue, Zed, the OpenAI Agents SDK — connects to the server over stdio or SSE and lets the model call those tools the same way it calls any built-in.

The breakthrough is not the wire format. JSON-RPC over stdio is not new. The breakthrough is the contract: every MCP server speaks the same surface, so any MCP client gets the new tool the moment the server is installed. No bespoke connector code, no per-vendor plugins. mcp add techkern and your agent has query_solana_swaps immediately.

Why Solana data is the killer context source

LLM agents are bad at recent factual recall. They are good at synthesizing structured data that you hand them. Solana on-chain data is one of the few data domains where:

• The schema is stable and public (token transfers, swaps, mint events all have well-known shapes)
• The data updates in real time at sub-second block production
• The query patterns are repeatable enough to standardize as tools
• The signal density is enormous — 60M+ transactions a day, every dev wallet's full history queryable

That is precisely the surface MCP was designed for. Compare it to giving an agent web search: the result shape is unstructured HTML, the freshness varies, and the agent has to parse anew every time. Compare it to giving an agent a SQL database: the schema is structured, but it is a private resource, and now your model needs read credentials.

Solana MCP tools sit in the sweet spot — structured, fresh, public, and parameterized by a small set of well-known shapes (mints, wallets, programs, time-windows).

What techkern indexes

We index every Solana primitive worth indexing, end-to-end:

• DEX swaps — every fill on Jupiter (aggregator), Raydium (AMMs + CLMM), Orca (whirlpools), Meteora (DLMM). Decoded into a single normalized swap schema.
• pump.fun launches — every bonding-curve mint, every buy / sell on the curve, every graduation to Raydium. ~10K-50K new mints per day at peak.
• Token holders — full holder list per mint, top-N concentration, dev-wallet balance tracking, snipers identified by first-block buys.
• KOL wallets — 1,400+ curated influencer / alpha-trader addresses, every entry and exit tagged in real time with PnL.
• Mint authority + freeze status — fast revocation checks for rug-screen.
• Dev token history — given any dev wallet, the full historical launch log: graduated, rugged, dead.

Total: 247B+ Solana rows indexed in ClickHouse, sub-50ms p95 query latency. Same infra that powers our internal alpha bots — exposed via MCP so your agent can query it natively. Helius is our upstream RPC; Jito MEV bundles are tracked separately for cross-referencing sniper activity.

The tools your agent gets

After mcp add techkern your AI agent has these tools available:

• query_solana_swaps(mint?, wallet?, since?, min_usd?) — DEX swaps filtered any combo
• query_pump_fun_launches(window_minutes?, min_holders?, min_mcap_usd?) — fresh launches
• query_token_holders(mint, top_n?) — holder list + concentration metrics
• query_kol_wallets(window_minutes?, min_size_usd?) — recent tracked-KOL buys
• mint_authority_check(mint) — quick rug check
• dev_token_history(wallet) — full launch log for a dev wallet
• whale_tracker(wallet, since?) — full activity for any address
• new_token_alerts(min_holders?) — fresh mints crossing thresholds
• liquidity_depth(mint) — pool depth across DEXes
• holder_distribution(mint) — top-N holders, concentration metrics

Each tool has a strict JSON-schema input. The return shape is JSON every time, never markdown blobs the model has to re-parse.

What this changes for your agent

Three concrete workflows that go from impossible-to-painful → one prompt:

Pre-trade due diligence. "Pull holder distribution + mint authority + dev wallet's last 50 launches for $KERN before I size in." Previously: 4 API calls across 3 services, manual aggregation. Now: one prompt, the agent calls 4 MCP tools in parallel, returns a summary.

Whale-mirroring strategy. "Watch this Solana wallet, alert me when it opens a new position > $50K." Previously: build your own indexer, host it, monitor it. Now: agent polls whale_tracker on a loop, notifies you.

Fresh-launch sniper triage. "Find any pump.fun token less than 30 minutes old where dev still holds >50%, with at least 100 holders, where at least one wallet from my KOL list has a position." Previously: write three database joins. Now: one prompt, three MCP tool calls in parallel, structured response.

The on-chain settlement angle

Techkern is paid per query in $TECH (Solana SPL). 85% goes to the validators running indexer shards (anyone can stake $TECH and host one). 10% goes to buyback-and-burn. 5% goes to the dev fund. Settlement is per-query, no monthly invoicing, no Stripe. The 247B rows are indexed across 4 shards (DEX swaps / pump.fun / holders / KOL wallets); if any single shard goes offline, queries reroute to a backup within 15 seconds.

You can also pay-as-you-go in USDC on Solana if you do not want to touch tokens. The MCP install is identical either way.

Getting started

mcp add techkern

That is the actual command for Claude Code and any MCP-aware CLI. For Claude Desktop, drop the snippet from the docs into claude_desktop_config.json and restart. Cursor, Cline, Continue, Zed all take a mcp.json entry. Same server, every client.

Once it is installed, ask Claude (or your agent of choice): "Use techkern to find the three pump.fun launches with the most holders in the last 30 minutes." The model will discover and call query_pump_fun_launches, then summarize the results. No code on your end. 8.4M+ MCP queries served today across 2,341 connected AI agents — and counting.