> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orbitflare.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

> Build AI agents on OrbitFlare. Skills, MCP server, CLI, and SDK: everything an agent needs to query Solana, stream data, and manage an OrbitFlare account.

OrbitFlare ships a complete agent surface for Solana. Drop a skill into Claude Code or Cursor, wire up the MCP server in any compatible host, script the CLI from a shell, or call the Rust SDK directly. All four talk to the same Shredstream-optimized RPC, gRPC streaming, and Customer API.

<Tip>
  **Start with the MCP server.** It exposes 53 typed tools that cover RPC reads, streaming config, account management, billing, swaps, and on-chain wallet operations, and it works in Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Gemini CLI, and Codex CLI out of the box.
</Tip>

## What's available

<CardGroup cols={2}>
  <Card title="Skills" icon="sparkles" href="/agents/skills">
    Drop-in instruction sets that teach Claude Code, Cursor, and Codex how to use OrbitFlare correctly: RPC, streaming, dedicated nodes, trading APIs, CLI, and SDK in one skill.
  </Card>

  <Card title="MCP Server" icon="plug" href="/agents/mcp">
    53 tools across RPC, streaming, billing, swaps, staking, and wallet ops. Works in any MCP-compatible host. Includes auth flows, top-up, and live docs as resources.
  </Card>

  <Card title="CLI" icon="terminal" href="/agents/cli">
    Single binary for streaming, querying, scaffolding, and account management. Every command supports `--json` so output is parseable in shell scripts and CI/CD.
  </Card>

  <Card title="Rust SDK" icon="rust" href="/agents/sdk">
    Typed Rust clients for RPC, WebSocket, Yellowstone gRPC, and Jetstream. Built-in retry, failover, and reconnection. Reads endpoints from environment variables.
  </Card>
</CardGroup>

## Skill vs MCP vs CLI vs SDK

Pick the surface that matches the workflow:

| Surface   | Best for                                                           | When to reach for it                                                                                                             |
| --------- | ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
| **Skill** | Coding agents (Claude Code, Cursor, Codex) writing OrbitFlare code | You want the agent to **write** correct OrbitFlare code (endpoint URLs, gRPC filters, SDK setup) without you fetching docs first |
| **MCP**   | Agents that need to **call** OrbitFlare directly from chat         | You want the agent to query balances, send txs, build streaming configs, or manage your account interactively                    |
| **CLI**   | Shell scripts, CI/CD, terminal automation                          | You're writing bash, GitHub Actions, or cron jobs, and `--json` output composes cleanly with `jq` and shell pipes                |
| **SDK**   | Production Rust services                                           | You're building a long-running daemon, indexer, or trading bot and want type-safe access with retry/failover baked in            |

<Note>
  Skills and MCP are complementary. Install both: the skill teaches the agent *how* OrbitFlare works; the MCP server lets it actually call OrbitFlare without leaving the chat.
</Note>

## Recommended setup

The fastest path for a coding agent on Solana:

<Steps>
  <Step title="Get an API key">
    Sign up at [orbitflare.com](https://orbitflare.com) and copy your license key from the **Licenses** section. The Free plan gives you 10 RPS / 1 TPS forever.
  </Step>

  <Step title="Install the skill">
    ```bash theme={null}
    npx @orbitflare/skills@latest      # Claude Code (personal)
    ```

    See [Skills](/agents/skills) for Cursor, Codex, and project-scoped installs.
  </Step>

  <Step title="Install the MCP server">
    Add to your host's MCP config:

    ```json theme={null}
    {
      "mcpServers": {
        "orbitflare": {
          "command": "npx",
          "args": ["@orbitflare/mcp@latest"],
          "env": {
            "ORBITFLARE_API_KEY": "your-license-key",
            "ORBITFLARE_NETWORK": "mainnet"
          }
        }
      }
    }
    ```

    See [MCP Server](/agents/mcp) for per-host file paths and the Codex CLI TOML variant.
  </Step>

  <Step title="Restart your host">
    Restart Claude Code (or your host of choice) so it picks up the new skill and MCP server.
  </Step>

  <Step title="Try a prompt">
    > "Stream pump.fun trades using OrbitFlare Jetstream from Frankfurt"

    > "What is the SOL balance of `Gh9ZwEm…`? Then show me the last 20 transactions for that address."

    > "Quote 1 SOL → USDC with 0.3% slippage and build me a Yellowstone config to watch the pool."
  </Step>
</Steps>

## Common workflows

| Goal                     | Surfaces to use                                                                                     |
| ------------------------ | --------------------------------------------------------------------------------------------------- |
| Build a trading bot      | **MCP** for prototyping in chat → **Rust SDK** for the production daemon                            |
| Stream real-time data    | **MCP** `subscribeTransactions` to generate the YAML config → **CLI** `orbitflare stream` to run it |
| Index historical data    | **Skill** to learn `getTransactionsForAddress` and the archive endpoint → **SDK** for the indexer   |
| Manage account / billing | **MCP** auth flows + `prepareTopUp` / `confirmTopUp` from chat                                      |
| Quote a swap             | **MCP** `getSwapQuote` (Jupiter Metis routing, auto-resolves SOL/USDC/USDT symbols)                 |
| CI / scripted automation | **CLI** with `--json` flag piped into `jq`                                                          |

## Source code

Everything is open source:

* Skills: [github.com/orbitflare/orbitflare-skills](https://github.com/orbitflare/orbitflare-skills)
* MCP server: [github.com/orbitflare/orbitflare-mcp](https://github.com/orbitflare/orbitflare-mcp)
* CLI: [github.com/orbitflare/orbit-cli](https://github.com/orbitflare/orbit-cli)
* Rust SDK: [github.com/orbitflare/orbitflare-sdk-rs](https://github.com/orbitflare/orbitflare-sdk-rs)

The agent surfaces are derived from the same source of truth: [docs.orbitflare.com/llms.txt](https://docs.orbitflare.com/llms.txt). Point any agent at that index when you want it to ground answers in the official docs.