Helius MCP: AI-Powered Solana Development Documentation

Connect AI tools directly to Helius Solana API documentation for intelligent code generation and contextual development assistance.

AI-Native Development: The Helius MCP server gives AI tools direct access to our documentation and API specifications, enabling contextual code generation and intelligent assistance.

What is MCP?

Model Context Protocol (MCP) is an open standard that creates standardized connections between AI applications and external services like documentation. The Helius MCP server automatically exposes tools for AI applications to search our documentation and interact with our APIs.

Real-time Context

AI tools can search live documentation and API specifications for accurate, up-to-date information

Code Generation

AI generates working code examples using current API methods and best practices from our docs

Interactive Development

Ask questions about Helius APIs and get contextual answers based on our documentation

Seamless Integration

Works with popular AI-powered IDEs and development tools

How Helius MCP Works

The Helius MCP server is automatically generated and hosted at https://docs.helius.dev/mcp, providing AI tools with access to:

• Complete API Documentation: All Helius API methods, parameters, and examples
• Search Capabilities: Query any part of our documentation for specific information
• Code Examples: Working implementations for common use cases
• Best Practices: Recommended patterns for using Helius services
• Real-time Updates: Always current with the latest documentation changes

Automatic Generation: Our MCP server is automatically generated from our documentation and API specifications, ensuring it’s always up-to-date with the latest features and changes.

Getting Started

1. Choose Your AI Tool

   Make sure your AI tool supports MCP. Popular options include:

   • Cursor: Built-in MCP support
   • Windsurf: Native MCP integration
   • Claude Desktop: MCP server support
   • VS Code: via MCP extensions
2. Connect to Helius MCP Server

   Add the Helius MCP server URL to your AI tool:

   https://docs.helius.dev/mcp
   

   Each tool has different configuration methods - see the specific instructions below for your AI tool.

3. Start Using AI with Helius Context

   Once connected, start asking questions about Helius APIs. The AI will automatically search our MCP server for accurate, contextual documentation to help generate code.

Connection Instructions

Choose your AI tool and follow the specific setup instructions:

Cursor

1. Open Cursor IDE
2. Use the contextual menu (see below) or manually add the MCP server:
   • Open Settings → MCP Servers
   • Add server URL: https://docs.helius.dev/mcp
3. Open Agent mode (Ctrl/Cmd + K)
4. Ask: “Write a Node.js script for sending transactions using Helius”
5. The AI will search our documentation via MCP to generate accurate code

Contextual Menu Integration

For quick access, use the contextual menu available on any page of our documentation:

• Copy MCP server URL: Copies https://docs.helius.dev/mcp to your clipboard
• Connect to Cursor: Automatically installs the MCP server in Cursor
• Connect to VS Code: Automatically installs the MCP server in VS Code

The contextual menu provides the easiest way to connect to our MCP server. Look for the menu icon in the top-right corner of any documentation page.

Use Cases

Rapid Prototyping

Scenario: You need to quickly build a demo that fetches NFT data and displays it.

With MCP: Ask your AI tool “Create a React component that fetches and displays NFTs for a wallet using Helius DAS API”

Result: Get a complete component with proper error handling, loading states, and current API usage.

API Integration

Scenario: Integrating Helius websockets into your application.

With MCP: “Show me how to set up Helius websockets for monitoring account changes”

Result: Complete websocket setup code with proper connection handling and real-time updates.

Documentation Generation

Scenario: Need to document your Helius integration for your team.

With MCP: “Generate documentation for our Helius RPC usage patterns”

Result: Comprehensive docs with code examples and best practices.

Debugging & Optimization

Scenario: Your Helius API calls are failing or performing poorly.

With MCP: “Help me optimize these Helius API calls and handle errors properly”

Result: Improved code with proper error handling and performance optimizations.

Example Workflows

Building a Transaction Monitor

// Ask your AI: "Create a transaction monitor using Helius websockets"
// The AI will generate something like this with current API patterns:

const WebSocket = require('ws');

// Create WebSocket connection
const ws = new WebSocket('wss://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY');

ws.on('open', function open() {
  console.log('WebSocket connected');
  
  // Subscribe to account changes
  const request = {
    jsonrpc: "2.0",
    id: 1,
    method: "accountSubscribe",
    params: [
      "YOUR_WALLET_ADDRESS",
      {
        encoding: "jsonParsed",
        commitment: "confirmed"
      }
    ]
  };
  
  ws.send(JSON.stringify(request));
});

ws.on('message', function incoming(data) {
  const message = JSON.parse(data.toString());
  console.log('Account update:', message);
});

NFT Portfolio Tracker

// Ask: "Build an NFT portfolio tracker using Helius DAS API"
// Get working code with current method signatures:

const getNFTPortfolio = async (walletAddress: string) => {
  const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 'my-id',
      method: 'getAssetsByOwner',
      params: {
        ownerAddress: walletAddress,
        page: 1,
        limit: 1000
      },
    }),
  });
  
  const data = await response.json();
  return data.result;
};

Advanced Features

Context-Aware Suggestions

The MCP server provides documentation context so AI tools can make intelligent suggestions:

• API Method Selection: AI recommends the most appropriate Helius API based on our docs
• Error Handling: AI suggests proper error handling patterns from our documentation
• Performance Tips: AI identifies optimization opportunities using our best practices

Supported AI Tools

Tool	Support Level	Setup Difficulty	Best For
Cursor	✅ Native	Easy	Full-stack development
Windsurf	✅ Native	Easy	AI-assisted coding
Claude Desktop	✅ Supported	Medium	Documentation and planning
VS Code	⚠️ Extension Required	Medium	Existing VS Code workflows

Best Practices

Be Specific

Ask specific questions like “How do I paginate through NFT results?” rather than “Help with NFTs”

Include Context

Mention your tech stack: “Using Next.js and TypeScript, show me how to…”

Iterate Quickly

Use the generated code as a starting point and ask for modifications

Test Generated Code

Always test AI-generated code in your development environment

Troubleshooting

MCP Server Connection Issues

Issue: AI tool can’t connect to the Helius MCP server

Solution:

1. Verify the MCP server URL is correct: https://docs.helius.dev/mcp
2. Check your internet connection
3. Restart your AI tool and try reconnecting
4. Ensure your AI tool supports MCP (check tool documentation)

Search Tool Only Available

Issue: Only the search tool appears, no API endpoints

Solution:

1. This is expected - our MCP server exposes documentation search capabilities
2. API endpoints are accessed through the search tool when the AI needs specific information
3. The search tool provides access to all our documentation and API specifications

Outdated Information

Issue: AI is providing outdated API information

Solution:

1. The MCP server auto-updates with our documentation
2. Refresh your AI session or restart the tool
3. Ask specifically for “the latest” information about the API
4. Verify you’re connected to the correct MCP server URL

Generated Code Doesn't Work

Issue: AI-generated code has errors or doesn’t run

Solution:

1. Share the error message with the AI for debugging
2. Ask the AI to search for specific error handling patterns
3. Verify your API key and network connectivity
4. Ask for working examples from our documentation

Contextual Menu Not Working

Issue: Can’t find or use the contextual menu

Solution:

1. Look for the menu icon in the top-right corner of documentation pages
2. Ensure you’re viewing the documentation in a supported browser
3. Manually copy the MCP server URL: https://docs.helius.dev/mcp
4. Configure your AI tool manually using the connection instructions above

Learn More

MCP Specification

Learn about the Model Context Protocol standard

Helius APIs

Explore all available Helius APIs and endpoints

SDK Documentation

Official SDKs for different programming languages

Join Discord

Get help from our developer community

Ready to supercharge your development workflow? Connect to the Helius MCP server and start building with AI assistance today!