Orquestra: upload a Solana IDL, get a REST API, AI docs, and an MCP server

We published a piece this morning about why Solana interfaces live in IDL files rather than inline ABI strings. The upside of that design is that the IDL is a complete, machine-readable description of a program: instructions, account lists, PDA seeds, types, events, errors. Which raises an obvious question: if the file already describes everything, why does anyone hand-write a backend to expose it?

Orquestra is the most direct answer to that question we've seen. Upload an IDL and it hosts the rest: REST endpoints for every instruction and account type, AI-readable documentation, and a live MCP server your agents can call. It's free, MIT-licensed, fully open source, and built by Berkay Oztunc, a developer in the Superteam Turkiye orbit.

What you get from one upload

Point Orquestra at an Anchor or Codama IDL (paste it, or let the CLI discover it on-chain) and it generates:

• REST endpoints for instructions, accounts, program account queries, errors, events, types, and docs, with IDL versioning as your program evolves.
• An unsigned transaction builder. HTTP clients and agents can construct real instructions with cluster-aware blockhash lookup, then optionally run a preflight simulation that decodes Anchor errors into readable messages.
• PDA tooling. Discovery, derivation from seeds, single-account decoding, and program-owned account queries with dataSize and memcmp filters. On Helius RPC URLs it upgrades to getProgramAccountsV2 automatically and paginates large account sets.
• AI-ready docs. Every public project gets an llms.txt, the same convention we use for devrels.xyz itself, so agents can read your program's surface without scraping.
• A public MCP server. One endpoint, https://api.orquestra.dev/mcp, exposes the whole platform to AI agents over streamable HTTP.

The MCP surface

The MCP server publishes ten tools: search_programs, list_instructions, build_instruction, simulate_instruction, list_pda_accounts, derive_pda, read_llms_txt, get_ai_analysis, fetch_pda_data, and get_program_data. Wiring it into Claude Code takes four lines:

{
  "mcpServers": {
    "orquestra": {
      "type": "http",
      "url": "https://api.orquestra.dev/mcp"
    }
  }
}

We probed the endpoint while writing this: it speaks MCP protocol 2025-03-26 over streamable HTTP and responds as orquestra 1.0.0. The interesting design choice is that this is one shared server for every registered program, not a per-program deployment. Your agent searches for a program, lists its instructions, derives the PDAs, builds the transaction, and simulates it, all through the same connection. Program lists with MCP scope keys let you narrow what an agent sees.

The trust model, honestly

Any hosted service that builds transactions for you deserves a clear-eyed look, so here is Orquestra's shape. It builds unsigned transactions only; keys never leave your side, and nothing moves without your signature. The platform is open source end to end (TypeScript monorepo: React dashboard, Hono API and MCP server on Cloudflare Workers with D1 and KV), so you can audit what the builder does, or self-host the whole thing with bun install and a migration script. Recent commits added verified-build gated ingest: program registration checks OSEC verified-build status, which raises the floor on what ends up in the shared registry. The standard discipline still applies: decode and inspect any unsigned transaction before signing it, whichever service built it.

The companion CLI

orquestra-cli is a Rust tool for the local half of the workflow: discovering programs and IDLs on-chain, ingesting them into the API, and driving API-backed workflows from the terminal. The recent funnel command gates bulk ingest on verified builds, which is how the registry gets populated without turning into a dumping ground.

Where it fits

Codama answers "how do I get a typed client in my codebase" (see our Codama deep-dive). Orquestra answers a different question: "how does something that isn't my codebase call my program?" A partner integrating over HTTP without touching Rust or TypeScript SDKs. An AI agent that needs tools, not libraries. A quick internal dashboard that just wants GET /accounts?dataSize=.... For programs you don't control, the combination of on-chain IDL discovery and the shared MCP registry makes it a practical explorer for agents, an angle we last saw from the ProofNetwork MCP server, here generalized to any program with an IDL.

It's a young project (the repo went public this month), so treat it as early and moving fast. But the idea is exactly right: the IDL already is the API spec. Orquestra just serves it.

Resources

• orquestra.dev, the hosted platform
• github.com/berkayoztunc/orquestra, the MIT-licensed monorepo (frontend, Workers API, MCP server, docs)
• github.com/berkayoztunc/orquestra-cli, the Rust companion CLI
• @whitemoondev, the author
• Related reading: Where is Solana's ABI? and Codama client generation