Skip to main content
Glama
ComputeNexa MCP Server

ComputeNexa MCP Server

Official

ComputeNexa MCP server

Let your AI assistant find, launch and stop private GPUs on ComputeNexa. Ask it "Which GPUs with 48 GB or more are in stock?", "Launch the cheapest one with Data Science for two hours" or "Stop it": it uses your team's API key, shows you what each launch costs, and only spends money after you agree.

Works with Claude Desktop, Claude Code, Cursor, VS Code and other assistants that support the Model Context Protocol. It runs on your computer and talks to the ComputeNexa API; your key stays in your own settings.

Set up

  1. In the ComputeNexa dashboard, open API keys and create a key:

    • Look only to browse GPUs, machines and spending;

    • Launch and stop to also launch, extend and stop machines.

  2. Install uv (it runs the server with uvx, no separate install needed).

  3. Add the server to your assistant (below), with your key as CNX_API_KEY.

Claude Code

claude mcp add --env CNX_API_KEY=cnxk_... --transport stdio computenexa -- uvx computenexa-mcp

Add --scope user to use it in every project.

Claude Desktop

Settings → Developer → Edit config (claude_desktop_config.json):

{
  "mcpServers": {
    "computenexa": {
      "command": "uvx",
      "args": ["computenexa-mcp"],
      "env": { "CNX_API_KEY": "cnxk_..." }
    }
  }
}

Cursor

~/.cursor/mcp.json (every project) or .cursor/mcp.json (one project): the same mcpServers entry as Claude Desktop.

VS Code

.vscode/mcp.json; VS Code asks for the key once and keeps it out of the file:

{
  "inputs": [
    { "type": "promptString", "id": "cnx-key", "description": "ComputeNexa API key", "password": true }
  ],
  "servers": {
    "computenexa": {
      "type": "stdio",
      "command": "uvx",
      "args": ["computenexa-mcp"],
      "env": { "CNX_API_KEY": "${input:cnx-key}" }
    }
  }
}

Related MCP server: gpu.nz MCP server

What it can do

Tool

What it does

Key

whoami

Your email, team, balance, GPU limit and the key's permissions

any

list_gpus

GPUs with live prices and stock, cheapest first; filter by app, region, memory

any

list_apps

The apps a GPU starts with, their models, and what's installed

any

list_machines · get_machine

Your machines; how to connect (SSH, browser apps, API or endpoint address)

any

get_usage · list_receipts

Spending and GPU-hours; finished sessions and their cost

any

list_projects · list_endpoints

Saved projects; Endpoints and the machine each points at

any

launch_machine

Launch a GPU (quote first, then launch when you agree)

launch and stop

extend_machine

Add time (quote first)

launch and stop

set_keep_running

Renew a machine automatically until stopped (quote first)

launch and stop

stop_machine

End a machine now; unused time is refunded

launch and stop

create_endpoint · get_endpoint_key

A stable HTTPS address for your own server; its key

launch and stop

A look-only key only gets the read tools (the first six rows).

Safety

  • Nothing is charged without you. launch_machine, extend_machine and set_keep_running first return a quote, e.g. "NVIDIA RTX A6000 with the datascience app for 2 h: $1.44 charged now ($0.72/h); unused time is refunded if it stops early." Only a second call with confirm=true and the quoted total goes ahead; if the price went up in between, it's refused.

  • A limit per call: a launch, extension or keep-running renewal costing more than $25 is refused. Change it with CNX_MCP_MAX_LAUNCH_USD (in dollars) in the server's env. Your team's GPU limit and prepaid balance still apply on top.

  • Your API key never appears in a tool result. Endpoint keys are shown only when you create an endpoint or ask for its key.

  • Tools that spend money or end a machine are marked as such, so your assistant asks before using them.

Settings

Variable

CNX_API_KEY

Required. A ComputeNexa API key (cnxk_…)

CNX_MCP_MAX_LAUNCH_USD

Most one call may spend, in US dollars. Default 25

CNX_API_URL

Only for testing against another ComputeNexa API

Develop

uv sync
uv run pytest
uv run ruff check src tests

Built on the ComputeNexa Python SDK and the official MCP Python SDK.

Questions: support@computenexa.com · Security issues: see SECURITY.md.

Available Tools

15 tools
create_endpointCreate an endpointA

A new Endpoint (owners and admins): a stable HTTPS address and key for your own server on port 8000, e.g. one per customer you serve. Launch machines for it with launch_machine(endpoint=...). Free. Its key is shown once here; get_endpoint_key shows it again.

Inputs: name (required). Returns: id, key, url, name, +1 more

extend_machineExtend a machineA

Add time to a machine at the price it launched with. Costs money: quote first (confirm=false), then confirm=true with expected_total_usd once the person agrees.

Inputs: hours (required), machine_id (required), confirm, expected_total_usd. Returns: quote, status, machine

get_endpoint_keyGet an endpoint's keyA
Read-onlyIdempotent

An Endpoint's key (owners and admins). Only when the person asks for it: it gives access to their server.

Inputs: endpoint (required). Returns: key, url, endpoint

get_machineGet a machineA
Read-onlyIdempotent

One machine: its state, how to connect (SSH command, browser apps, API or endpoint address), time left, keep-running status and costs. Never its keys.

Inputs: machine_id (required). Returns: id, app, gpu, label, +23 more

get_usageGet usageB
Read-onlyIdempotent

Spending and GPU-hours over the last N days, by GPU, app, day and project.

Inputs: days. Returns: days, daily, by_app, by_gpu, +6 more

launch_machineLaunch a machineA

Launch a GPU machine. Costs money: call first with confirm=false to get a quote (nothing happens), show it to the person, and only after they agree call again with the same arguments, confirm=true and expected_total_usd. The booked time is charged up front from the team's balance.

Inputs: app (required), gpu (required), hours (required), label, +8 more. Returns: quote, status, machine

list_appsList appsA
Read-onlyIdempotent

The apps a GPU can start with (basic, datascience, chat, imagegen, modelapi, voice): what each is for, the models it offers and which model we recommend per GPU memory. Give app for the software installed.

Inputs: app, package. Returns: apps, software

list_endpointsList endpointsA
Read-onlyIdempotent

Endpoints: stable HTTPS addresses for your own server on a machine's port 8000, and the machine each points at now. Never their keys.

Inputs: no named parameters. Returns: endpoints

list_gpusList GPUsA
Read-onlyIdempotent

GPUs with live prices (US dollars per GPU per hour) and stock, cheapest first.

Inputs: app, region, min_memory_gb, include_sold_out. Returns: gpus, region

list_machinesList machinesB
Read-onlyIdempotent

Your machines, newest first: state, GPU, app, price, time left and cost so far.

Inputs: limit, whole_team, active_only. Returns: machines

list_projectsList projectsB
Read-onlyIdempotent

Saved projects (files restored into ~/work on machines launched with them) and their size.

Inputs: no named parameters. Returns: projects

list_receiptsList receiptsB
Read-onlyIdempotent

Finished sessions and what each cost in the end (charged minus refunded).

Inputs: days, limit. Returns: receipts, total_net_usd

set_keep_runningKeep a machine runningA

Keep running: the machine renews itself hours at a time from the team's balance, at its launch price, until it's stopped. Turning it on spends money at every renewal: quote first, then confirm=true with expected_renewal_usd. Turning it off (hours=null) needs no confirmation.

Inputs: hours (required), machine_id (required), confirm, expected_renewal_usd. Returns: quote, status, machine

stop_machineStop a machineA
DestructiveIdempotent

End a machine now: stopped if running, cancelled with a full refund if still starting. Files outside a project are deleted; a project is saved first. Unused time is refunded. Can't be undone.

Inputs: machine_id (required). Returns: machine, refunded_usd

whoamiWho am IA
Read-onlyIdempotent

Who this server's API key acts as: email, team and role, the team's balance and GPU limit, and whether the key may launch and stop machines.

Inputs: no named parameters. Returns: role, team, email, api_key, +4 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 15 tools

    Disambiguation5/5

    Each tool targets a distinct resource or lifecycle action: GPUs/apps discovery, machine launch/list/get/extend/stop/keep-running, endpoints, projects, usage, receipts, and identity. The potentially closest pair, extend_machine and set_keep_running, is clearly separated by one-off time extension versus automatic renewal, with both having explicit confirmation semantics.

    Naming Consistency4/5

    Nearly all tools follow a snake_case verb_noun pattern such as list_machines, get_machine, launch_machine, stop_machine, create_endpoint, and get_endpoint_key. whoami is the lone conventional outlier, and set_keep_running is slightly more phrasal, but the naming remains predictable overall.

    Tool Count5/5

    Fifteen tools fit the server's scope well: discovery, machine lifecycle, spending, projects, endpoints, and identity each contribute a small set of operations. No obvious redundant tools inflate the surface, and the set stays within a manageable range.

    Completeness3/5

    Core GPU machine workflows are well covered: discovering GPUs/apps, launching, inspecting, extending, stopping, and checking costs. However, projects expose only list_projects with no create/get/delete lifecycle, and endpoints expose create/list/get-key but no delete or revoke operation, leaving notable dead ends for resource management.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Enables AI agents to retrieve live GPU rental prices, compare models, and access market summaries and historical price data through four read-only MCP tools.
      4
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to search live GPU offers, estimate model VRAM, rent and monitor cloud GPU servers with ready templates, read logs, and stop or destroy them when done. Browsing and VRAM estimates work without an API key, while server management requires one.
      1
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to work with a GPU cloud: check live GPU prices, launch GPUs on ready images, run commands as jobs that stop billing when the command exits, schedule runs, move files, and check spend. Access is scoped to one signed-in environment and capped by its monthly budget.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables agents to query live cloud GPU pricing, stock availability, and up to 12 months of price history across 30+ hyperscalers, neoclouds, and marketplaces, including comparisons of cheapest listed versus cheapest in-stock offers. All tools are read-only, with provider listings and GPU catalogs available at no cost.
      8
      63 npm
      MIT