Rent GPU Compute

{
  "instance_id": "respectful-rose-pelican",
  "instance_name": "respectful-rose-pelican",
  "status": "starting",
  "cluster_name": "us-east-1-cluster",
  "node_name": "node-abc123",
  "gpu_count": 2,
  "ssh_command": "ssh user@hostname -p 22"
}

from hyperbolic_agentkit_core.actions import RentComputeAction

# Initialize the action
rent_action = RentComputeAction()

# Rent 2 GPUs from a specific node
result = rent_action.func(
    cluster_name="us-east-1-cluster",
    node_name="node-abc123",
    gpu_count="2"
)

print(result)

from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
from hyperbolic_langchain.agent_toolkits import HyperbolicToolkit
from hyperbolic_langchain.utils import HyperbolicAgentkitWrapper

# Setup
hyperbolic = HyperbolicAgentkitWrapper()
toolkit = HyperbolicToolkit.from_hyperbolic_agentkit_wrapper(hyperbolic)
tools = toolkit.get_tools()

llm = ChatOpenAI(model="gpt-4")
agent = create_react_agent(llm, tools)

# Let the agent handle the entire workflow
events = agent.stream(
    {"messages": [("user", "Rent me the cheapest 4 GPU instance available")]},
    stream_mode="values",
)

for event in events:
    event["messages"][-1].pretty_print()

from hyperbolic_agentkit_core.actions import (
    GetAvailableGpusAction,
    RentComputeAction,
    GetGpuStatusAction
)
import json
import time

# Step 1: Get available GPUs
get_gpus = GetAvailableGpusAction()
available = get_gpus.func()
print(available)

# Step 2: Parse the output and select a GPU
# (In a real scenario, you'd parse the text output)
cluster_name = "us-east-1-cluster"
node_name = "node-abc123"
gpu_count = "2"

# Step 3: Rent the compute
rent = RentComputeAction()
result = rent.func(
    cluster_name=cluster_name,
    node_name=node_name,
    gpu_count=gpu_count
)
instance_data = json.loads(result)
print(f"Rented instance: {instance_data['instance_id']}")

# Step 4: Wait for instance to be ready
get_status = GetGpuStatusAction()
while True:
    status = get_status.func()
    status_data = json.loads(status) if isinstance(status, str) else status
    
    # Find our instance in the status list
    our_instance = None
    if isinstance(status_data, dict) and "instances" in status_data:
        for inst in status_data["instances"]:
            if inst.get("instance_id") == instance_data["instance_id"]:
                our_instance = inst
                break
    
    if our_instance and our_instance.get("status") == "running":
        print(f"Instance is ready!")
        print(f"SSH: {our_instance.get('ssh_command')}")
        break
    
    print("Instance is starting... waiting 5 seconds")
    time.sleep(5)

import requests
from hyperbolic_agentkit_core.actions import RentComputeAction

try:
    rent = RentComputeAction()
    result = rent.func(
        cluster_name="invalid-cluster",
        node_name="invalid-node",
        gpu_count="99"
    )
except requests.exceptions.RequestException as e:
    print(f"Failed to rent compute: {e}")
    # Handle error appropriately
except ValueError as e:
    print(f"Invalid parameters: {e}")

hyperbolic_agentkit_core/actions/rent_compute.py:44-106

def rent_compute(cluster_name: str, node_name: str, gpu_count: str) -> str:
    """Creates a marketplace instance using the Hyperbolic API."""
    
    # Input validation
    if not cluster_name or not node_name or not gpu_count:
        raise ValueError("cluster_name, node_name, and gpu_count are required")
    
    # Get API key from environment
    api_key = get_api_key()
    
    # API endpoint
    endpoint = "https://api.hyperbolic.xyz/v1/marketplace/instances/create"
    
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    
    payload = {
        "cluster_name": cluster_name,
        "node_name": node_name,
        "gpu_count": gpu_count
    }
    
    response = requests.post(endpoint, headers=headers, json=payload)
    response.raise_for_status()
    
    return json.dumps(response.json(), indent=2)