Docs

Getting started

Thirty seconds, two commands. Install the MCP server in your agent, then ask it anything about Solana.

# Install in any MCP-aware client
mcp add techkern

# Set your key (get one at https://techkern.xyz/dashboard)
export TECHKERN_API_KEY="tk_live_8c7f...3a91"

Restart your client. The agent now has ten new tools. Ask it something real:

> Find Solana memecoins with over $100K volume in the last 5 minutes
  where the dev still holds more than 50%.

→ techkern.query_solana_swaps({
    last_minutes: 5,
    min_volume_usd: 100000,
    where: { dev_hold_pct: { gt: 50 } }
  })

→ 3 matches: $MOCHI ($412K vol, dev 72%), $ZIGGY ($188K vol,
  dev 64%), $POPCAT ($121K vol, dev 51%).

No webhooks. No polling. No glue code. The agent picks the right tool, calls it, and reasons over the response. You move on.

Install

Every MCP-aware client takes the same shape of config. The server ships as a single npm package, fetched lazily on client launch. Source on GitHub: github.com/kern-tech/techkern.

Claude Desktop

Edit claude_desktop_config.json. On macOS it lives at ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows: %APPDATA%\Claude\claude_desktop_config.json.

{
  "mcpServers": {
    "techkern": {
      "command": "npx",
      "args": ["-y", "@techkern/mcp-server"],
      "env": {
        "TECHKERN_API_KEY": "tk_live_8c7f...3a91"
      }
    }
  }
}

Quit Claude Desktop fully (not just close the window) and relaunch. The hammer icon shows ten new Solana tools.

Cursor

Edit ~/.cursor/mcp.json, then open Cursor Settings → MCP and toggle the server on.

{
  "mcpServers": {
    "techkern": {
      "command": "npx",
      "args": ["-y", "@techkern/mcp-server"],
      "env": { "TECHKERN_API_KEY": "tk_live_..." }
    }
  }
}

Cline

Edit ~/Documents/Cline/MCP/cline_mcp_settings.json. Add read-only tools to autoApprove to skip per-call confirmation:

{
  "mcpServers": {
    "techkern": {
      "command": "npx",
      "args": ["-y", "@techkern/mcp-server"],
      "env": { "TECHKERN_API_KEY": "tk_live_..." },
      "autoApprove": [
        "query_solana_swaps",
        "query_pump_fun_launches",
        "query_token_holders",
        "query_kol_wallets",
        "mint_authority_check",
        "dev_token_history",
        "whale_tracker",
        "liquidity_depth",
        "holder_distribution"
      ]
    }
  }
}

Continue

Edit ~/.continue/config.json and append to the mcpServers array:

{
  "mcpServers": [
    {
      "name": "techkern",
      "command": "npx",
      "args": ["-y", "@techkern/mcp-server"],
      "env": { "TECHKERN_API_KEY": "tk_live_..." }
    }
  ]
}

Zed

Edit ~/.config/zed/settings.json and add under assistant.mcp_servers:

{
  "assistant": {
    "mcp_servers": {
      "techkern": {
        "command": "npx",
        "args": ["-y", "@techkern/mcp-server"],
        "env": { "TECHKERN_API_KEY": "tk_live_..." }
      }
    }
  }
}

OpenAI Agents SDK

For programmatic agents in Node, Bun, or Deno, use the hosted SSE endpoint — no local subprocess, lower latency.

import { Agent } from "@openai/agents";
import { MCPServerSse } from "@openai/agents/mcp";

const techkern = new MCPServerSse({
  name: "techkern",
  url: "https://api.techkern.xyz/mcp",
  headers: {
    Authorization: `Bearer ${process.env.TECHKERN_API_KEY}`,
  },
});

const agent = new Agent({
  name: "Solana Research Bot",
  model: "gpt-4.1",
  mcpServers: [techkern],
  instructions:
    "You research Solana using techkern — swaps, pump.fun launches, holders, KOL wallets.",
});

const result = await agent.run(
  "Find pump.fun launches with >100 holders in the last hour."
);
console.log(result.output);

Authentication

Two paths. Bearer token for everything programmatic, Solana wallet sign-in for pay-per-query without an account.

Bearer token

Tokens are scoped per environment — tk_test_ for development, tk_live_ for production. Pass the key in the Authorization header on every request:

curl https://api.techkern.xyz/v1/query \
  -H "Authorization: Bearer tk_live_8c7f3a91d2b8e4f5c1a9b6d7" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "query_pump_fun_launches",
    "input": { "last_minutes": 60, "min_holders": 100 }
  }'

Rotate keys from the dashboard with a 24-hour overlap so deploys cross cleanly. Keys are hashed at rest (Argon2id) and never logged.

Solana wallet sign-in

Connect Phantom, Backpack, or Solflare. The dashboard issues an API key tied to your wallet, and pay-per-query in $TECH or USDC settles automatically on every call — no monthly invoice, no Stripe. The signed challenge expires after 5 minutes:

import { SigninMessage } from "@techkern/sdk";

const msg = new SigninMessage({
  domain: "techkern.xyz",
  publicKey: wallet.publicKey.toBase58(),
  nonce: crypto.randomUUID(),
  issuedAt: new Date().toISOString(),
});

const signature = await wallet.signMessage(msg.prepare());

const { apiKey } = await fetch("https://api.techkern.xyz/v1/auth/wallet", {
  method: "POST",
  body: JSON.stringify({ message: msg.serialize(), signature }),
}).then((r) => r.json());

Tools

Ten tools. Every input is JSON-schema validated. Every output is structured JSON — never a markdown blob the model has to re-parse. All ten are backed by four ClickHouse shards (swaps, pumpfun, holders, kol) fed by Helius RPC + Jito MEV bundles, indexed every Solana slot (~400ms).

interface QuerySolanaSwapsInput {
  min_volume_usd?: number;       // default 0
  last_minutes?: number;         // default 60, max 10080 (7d)
  tokens?: string[];             // mint addresses
  where?: {
    dev_hold_pct?: { gt?: number; lt?: number };
    holder_count?: { gt?: number; lt?: number };
  };
  limit?: number;                // default 50, max 500
}

Find Solana swaps over $50K in the last 10 minutes
where the dev still holds more than 40%.

{
  "results": [
    {
      "token": "MOCHI",
      "ca": "7xK9rR4nT2vMqLp8wJ5sF3yH6zXcVbNm1aQpEdRtYuQp",
      "volume_usd": 412300,
      "dev_hold_pct": 72.4,
      "first_swap": "2026-05-22T14:32:11Z",
      "dex": "raydium",
      "signature": "5jKvN8...Hp3RqW"
    },
    {
      "token": "ZIGGY",
      "ca": "9pM2qR5xT8vNbKj4wH7sG2yF6zXcVbNm1aQpEdRtYuQp",
      "volume_usd": 188400,
      "dev_hold_pct": 64.1,
      "first_swap": "2026-05-22T14:29:48Z",
      "dex": "jupiter",
      "signature": "3xLpQ2...Vn8MkT"
    },
    {
      "token": "POPCAT",
      "ca": "7GCihgDB8fe6KNjn2MYtkzZcRjQy3t9GHdC8uHYmW2hr",
      "volume_usd": 121800,
      "dev_hold_pct": 51.0,
      "first_swap": "2026-05-22T14:27:02Z",
      "dex": "orca",
      "signature": "2bRtY9...Lk4FsX"
    }
  ],
  "result_count": 3,
  "latency_ms": 31
}

interface QueryPumpFunLaunchesInput {
  last_minutes?: number;          // default 30
  min_mcap_usd?: number;          // default 0
  min_holders?: number;           // default 0
  bonding_complete?: boolean;     // filter graduated vs pre-grad
  limit?: number;                 // default 50, max 500
}

Show pump.fun launches in the last hour with at least
100 holders that have not yet bonded.

{
  "results": [
    {
      "token": "KERN",
      "ca": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
      "mcap_usd": 47200,
      "age_minutes": 12,
      "holders": 184,
      "dev_wallet": "9ab2cD4eF6gH8jK1mN3pQ5rS7tU9vW2xY4zA6bC8dE",
      "bonding_progress_pct": 68.3
    },
    {
      "token": "WIBBLE",
      "ca": "Bn5pT3qR8sV2vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
      "mcap_usd": 31900,
      "age_minutes": 27,
      "holders": 142,
      "dev_wallet": "4cD6eF8gH1jK3mN5pQ7rS9tU2vW4xY6zA8bC1dE3f",
      "bonding_progress_pct": 41.8
    },
    {
      "token": "FLOPPY",
      "ca": "Cm2pT5qR8sV3vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
      "mcap_usd": 22400,
      "age_minutes": 44,
      "holders": 109,
      "dev_wallet": "7eF9gH2jK4mN6pQ8rS1tU3vW5xY7zA9bC2dE4fG6h",
      "bonding_progress_pct": 22.1
    }
  ],
  "result_count": 3,
  "latency_ms": 18
}

interface QueryTokenHoldersInput {
  token_mint: string;             // required, base58 mint
  top_n?: number;                 // default 10, max 100
}

Pull the top 10 holders of mint Hm4q...YuQp
and tell me if it looks centralized.

{
  "token_mint": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
  "unique_holders": 184,
  "top_10_pct": 38.2,
  "dev_balance_pct": 4.2,
  "gini_coefficient": 0.71,
  "top_n": [
    { "address": "9ab2cD4eF6gH8jK1mN3pQ5rS7tU9vW2xY4zA6bC8dE", "pct": 8.1, "first_block_buy": false },
    { "address": "2cF4dE6gH8jK1mN3pQ5rS7tU9vW2xY4zA6bC8dE0fG", "pct": 5.4, "first_block_buy": true },
    { "address": "Cented7y3Tg9bN5pT3qR8sV2vKj7wL3xH9yF6zXcV", "pct": 4.9, "first_block_buy": false }
  ],
  "latency_ms": 14
}

interface QueryKolWalletsInput {
  min_pnl_30d_usd?: number;       // default 0
  recent_buy_minutes?: number;    // default 60
  wallets?: string[];             // shortlist filter
  limit?: number;                 // default 50
}

Show me KOL wallets with >$500K 30d PnL
that bought anything in the last 30 minutes.

{
  "results": [
    {
      "wallet": "Cented7y3TgN8rL4pK2mJ9hG6fD3sA1qW5xZ7vY9b",
      "recent_buy": {
        "token": "KERN",
        "ca": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
        "at": "2026-05-22T14:42:18Z"
      },
      "size_usd": 12400,
      "pnl_30d_usd": 1240000,
      "tracked_since": "2024-08-12"
    },
    {
      "wallet": "Ansem8Lk2qN5pT3rR8sV2vKj7wL3xH9yF6zXcVbNm",
      "recent_buy": {
        "token": "WIF",
        "ca": "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm",
        "at": "2026-05-22T14:38:02Z"
      },
      "size_usd": 84000,
      "pnl_30d_usd": 2980000,
      "tracked_since": "2023-11-04"
    }
  ],
  "result_count": 2,
  "latency_ms": 22
}

interface MintAuthorityCheckInput {
  token_mint: string;             // required
}

Is the mint authority on Hm4q...YuQp renounced?

{
  "token_mint": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
  "mint_authority": null,
  "freeze_authority": null,
  "is_renounced": true,
  "dev_wallet": "9ab2cD4eF6gH8jK1mN3pQ5rS7tU9vW2xY4zA6bC8dE",
  "deploy_signature": "5jKvN8mPqR2sT4vXcVbNm1aQpEdRtYuQpHm4qN2pR8s",
  "latency_ms": 9
}

interface DevTokenHistoryInput {
  wallet: string;                 // required, base58
  limit?: number;                 // default 100
}

Has the wallet 9ab2...8dE deployed anything before?
Show me the last 5 tokens with their outcome.

{
  "wallet": "9ab2cD4eF6gH8jK1mN3pQ5rS7tU9vW2xY4zA6bC8dE",
  "results": [
    {
      "name": "KERN",
      "ca": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
      "deploy_at": "2026-05-22T14:30:00Z",
      "current_mcap": 47200,
      "rug_status": "active"
    },
    {
      "name": "OOPS",
      "ca": "2cF4dE6gH8jK1mN3pQ5rS7tU9vW2xY4zA6bC8dE0fG",
      "deploy_at": "2026-05-18T03:12:00Z",
      "current_mcap": 0,
      "rug_status": "rugged"
    },
    {
      "name": "OOPS2",
      "ca": "3dG5eF7gH9jK2mN4pQ6rS8tU1vW3xY5zA7bC9dE1fG",
      "deploy_at": "2026-05-17T19:48:00Z",
      "current_mcap": 0,
      "rug_status": "rugged"
    }
  ],
  "result_count": 3,
  "latency_ms": 16
}

interface WhaleTrackerInput {
  min_size_usd?: number;          // default 100000
  token_mint?: string;            // optional filter
  last_minutes?: number;          // default 60
  limit?: number;                 // default 50
}

Show me every swap over $250K in the last 15 minutes.

{
  "results": [
    {
      "wallet": "Cented7y3TgN8rL4pK2mJ9hG6fD3sA1qW5xZ7vY9b",
      "side": "buy",
      "size_usd": 412000,
      "token": "WIF",
      "ca": "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm",
      "dex": "jupiter",
      "at": "2026-05-22T14:44:02Z"
    },
    {
      "wallet": "5HqWxY3zA7bC9dE1fG3hJ5kM8nP2qR4sT6vN9pM2qR5",
      "side": "sell",
      "size_usd": 318000,
      "token": "BONK",
      "ca": "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
      "dex": "raydium",
      "at": "2026-05-22T14:41:18Z"
    },
    {
      "wallet": "Ansem8Lk2qN5pT3rR8sV2vKj7wL3xH9yF6zXcVbNm",
      "side": "buy",
      "size_usd": 284000,
      "token": "POPCAT",
      "ca": "7GCihgDB8fe6KNjn2MYtkzZcRjQy3t9GHdC8uHYmW2hr",
      "dex": "raydium",
      "at": "2026-05-22T14:38:55Z"
    }
  ],
  "result_count": 3,
  "latency_ms": 27
}

interface NewTokenAlertsInput {
  min_initial_liquidity_usd?: number;   // default 5000
  dev_wallet_min_age_days?: number;     // default 0
  limit?: number;                       // default 100
}

Alert me when a new mint launches with >$10K initial
liquidity from a dev wallet at least 30 days old.

{
  "events": [
    {
      "type": "new_mint",
      "token": "ZIGGY",
      "ca": "9pM2qR5xT8vNbKj4wH7sG2yF6zXcVbNm1aQpEdRtYuQp",
      "initial_liquidity_usd": 18400,
      "dev_wallet": "4cD6eF8gH1jK3mN5pQ7rS9tU2vW4xY6zA8bC1dE3f",
      "dev_wallet_age_days": 142,
      "at": "2026-05-22T14:45:01Z"
    },
    {
      "type": "new_mint",
      "token": "FLOPPY",
      "ca": "Cm2pT5qR8sV3vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
      "initial_liquidity_usd": 12100,
      "dev_wallet": "7eF9gH2jK4mN6pQ8rS1tU3vW5xY7zA9bC2dE4fG6h",
      "dev_wallet_age_days": 67,
      "at": "2026-05-22T14:43:48Z"
    }
  ],
  "stream": true,
  "result_count": 2
}

interface LiquidityDepthInput {
  token_mint: string;             // required
  levels?: number;                // default 10, max 50
}

What's the liquidity depth on KERN at the top 10 levels?
I want to size a $40K entry without eating more than 2% slippage.

{
  "token_mint": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
  "mid_price_usd": 0.00041,
  "bids": [
    { "price_usd": 0.000408, "size_usd": 8400, "dex": "raydium" },
    { "price_usd": 0.000404, "size_usd": 12200, "dex": "raydium" },
    { "price_usd": 0.000401, "size_usd": 6800, "dex": "orca" }
  ],
  "asks": [
    { "price_usd": 0.000412, "size_usd": 9100, "dex": "raydium" },
    { "price_usd": 0.000416, "size_usd": 14800, "dex": "raydium" },
    { "price_usd": 0.000420, "size_usd": 7200, "dex": "jupiter" }
  ],
  "depth_2pct_buy_usd": 31100,
  "depth_2pct_sell_usd": 27600,
  "latency_ms": 19
}

interface HolderDistributionInput {
  token_mint: string;             // required
  snapshot_at?: string;           // ISO 8601 or slot number
}

How has the holder distribution on KERN evolved
in the last 24 hours? Plot the top-10% over time.

{
  "token_mint": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
  "snapshot_at": "2026-05-22T14:45:00Z",
  "top_pcts": {
    "top_10": 38.2,
    "top_50": 71.4,
    "top_100": 84.9
  },
  "distribution_curve": [
    { "bucket_usd": "0-100",      "holders": 84 },
    { "bucket_usd": "100-1000",   "holders": 62 },
    { "bucket_usd": "1000-10000", "holders": 28 },
    { "bucket_usd": "10000+",     "holders": 10 }
  ],
  "holder_count_history": [
    { "at": "2026-05-21T14:45:00Z", "holders": 12 },
    { "at": "2026-05-21T20:45:00Z", "holders": 47 },
    { "at": "2026-05-22T02:45:00Z", "holders": 98 },
    { "at": "2026-05-22T08:45:00Z", "holders": 141 },
    { "at": "2026-05-22T14:45:00Z", "holders": 184 }
  ],
  "latency_ms": 28
}

Streaming

Subscriptions push events as they happen instead of requiring polling. End-to-end latency: ~400ms from Solana slot finalization to subscriber. Four streams are live today.

• subscribe.solana.new_mint — every fresh SPL mint, regardless of program
• subscribe.solana.swaps.large — DEX swaps over a configurable USD threshold
• subscribe.pumpfun.bonding_complete — pump.fun launches that just graduated to Raydium
• subscribe.kol.recent_buy — every entry from the 1,400+ tracked KOL wallets

Subscribe payload

Inside an MCP client, the agent calls subscribe; push events arrive as MCP notifications, one per matching event, until unsubscribe.

// Agent-side
subscribe({
  stream: "subscribe.kol.recent_buy",
  filters: {
    min_size_usd: 5000,
    wallets: ["Cented7y3TgN8rL4pK2mJ9hG6fD3sA1qW5xZ7vY9b"]
  }
});

Example streamed event

{
  "stream": "subscribe.kol.recent_buy",
  "event": {
    "wallet": "Cented7y3TgN8rL4pK2mJ9hG6fD3sA1qW5xZ7vY9b",
    "token": "KERN",
    "ca": "Hm4qN2pR8sT5vKj7wL3xH9yF6zXcVbNm1aQpEdRtYuQp",
    "side": "buy",
    "size_usd": 12400,
    "dex": "raydium",
    "signature": "5jKvN8mPqR2sT4vXcVbNm1aQpEdRtYuQpHm4qN2pR8s",
    "at": "2026-05-22T14:45:11Z"
  },
  "delivered_at": "2026-05-22T14:45:11.412Z"
}

Raw WebSocket access is available outside MCP for low-level consumers — connect to wss://stream.techkern.xyz/v1 with the same bearer token and send the same payload over the wire.

Rate limits

Limits are enforced per API key, sliding-window over the last rolling day. When you hit a limit the API returns 429 with a Retry-After header. Every response also carries x-ratelimit-remaining and x-ratelimit-reset so you can build proactive backoff.

429 retry semantics

Retry-After is always in seconds. The recommended client behavior is exponential backoff with full jitter, capped at 60s. The official SDKs handle this automatically:

HTTP/1.1 429 Too Many Requests
Retry-After: 7
x-ratelimit-remaining: 0
x-ratelimit-reset: 1716345607
Content-Type: application/json

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Daily limit reached for plan 'hobby'.",
    "retry_after_seconds": 7
  }
}

Errors

Standard HTTP status codes. The body is always JSON with an error object describing what went wrong and what to do next.

Example error body

{
  "error": {
    "code": "shard_offline",
    "message": "Indexer shard 'holders' is rebalancing. Re-route in progress.",
    "shard": "holders",
    "retry_after_seconds": 15,
    "request_id": "req_4f8c2a1d9b3e7h2k"
  }
}

SDKs

Official SDKs for Node, Python, and Rust. Each wraps the same REST + WebSocket surface and handles auth, retries, and streaming. Source on GitHub: github.com/kern-tech/techkern.

Node

import { TechKernClient } from "@techkern/sdk";

const client = new TechKernClient({ apiKey: process.env.TECHKERN_API_KEY! });
const swaps = await client.querySolanaSwaps({ last_minutes: 5, min_volume_usd: 100000 });
console.log(swaps.results);

Python

from techkern import Client

client = Client(api_key=os.environ["TECHKERN_API_KEY"])
swaps = client.query_solana_swaps(last_minutes=5, min_volume_usd=100_000)
print(swaps["results"])

Rust

use techkern::Client;

let client = Client::new(std::env::var("TECHKERN_API_KEY")?);
let swaps = client.query_solana_swaps()
    .last_minutes(5)
    .min_volume_usd(100_000)
    .send().await?;
println!("{:#?}", swaps.results);

Recipes

Real prompts to drop into any MCP-aware agent. Each shows the literal Claude prompt, the tool invocation it triggers under the hood, and the expected response shape.

Memecoins with high volume and dev still in

Prompt:
> Find Solana memecoins with >$100K volume in the last 5 min
  where the dev still holds >50%.

Triggers:
techkern.query_solana_swaps({
  last_minutes: 5,
  min_volume_usd: 100000,
  where: { dev_hold_pct: { gt: 50 } }
})

Response shape:
{ results: [{ token, ca, volume_usd, dev_hold_pct, dex }], result_count }

Pump.fun mints from fresh dev wallets

Prompt:
> Track every new pump.fun mint where the dev wallet is <7 days old.

Triggers:
techkern.new_token_alerts({
  min_initial_liquidity_usd: 1000,
  dev_wallet_min_age_days: 0
})
↓ filter client-side: dev_wallet_age_days < 7

Response shape:
{ events: [{ token, ca, dev_wallet, dev_wallet_age_days, at }], stream: true }

Recent buys of a specific wallet with PnL

Prompt:
> Show me the last 20 buys of wallet Cented7y3Tg...vY9b with PnL deltas.

Triggers:
techkern.whale_tracker({
  last_minutes: 1440,
  limit: 20
})
↓ filter: wallet == "Cented7y3TgN8rL4pK2mJ9hG6fD3sA1qW5xZ7vY9b"
↓ enrich each with: techkern.holder_distribution(ca) for current price

Response shape:
{ results: [{ wallet, side, size_usd, token, ca, dex, at }] }

Alert on large KOL buys

Prompt:
> Alert me when any KOL wallet I track buys >$10K of any token
  in the last hour.

Triggers:
techkern.subscribe({
  stream: "subscribe.kol.recent_buy",
  filters: { min_size_usd: 10000 }
})

Event shape:
{ stream, event: { wallet, token, ca, side, size_usd, dex, at } }

Pre-trade rug screen in one call

Prompt:
> Before I buy KERN, give me the full safety check —
  mint authority, holder concentration, dev history.

Triggers (in parallel):
techkern.mint_authority_check({ token_mint: "Hm4q...YuQp" })
techkern.holder_distribution({ token_mint: "Hm4q...YuQp" })
techkern.dev_token_history({ wallet: "<dev from mint_authority_check>" })

Synthesized response:
- is_renounced: true ✓
- top_10_pct: 38.2% (acceptable)
- dev history: 1 active, 0 rugs → low risk

FAQ

Is techkern compliant with MCP spec v1.0?

Yes. Verified against Claude Desktop, Cursor, Cline, Continue, Zed, the OpenAI Agents SDK, and the official MCP TypeScript + Python reference clients. Tool schemas pass mcp-validator --strict.

Can I self-host?

On the Scale plan, yes — single-tenant deployment with your own Helius keys and ClickHouse cluster. Contact hello@techkern.xyz for the deployment kit and license terms.

Does this work with Anthropic API tool use (non-MCP)?

Yes — every tool is also exposed as a plain REST endpoint, and we ship a tool-use bridge that translates Anthropic tools definitions into REST calls. See the bridge example at examples/anthropic-bridge.

What about Solana network upgrades?

The indexer auto-syncs to new program IDs as they roll out (Token-2022, ALT activations, new DEX program upgrades). Last 12 months: 99.96% uptime across the four shards. See /status for live SLO history.

Can I get historical data?

Yes — pass snapshot_at (ISO timestamp or slot number) on any compatible tool. Retention: Hobby 7 days, Pro 90 days, Scale unlimited. Bulk historical exports (CSV / Parquet) ship from the dashboard for Pro and Scale.

How is data freshness guaranteed?

The indexer subscribes to every Solana slot via Helius gRPC plus Jito MEV bundles. End-to-end pipeline: slot finalization → parse → ClickHouse insert in ~400ms (p95). Query lag from insert to read is <500ms p95.

What about Jito MEV data?

Jito bundles are tracked as a separate event type. Every swap response carries a jito_bundle_id field when the transaction was bundled, and a dedicated subscribe.jito.bundles stream is in beta — ask in the discussions for access.

Is there a free tier?

Yes — Hobby is 1,000 queries/day, no card required. Sign in with a Solana wallet or email and you get a tk_live_ key immediately. Upgrade to Pro ($49/mo) when you outgrow it.