Developer Tools

Enhance your development workflow with Hyperbolic’s suite of developer tools. Manage GPU instances, run inference, and integrate AI capabilities directly from your terminal or IDE.

Hyperbolic CLI

A developer-first CLI to browse, rent, and manage Hyperbolic GPUs directly from your terminal. Rent on-demand GPU VMs and bare-metal clusters from $1.49 per hour.

Installation

Install the Hyperbolic CLI using Homebrew:

brew install HyperbolicLabs/hyperbolic/hyperbolic

Quick start

# Authenticate with your Hyperbolic account
hyperbolic auth login

# View available commands
hyperbolic --help

Account setup

Before using the CLI, ensure you have:

Created an account at app.hyperbolic.ai and verified your email
Added funds in the Billing section (we recommend starting with $25)
Added your SSH public key in Settings > SSH Public Key

See Account Management for detailed setup instructions.

Commands and examples

Browse On-Demand GPUs
Rent On-Demand VM
Rent Bare Metal
Manage Instances

View available GPUs on the On-Demand GPU platform:

hyperbolic ondemand

Rent a virtual machine with 1, 2, 4, or 8 GPUs (based on availability):

hyperbolic rent ondemand --instance-type virtual-machine --gpu-count 1

Rent a bare metal cluster with InfiniBand networking (multiples of 8 GPUs):

hyperbolic rent ondemand --instance-type bare-metal --network-type infiniband --gpu-count 16

List your active instances:

hyperbolic instances

Terminate an instance:

hyperbolic terminate <instance-id>

VS Code / Cursor extension

Manage GPU instances from Hyperbolic directly within VS Code or Cursor. Create instances, connect via SSH, run Jupyter notebooks, and serve large language models with vLLM - all without leaving your editor.

Why use the extension?

Stay in the flow - Provision powerful GPUs without leaving your workspace
One-click everything - Rent, connect, run Jupyter, and serve models from a unified sidebar
Speed up iterations - Launch an H100 in under 60 seconds and immediately start working

Installation

Install from the On-Demand GPU platform:

VS Code: Search for “Hyperbolic AI Cloud” or visit the VS Code Marketplace
Cursor: Search for “Hyperbolic AI Cloud” in the extensions panel

Prerequisites

Install these required extensions before using Hyperbolic:

Extension	Purpose	Extension ID
Jupyter	Running notebooks	`ms-toolsai.jupyter`
Remote - SSH (VS Code)	SSH connections	`ms-vscode-remote.remote-ssh`
Remote - SSH (Cursor)	SSH connections	`anysphere.remote-ssh`

Configuration

After installation, configure your settings:

Open Settings

Open Command Palette (Ctrl+Shift+P / Cmd+Shift+P) and type “Preferences: Open Settings (UI)”

Search for Hyperbolic

Type “hyperbolic” in the search bar

Configure credentials

Set the following:

API Key - Your Hyperbolic API key
SSH Private Key Path - Path to your SSH private key (e.g., ~/.ssh/id_ed25519)
Hugging Face Token - (Optional) For accessing gated models

Jupyter Notebook support

When creating a new instance, you can expose a port for Jupyter. The extension handles all setup automatically:

Automatic installation of Python and pip if needed
Jupyter Notebook installation and configuration
Port management and process cleanup
Secure access via SSH tunnel or public URL

vLLM model serving

Serve large language models using vLLM directly from your GPU instance. Features:

Model selection - Choose any Hugging Face model compatible with vLLM
Gated model support - Automatic authentication with Hugging Face
Custom tokenizers - Optional tokenizer mode configuration (e.g., “mistral” for Mistral models)
Setup options - Live terminal setup with monitoring or automated setup
Public URLs - Automatic URL generation for API access

How to use:

Select an instance

Select an active GPU instance or create a new one with exposed ports.

Run the command

Open Command Palette and run Hyperbolic: Serve vLLM Model

Configure the model

Enter the Hugging Face model name (e.g., deepseek-ai/DeepSeek-R1-0528)
Configure optional tokenizer mode if needed
Specify if the model is gated (requires HF authentication)
Choose setup method (live terminal or automated)

Use the API

The extension handles all installation and configuration. Once running, access via REST API.

Example API usage:

# Test the server
curl http://your-instance-url/v1/models

# Generate text
curl http://your-instance-url/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "your-model-name",
        "prompt": "San Francisco is a",
        "max_tokens": 7,
        "temperature": 0
    }'

Security settings

The extension provides configurable SSH security options:

{
  "hyperbolic.sshStrictHostKeyChecking": false
}

By default, SSH strict host key checking is disabled for convenience. This means SSH connections automatically accept unknown hosts without verification.

To enable strict checking:

Open VS Code/Cursor settings (Cmd+, or Ctrl+,)
Search for “hyperbolic ssh”
Enable “SSH Strict Host Key Checking”

Recommendations:

Development/testing: Keep disabled for convenience
Production/sensitive work: Enable strict host key checking

Requirements

VS Code 1.85.0 or higher (or compatible Cursor version)
Valid Hyperbolic API key
SSH client installed on your system
SSH private key configured
Jupyter Extension installed
Remote - SSH Extension installed
Python 3.x (installed automatically on remote instances if needed)
Hugging Face account and token (optional, for gated models)

MCP Server

The Hyperbolic MCP Server enables AI agents and LLMs to interact with Hyperbolic’s GPU cloud. Connect Claude Desktop to view and rent available GPUs, SSH into instances, and run GPU-powered workloads autonomously.

Installation

Follow the installation instructions in the GitHub repository.

Running the server

Start the server locally:

npm start

Connecting with Claude Desktop

Add the server to your Claude Desktop configuration:

{
  "mcpServers": {
    "hyperbolic-gpu": {
      "command": "node",
      "args": ["/path/to/hyperbolic-mcp-server/build/index.js"],
      "env": {
        "HYPERBOLIC_API_TOKEN": "your-hyperbolic-api-token",
        "SSH_PRIVATE_KEY_PATH": "/path/to/your/privatekey"
      }
    }
  }
}

After updating the configuration:

Restart Claude Desktop
Start a new conversation
Interact with the server using natural language

You can provide environment variables through the Claude Desktop config (as shown above) or by creating a .env file in the project root.

Available tools

The MCP server provides tools for GPU management and SSH operations.

GPU Management
SSH Tools

list-available-gpusLists all available GPUs on the Hyperbolic network.Example: “Show me all available GPUs on Hyperbolic.”

rent-gpu-instanceRents a GPU instance from a specific cluster.Parameters:

cluster_name - Name of the cluster (e.g., “extrasmall-chamomile-duck”)
node_name - Name of the node (e.g., “prd-acl-msi-02.fen.intra”)
gpu_count - Number of GPUs to rent

Example: “I want to rent 4 GPUs from the extrasmall-chamomile-duck cluster.”

terminate-gpu-instanceTerminates a rented GPU instance.Parameters:

instance_id - ID of the instance to terminate

Example: “Terminate my GPU instance with ID abc123.”

list-user-instancesLists all your active GPU instances.Example: “Show me all my active GPU instances.”

get-cluster-detailsGets detailed information about a specific cluster.Parameters:

cluster_name - Name of the cluster

Example: “Tell me more about the cluster called extrasmall-chamomile-duck.”

ssh-connectEstablishes an SSH connection to a remote server.Parameters:

host - Hostname or IP address
username - SSH username
password - (Optional) SSH password
private_key_path - (Optional) Path to private key
port - (Optional) SSH port (default: 22)

Example: “Connect to my GPU instance at 192.168.1.100 as user admin.”

remote-shellExecutes a command on the connected remote server.Parameters:

command - Command to execute

Example: “Run ‘nvidia-smi’ on the connected server.”

ssh-statusChecks the current SSH connection status.Example: “What’s the status of my SSH connection?”

ssh-disconnectCloses the active SSH connection.Example: “Disconnect from the SSH server.”

Security notes

Commands to rent GPUs will incur charges on your Hyperbolic account. Monitor your usage carefully when using autonomous agents.

The server requires your Hyperbolic API token and optionally an SSH private key
Credentials can be provided through the Claude Desktop config or a .env file
The server runs locally and doesn’t expose credentials externally
SSH private keys must not be password-protected (the server cannot handle protected keys)

Troubleshooting

Issue	Solution
API errors	Check that your API token is correct and not expired
Insufficient credits	Ensure you have sufficient credits on your Hyperbolic account
SSH connection fails	Verify your private key path is correct and has proper permissions
Network issues	Check your network connection to the Hyperbolic API

SDKs

Official Python and TypeScript SDKs are coming soon.

Hyperbolic will provide official SDKs for streamlined integration:

Python SDK - Native Python client for inference and GPU management
TypeScript SDK - Full TypeScript support with type definitions

In the meantime, you can use:

OpenAI SDK - Hyperbolic’s inference APIs are OpenAI-compatible. See Integrations for migration guides.
REST API - Direct HTTP requests to our endpoints. See Inference API Reference for details.

Next steps

On-Demand GPU

Rent GPU instances using CLI or extensions

Inference APIs

Make API calls to hosted AI models

Integrations

Integrate with LangChain, OpenAI SDK, and more

Account Setup

Configure API keys and SSH keys

Overview

On-Demand GPU

Serverless Inference

Reserved Clusters

General Platform

Hyperbolic CLI

Installation

Quick start

Account setup

Commands and examples

Links

VS Code / Cursor extension

Why use the extension?

Installation

Prerequisites

Configuration

Jupyter Notebook support

vLLM model serving

Security settings

Requirements

MCP Server

Installation

Running the server

Connecting with Claude Desktop

Available tools

Security notes

Troubleshooting

SDKs

Next steps

On-Demand GPU

Inference APIs

Integrations

Account Setup

Overview

On-Demand GPU

Serverless Inference

Reserved Clusters

General Platform

​Hyperbolic CLI

​Installation

​Quick start

​Account setup

​Commands and examples

​Links

​VS Code / Cursor extension

​Why use the extension?

​Installation

​Prerequisites

​Configuration

​Jupyter Notebook support

​vLLM model serving

​Security settings

​Requirements

​MCP Server

​Installation

​Running the server

​Connecting with Claude Desktop

​Available tools

​Security notes

​Troubleshooting

​SDKs

​Next steps

On-Demand GPU

Inference APIs

Integrations

Account Setup

Hyperbolic CLI

Installation

Quick start

Account setup

Commands and examples

Links

VS Code / Cursor extension

Why use the extension?

Installation

Prerequisites

Configuration

Jupyter Notebook support

vLLM model serving

Security settings

Requirements

MCP Server

Installation

Running the server

Connecting with Claude Desktop

Available tools

Security notes

Troubleshooting

SDKs

Next steps