Skip to main content
Glama
biccsdev

Solana Debug MCP

by biccsdev
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

Solana Debug MCP

Solana Debug MCP is a Model Context Protocol server for inspecting and debugging Solana transactions, accounts, Anchor IDLs, Anchor errors, and Program Derived Addresses from MCP-compatible clients.

This project is ready for local production-style MCP use over stdio. It can simulate base64 or base58 serialized Solana transactions, inspect account metadata, inspect legacy and versioned transaction instructions, fetch on-chain Anchor IDLs, decode supported Anchor account and instruction fields, look up built-in and IDL-provided Anchor errors, and derive PDAs.

Features

  • simulate_transaction: Simulate a serialized Solana transaction through an RPC endpoint and summarize logs.

  • decode_account: Fetch account metadata and decode supported Anchor account fields when an IDL is supplied or fetchable.

  • decode_instruction: Inspect legacy/versioned instructions and decode supported Anchor instruction args when an IDL is supplied or fetchable.

  • anchor_error_lookup: Look up common Anchor framework errors and custom IDL errors.

  • pda_verify: Derive a PDA from seeds and check whether the account exists on chain.

Related MCP server: SOLANA-MCP-Server

Current Limitations

  • Hosted HTTP/SaaS transport is not implemented; current production target is local stdio MCP.

  • IDL enum decoding and some unusual Anchor IDL shapes are not implemented yet.

  • pda_verify supports typed seeds. Plain string seeds are still accepted as UTF-8 for backward compatibility.

  • Error analysis is deterministic log pattern matching, not AI-generated analysis.

Requirements

  • Node.js 20 or newer

  • pnpm 10 or newer

  • A Solana RPC endpoint

  • Optional Helius API key for mainnet RPC

Installation

pnpm install
pnpm run build

For local development:

pnpm run dev

For production-style local execution:

pnpm start

Configuration

Create a .env file from the example:

cp .env.example .env

Supported environment variables:

# Optional. If set, the server uses Helius mainnet RPC by default.
HELIUS_API_KEY=your-helius-api-key

# Optional fallback RPC URL when HELIUS_API_KEY is not set.
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com

# Documented for future cluster-aware IDL fetching. Currently unused.
SOLANA_CLUSTER=mainnet-beta

RPC precedence in the current implementation:

  1. Tool-level rpc_url, where supported

  2. HELIUS_API_KEY, if set

  3. SOLANA_RPC_URL

  4. https://api.mainnet-beta.solana.com

Claude Desktop Setup

Build the project first:

pnpm run build

Then add the server to your Claude Desktop configuration.

macOS path:

~/Library/Application Support/Claude/claude_desktop_config.json

Example configuration:

{
  "mcpServers": {
    "solana-debug": {
      "command": "node",
      "args": ["/absolute/path/to/solanaDebug/dist/index.js"],
      "env": {
        "HELIUS_API_KEY": "your-helius-api-key",
        "SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com"
      }
    }
  }
}

Restart Claude Desktop after editing the config.

Other Client Config Examples

All examples assume you already ran:

pnpm install
pnpm run build

Replace /absolute/path/to/solanaDebug with your local checkout path. Prefer passing secrets through the client config or process environment instead of committing them to source control.

Codex

Codex reads MCP servers from ~/.codex/config.toml.

[mcp_servers.solana-debug]
command = "node"
args = ["/absolute/path/to/solanaDebug/dist/index.js"]
startup_timeout_sec = 10
tool_timeout_sec = 60

[mcp_servers.solana-debug.env]
HELIUS_API_KEY = "your-helius-api-key"
SOLANA_RPC_URL = "https://api.mainnet-beta.solana.com"

If you keep .env in the project root, you can omit the env table and set cwd so the server loads the local .env file:

[mcp_servers.solana-debug]
command = "node"
args = ["dist/index.js"]
cwd = "/absolute/path/to/solanaDebug"
startup_timeout_sec = 10
tool_timeout_sec = 60

VS Code

VS Code can use a workspace .vscode/mcp.json or user-level MCP config.

{
  "servers": {
    "solana-debug": {
      "type": "stdio",
      "command": "node",
      "args": ["/absolute/path/to/solanaDebug/dist/index.js"],
      "env": {
        "HELIUS_API_KEY": "your-helius-api-key",
        "SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com"
      }
    }
  }
}

For a workspace-local setup:

{
  "servers": {
    "solana-debug": {
      "type": "stdio",
      "command": "node",
      "args": ["dist/index.js"],
      "cwd": "/absolute/path/to/solanaDebug"
    }
  }
}

Hermes Agent

Hermes Agent uses mcp_servers in its YAML config. Hermes intentionally filters environment variables for stdio servers, so include any RPC secrets explicitly.

mcp_servers:
  solana-debug:
    command: "node"
    args:
      - "/absolute/path/to/solanaDebug/dist/index.js"
    env:
      HELIUS_API_KEY: "your-helius-api-key"
      SOLANA_RPC_URL: "https://api.mainnet-beta.solana.com"
    enabled: true
    timeout: 120
    connect_timeout: 60
    tools:
      resources: false
      prompts: false

OpenClaw

OpenClaw-managed MCP servers can be configured under mcp.servers. If sandbox tool filtering is enabled, allow MCP plugin tools via bundle-mcp or group:plugins.

{
  mcp: {
    servers: {
      "solana-debug": {
        command: "node",
        args: ["/absolute/path/to/solanaDebug/dist/index.js"],
        env: {
          HELIUS_API_KEY: "your-helius-api-key",
          SOLANA_RPC_URL: "https://api.mainnet-beta.solana.com",
        },
      },
    },
  },
  tools: {
    sandbox: {
      tools: {
        alsoAllow: ["bundle-mcp"],
      },
    },
  },
}

MCP Tools

simulate_transaction

Simulates a serialized Solana transaction and returns simulation status, logs, units consumed, and pattern-based analysis.

Input:

{
  "transaction": "base64-or-base58-serialized-transaction",
  "rpc_url": "https://api.mainnet-beta.solana.com"
}

Fields:

  • transaction: Required string. Accepts base64 or base58 serialized legacy or versioned transaction bytes.

  • rpc_url: Optional string. Overrides environment RPC defaults for this call.

Output shape:

{
  "ok": true,
  "data": {
    "success": false,
    "error_code": "custom program error...",
    "error_message": "Transaction simulation failed",
    "transaction_type": "legacy",
    "encoding": "base64",
    "logs": [],
    "analysis": "Pattern-based explanation"
  }
}

Implementation:

  • Registered in src/index.ts.

  • Handler is simulateTransaction in src/tools/simulate.ts.

  • RPC call is made by RPCService.simulateTransaction in src/services/rpc.ts.

  • Log summary is generated by generateAnalysis in src/services/analyzer.ts.

decode_account

Fetches basic account information from RPC.

Input:

{
  "address": "account-public-key",
  "program_id": "expected-owner-program-id"
}

Fields:

  • address: Required account public key.

  • program_id: Required expected owner program ID. The response reports whether it matches the fetched account owner.

Output shape:

{
  "ok": true,
  "data": {
    "address": "account-public-key",
    "program_id": "expected-owner-program-id",
    "owner_matches_program_id": true,
    "account_type": "unknown",
    "data": {
      "lamports": 1000000,
      "sol_balance": 0.001,
      "owner": "actual-owner-program-id",
      "executable": false,
      "data_length": 128,
      "note": "Full IDL decoding not yet implemented in MVP. Raw account data available."
    }
  }
}

Implementation:

  • Registered in src/index.ts.

  • Handler is decodeAccount in src/tools/decode.ts.

  • Account fetching is handled by RPCService.getAccountInfo.

  • src/services/idl.ts contains placeholder IDL-service code but is not wired into this tool yet.

decode_instruction

Inspects one or all instructions in a serialized legacy transaction.

Input:

{
  "transaction": "base64-or-base58-serialized-transaction",
  "instruction_index": 0
}

Fields:

  • transaction: Required string. Accepts base64 or base58 serialized legacy or versioned transaction bytes.

  • instruction_index: Optional number. When omitted, all instructions are returned.

Output shape for one instruction:

{
  "ok": true,
  "data": {
    "transaction_type": "legacy",
    "encoding": "base64",
    "instruction": {
      "index": 0,
      "program_id": "program-public-key",
      "accounts": [
        {
          "pubkey": "account-public-key",
          "isSigner": true,
          "isWritable": true
        }
      ],
      "data": "base64-instruction-data",
      "data_length": 16
    }
  }
}

Implementation:

  • Registered in src/index.ts.

  • Handler is decodeInstruction in src/tools/decode.ts.

  • Uses the shared transaction parser in src/services/transaction.ts.

anchor_error_lookup

Looks up a common Anchor framework error by decimal or hexadecimal code.

Input:

{
  "error_code": "0x1771",
  "program_id": "optional-program-id"
}

or:

{
  "error_code": "6001"
}

Fields:

  • error_code: Required string. Accepts decimal, 0x hex, or 0X hex.

  • program_id: Optional string. Used to fetch an on-chain Anchor IDL for custom error lookup when idl is not supplied.

Output shape:

{
  "ok": true,
  "data": {
    "error_code": "0x1771",
    "error_code_decimal": 6001,
    "error_name": "Unknown",
    "description": "Error code not found in Anchor error database",
    "common_causes": ["Custom program error", "Unknown error type"],
    "suggested_fixes": [
      "Check program source code for custom error definitions",
      "Review transaction logs for more context",
      "Verify error code is from Anchor framework"
    ],
    "program_id": "unknown"
  }
}

Implementation:

  • Registered in src/index.ts.

  • Handler and built-in error table are in src/tools/errors.ts.

pda_verify

Derives a Program Derived Address and checks whether the derived account exists.

Input:

{
  "program_id": "program-public-key",
  "seeds": [
    { "type": "utf8", "value": "seed" },
    { "type": "pubkey", "value": "public-key-seed" }
  ]
}

Fields:

  • program_id: Required program public key.

  • seeds: Required array of typed seeds. Supported types are utf8, pubkey, hex, and base64. Plain strings are accepted as UTF-8 seeds for backward compatibility.

Output shape:

{
  "ok": true,
  "data": {
    "address": "derived-pda",
    "bump": 255,
    "exists": true,
    "program_id": "program-public-key",
    "seeds": [{ "type": "utf8", "value": "seed" }],
    "account_data": {
      "lamports": 1000000,
      "owner": "owner-public-key",
      "data_length": 128
    }
  }
}

Implementation:

  • Registered in src/index.ts.

  • Handler is pdaVerify in src/tools/pda.ts.

  • PDA derivation uses PublicKey.findProgramAddressSync.

  • Account lookup uses RPCService.getAccountInfo.

Project Structure

src/
├── index.ts                 MCP server entry point and tool registration
├── tools/
│   ├── simulate.ts          simulate_transaction handler
│   ├── decode.ts            decode_account and decode_instruction handlers
│   ├── errors.ts            anchor_error_lookup handler and error table
│   └── pda.ts               pda_verify handler
├── services/
│   ├── rpc.ts               Solana RPC wrapper
│   ├── transaction.ts       Shared transaction parser and instruction views
│   ├── idl.ts               Placeholder IDL fetching and decoding service
│   └── analyzer.ts          Transaction log pattern matching
└── utils/
    └── types.ts             Shared result helpers and interfaces

Development Workflow

Install dependencies:

pnpm install

Run the server from TypeScript:

pnpm run dev

Typecheck and build:

pnpm run typecheck
pnpm run build

Run tests:

pnpm test

Run the opt-in live RPC smoke test:

pnpm run test:live

This uses your configured .env or process environment and reaches the configured Solana RPC provider.

Run the built server:

pnpm start

Clean generated output:

pnpm run clean

Implementation Notes

Adding a Tool

  1. Add the handler under src/tools/.

  2. Define its Zod schema near the handler.

  3. Register it with server.tool(...) in src/index.ts.

  4. Return MCP-compatible text content with createResult or createErrorResult.

  5. Add tests for valid input, invalid input, and RPC failure behavior.

Returning Results

Tools return:

{
  content: [{ type: "text", text: "..." }]
}

JSON payloads are currently serialized into the text field. Success responses use { "ok": true, "data": ... }; failures use { "ok": false, "error": "..." }.

RPC Access

RPCService wraps @solana/web3.js Connection creation and common calls. New RPC-backed features should be added there when they are reusable by multiple tools.

IDL Decoding

src/services/idl.ts supports Anchor IDL fetching and decoding:

  • On-chain Anchor IDL address derivation.

  • Inflating and parsing on-chain Anchor IDL account data.

  • Account and instruction discriminator matching.

  • Primitive fields: bool, u8, i8, u16, i16, u32, i32, u64, i64, string, bytes, publicKey, and pubkey.

  • Complex fields: option, vec, fixed arrays, and nested defined structs.

  • Custom IDL errors through anchor_error_lookup.

IDL support should still add enum decoding and broader fixture coverage for unusual Anchor IDL shapes.

Troubleshooting

Unable to parse transaction

The transaction field must be a serialized Solana transaction encoded as base64 or base58. JSON transaction objects and signatures are not accepted.

RPC timeouts or rate limits

Set HELIUS_API_KEY or SOLANA_RPC_URL in .env. The RPC wrapper has retry and timeout handling, but persistent rate limits require a better RPC provider or a dedicated key.

.env is not loading

The server loads .env from the current working directory. Start the server from the project root, or pass environment variables through your MCP client config.

Live RPC smoke test is skipped

This is expected. Run it explicitly:

pnpm run test:live

Contributing

  1. Add or update tests first.

  2. Run pnpm run typecheck.

  3. Run pnpm test.

  4. Keep MCP tool outputs structured as { "ok": true, "data": ... } or { "ok": false, "error": "..." }.

  5. Keep network tests opt-in unless they use mocked RPC.

Testing Status

The project has a focused Node test suite for transaction parsing, instruction inspection, Anchor error lookup, and structured errors. More unit and integration coverage is still needed before production use. See PRODUCTION_PLAN.md for the recommended production-readiness checklist.

Production Status

This project is production-ready for local stdio MCP usage. Hosted HTTP/SaaS deployment is not implemented.

Security

See SECURITY.md. Do not commit .env files or private RPC keys. Serialized transactions and account addresses may be sent to the configured RPC provider.

Release

See RELEASE.md for the package release checklist.

Usage Scenarios

See USER_STORIES.md for concrete examples of how Solana developers can use this MCP server.

Testing It Yourself

See TESTING_GUIDE.md for a hands-on path after cloning the repo.

License

MIT

Author

@itsbiccs

Available Tools

5 tools
anchor_error_lookupA

Look up Anchor error codes and get fix suggestions

ParametersJSON Schema
NameRequiredDescriptionDefault
idlNoOptional Anchor IDL containing custom errors
error_codeYesError code in hex (0x1771) or decimal (6001) format
program_idNoOptional program ID to check for custom errors

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It does not disclose whether the tool performs network calls, rate limits, auth requirements, or what happens with invalid codes. Only states the basic function.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, front-loaded with action and object. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite simple schema, description is under-specified. No output schema means description should explain return format (e.g., error details, suggestions). Also no behavioral or usage nuance beyond the one-liner.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers 100% of parameters with useful descriptions (hex/decimal format, optional IDL/program ID). Description adds no extra parameter context, but baseline 3 applies as schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses specific verb 'look up' and specifies resource 'Anchor error codes' with outcome 'fix suggestions'. Clearly distinguishes from sibling tools which are about simulation, decoding, and PDA verification.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Clear context: use for Anchor error codes. No explicit alternatives or exclusions, but sibling tools are sufficiently different that the intended usage is apparent. Slight lack of explicit when-not-to-use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

decode_accountB

Decode Solana account data using program IDL

ParametersJSON Schema
NameRequiredDescriptionDefault
idlNoOptional IDL object (if not provided, will attempt to fetch from chain)
addressYesAccount address to decode
program_idYesProgram ID that owns the account

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core function and omits any details about side effects, network calls (e.g., fetching IDL from chain), permissions, or output format. This leaves significant behavioral uncertainty.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no unnecessary words. It conveys the essential purpose efficiently, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of an output schema and annotations, the description should provide more context, but it does not mention return values, potential errors, or the optional IDL fetching behavior. It is minimally sufficient but lacks depth for an agent to fully anticipate the tool's behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage for all parameters (address, program_id, idl), so the schema already explains their meaning. The description adds no extra parameter semantics beyond what the schema provides, warranting the baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool as decoding Solana account data using program IDL, specifying both the verb ('decode') and the resource ('account data'). This distinguishes it from the sibling tool decode_instruction, which targets instructions rather than account data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when one needs to decode account data, but it does not explicitly state when to use it over alternatives like decode_instruction or simulate_transaction. No exclusions or comparative guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

decode_instructionC

Decode transaction instructions into readable format

ParametersJSON Schema
NameRequiredDescriptionDefault
idlNoOptional Anchor IDL for instruction argument decoding
program_idNoOptional program ID used to fetch an on-chain IDL
transactionYesBase64 or base58 encoded transaction
instruction_indexNoSpecific instruction index to decode (all if omitted)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description must carry the full burden of behavioral disclosure. It only states that it decodes into a readable format, without mentioning any caveats, required dependencies (e.g., IDL/program_id), output structure, or error behavior. This is a minimal disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that immediately conveys the core purpose. It is not verbose, but it could arguably provide a bit more specificity about the output format. Still, it earns its place with no wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Without an output schema or annotations, the description is quite thin for a tool with four parameters. It does not explain what the decoded output looks like, how idl and program_id interact, or any limitations, leaving the agent with incomplete information for successful invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides 100% coverage with descriptions for all four parameters, including the optional idl, program_id, and instruction_index. The tool description adds no additional parameter meaning beyond this, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: decoding transaction instructions into a readable format. It uses a specific verb 'decode' and identifies the resource ('transaction instructions'), which distinguishes it from siblings like simulate_transaction or decode_account, though it does not explicitly name alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as decode_account or simulate_transaction. The description only states what it does, offering no context or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

pda_verifyC

Derive and verify Program Derived Addresses (PDAs)

ParametersJSON Schema
NameRequiredDescriptionDefault
seedsYesArray of typed seeds for PDA derivation
program_idYesProgram ID for PDA derivation

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must fully disclose behavioral traits. It does not mention what the tool returns (e.g., a derived address, a boolean verification result), how errors are handled, or any side effects. The description merely repeats the tool's name-level concept without adding operational details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with zero wasted words. It clearly leads with the verb and resource. Despite being terse, it is appropriately concise and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a cryptographic utility with no output schema and no annotations, the description is far too sparse. It fails to specify return values, seed encoding nuances, error conditions, or whether 'verify' means checking a PDA against given seeds. The absence of an output schema makes the description's silence on outputs a significant gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema covers all parameters with descriptions, giving 100% coverage, so the baseline is 3. The tool description itself adds no parameter-level information. The schema descriptions are minimal but structurally complete; the description does not go beyond them, so the baseline is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Derive and verify') and a clear resource ('Program Derived Addresses'). This distinguishes the tool from its siblings, which all perform different operations (simulate, decode, error lookup). However, it does not explicitly contrast with any sibling tool or elaborate on the 'verify' aspect, preventing a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It simply states the function without mentioning use cases, prerequisites, or exclusions. There is no mention of alternative tools like 'decode_account' or 'simulate_transaction', so the agent receives no contextual direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

simulate_transactionB

Simulate a Solana transaction and return detailed error analysis

ParametersJSON Schema
NameRequiredDescriptionDefault
rpc_urlNoOptional RPC URL (defaults to mainnet)
transactionYesBase64 or base58 encoded transaction

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It mentions returning 'detailed error analysis' but does not clarify whether simulation has side effects (e.g., state changes), what the output format is, or any network/authorization requirements. This is a significant gap for a tool that potentially interacts with the Solana network.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no redundant words. It efficiently communicates the core purpose and returns a clear output concept, earning every word's place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the simple schema (2 params, no output schema), the description lacks important context about what 'detailed error analysis' entails, whether simulation requires a recent blockhash, or if there are any limitations. With no output schema, the description should explain the return format more thoroughly, but it remains vague, leaving the agent underinformed about behavior and edge cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with both rpc_url and transaction having clear descriptions in the schema itself. The description does not add any additional parameter meaning beyond the schema, so a baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Simulate'), the resource ('a Solana transaction'), and the outcome ('return detailed error analysis'). It distinguishes itself from sibling tools like decode_account and anchor_error_lookup by focusing on simulation rather than decoding or lookup.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies a usage scenario (when you need to simulate a transaction and analyze errors) but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. It's a simple definition without comparative guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.5/5.0
Disambiguation5/5

Each tool targets a distinct aspect of Solana debugging: transaction simulation, account data decoding, instruction decoding, error code lookup, and PDA verification. There is no overlap in their core functions.

Naming Consistency4/5

Tool names predominantly follow a verb_noun snake_case pattern (simulate_transaction, decode_account, decode_instruction). The one exception is anchor_error_lookup, which uses a noun_verb ordering but remains clear and consistent in style.

Tool Count5/5

Five tools is an ideal size for a specialized debugging server. Each tool addresses a specific need without redundancy, and the scope is well-defined.

Completeness4/5

The set covers the most common debugging tasks: simulate, decode, lookup errors, and verify PDAs. Minor gaps exist (e.g., fetching raw transaction logs or account history), but the core debugging workflow is well-supported.

Maintenance

ActivityStale
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • onchain-mcp

    sylvainlondon136
    A
    license
    A
    quality
    C
    maintenance
    Provides read-only access to Solana on-chain data, enabling natural language queries for wallet balances, token holdings, prices, transactions, and more via MCP-compatible clients.
    8
    MIT

  • sortie

    srivtx
    A
    license
    Not graded
    quality
    B
    maintenance
    Extends Solana debugging to AI agents via MCP: decode transaction failures, trace CPI trees, and profile compute for any Solana transaction.
    13
    MIT

  • helius-forensics-mcp

    drtiibiird
    A
    license
    Not graded
    quality
    D
    maintenance
    Enables Solana wallet forensics via MCP, including tracing funds, identifying entities, scoring risk, and comparing wallets using Helius APIs.
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/biccsdev/solana_debug_mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server