What can you do with this server?

This server gives an MCP agent read-only visibility into Lambda Cloud GPU pricing, live capacity, and your account resources. * list_instance_types — GPU types with USD/hour price, specs, and regions with capacity now; sorted cheapest first, with an only_available filter to hide sold-out types. * cheapest_available_instance — finds the cheapest type with capacity right now, filtered by min_gpus, gpu_contains (e.g. "H100"), region, and max_hourly_usd; returns {"found": false} if nothing matches. * list_instances — lists your running instances. * get_instance — returns details for one instance by instance_id. * list_ssh_keys — lists SSH keys in your account. * list_file_systems — lists persistent file systems. * list_images — lists available machine images. * list_regions — lists Lambda Cloud regions. * Note: no launch, restart, or terminate tools appear in this schema; per the README those write tools only exist when LAMBDA_MCP_ALLOW_WRITE=1 is set, and launch_instance requires a max_hourly_usd price cap.

How do I use lambda-cloud-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@lambda-cloud-mcp What's the cheapest H100 instance available right now?" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

lambda-cloud-mcp

An MCP server for the Lambda Cloud API. It lets an AI agent (Claude Code, Claude Desktop, or any MCP client) check GPU prices and capacity, find the cheapest GPU that is available right now, and see your instances.

If you turn it on, the agent can also launch, restart and terminate instances, with a hard price limit.

Not affiliated with Lambda. Tested against mocked responses built from the public API docs; live test pending.

Why

Lambda has a clean REST API but, as of September 2026, no official MCP server. Agents that train or serve models need to answer simple questions fast: "Is there an H100 free? Where? How much per hour?" This server answers them in one tool call.

Related MCP server: gpu.nz MCP server

Tools

Read-only (always on):

Tool	What it does	API call
`list_instance_types`	Types with price in USD/hour, specs, regions with capacity. Sorted cheapest first. `only_available=true` hides sold-out types.	`GET /api/v1/instance-types`
`cheapest_available_instance`	Cheapest type with capacity now. Filters: `min_gpus`, `gpu_contains` (e.g. `"H100"`), `region`, `max_hourly_usd`.	`GET /api/v1/instance-types`
`list_instances`	Your running instances	`GET /api/v1/instances`
`get_instance`	One instance by id	`GET /api/v1/instances/{id}`
`list_ssh_keys`	SSH keys in your account	`GET /api/v1/ssh-keys`
`list_file_systems`	Persistent file systems	`GET /api/v1/file-systems`
`list_images`	Available machine images	`GET /api/v1/images`
`list_regions`	Regions	`GET /api/v1/regions`

Write tools (cost money, only with LAMBDA_MCP_ALLOW_WRITE=1):

Tool	What it does	API call
`launch_instance`	Launch one instance. Requires `max_hourly_usd`. Refuses if the price is higher, or if the region has no capacity.	`POST /api/v1/instance-operations/launch`
`restart_instances`	Restart instances by id	`POST /api/v1/instance-operations/restart`
`terminate_instances`	Terminate instances by id. Irreversible.	`POST /api/v1/instance-operations/terminate`

Install

You need an API key from the Lambda Cloud API keys page.

Run with uv (no install step):

LAMBDA_API_KEY=your-key uvx --from git+https://github.com/tonydzi/lambda-cloud-mcp lambda-cloud-mcp

Or with pip:

pip install git+https://github.com/tonydzi/lambda-cloud-mcp
LAMBDA_API_KEY=your-key lambda-cloud-mcp

Python 3.10 or newer.

Configure

Claude Code

Read-only:

claude mcp add lambda-cloud -e LAMBDA_API_KEY=your-key -- \
  uvx --from git+https://github.com/tonydzi/lambda-cloud-mcp lambda-cloud-mcp

With launch / terminate enabled:

claude mcp add lambda-cloud -e LAMBDA_API_KEY=your-key -e LAMBDA_MCP_ALLOW_WRITE=1 -- \
  uvx --from git+https://github.com/tonydzi/lambda-cloud-mcp lambda-cloud-mcp

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "lambda-cloud": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/tonydzi/lambda-cloud-mcp", "lambda-cloud-mcp"],
      "env": {
        "LAMBDA_API_KEY": "your-key"
      }
    }
  }
}

Add "LAMBDA_MCP_ALLOW_WRITE": "1" to env only if you want the agent to spend money.

Safety

Read-only by default. Without LAMBDA_MCP_ALLOW_WRITE=1 the write tools are not even shown to the agent. They also check the flag again when called. Only the exact value 1 turns it on.
Price limit on launch. launch_instance has no default for max_hourly_usd. The server reads the current price from the API and refuses if it is higher. Price is per instance per hour, as returned by the API (price_cents_per_hour).
Capacity check. Launch is refused if the region is not in regions_with_capacity_available.
One instance per launch call. No bulk launches.
Key handling. The key is read only from LAMBDA_API_KEY, sent as Authorization: Bearer, and never logged or returned in errors.
API errors come back as readable text with Lambda's error code, e.g. Lambda API 401 on /instances: global/invalid-api-key.

Lambda rate-limits the API to about 1 request per second, and launch to 1 request per 12 seconds.

Source of truth

Every endpoint and field comes from Lambda's public OpenAPI spec, version 1.10.0:

Development

uv venv && uv pip install -e ".[test]"
.venv/bin/pytest -q

Tests use respx to mock HTTP. No real API calls, no key needed.

Environment variables

Variable	Required	Meaning
`LAMBDA_API_KEY`	yes	Your Lambda Cloud API key
`LAMBDA_MCP_ALLOW_WRITE`	no	`1` enables launch / restart / terminate
`LAMBDA_API_BASE_URL`	no	Override base URL (default `https://cloud.lambda.ai`)

License

MIT

— Anton Dziatkovskii · github.com/tonydzi

READ THIS WITH AI

One click and an agent reads the repo, pulls out the patterns and helps you apply them to your own work.

Read this repo: https://github.com/tonydzi/lambda-cloud-mcp (“lambda-cloud-mcp” - MCP server for the Lambda Cloud API: GPU prices, live capacity, cheapest-available lookup, and env-gated launch/terminate with a price cap. Read-only by default). Work out what problem it actually solves, pull out the reusable patterns and help me apply them to my own setup. Start by asking what I am working on.

— TonyDzi, Palo Alto AI Research Lab · second brain, agent coordination, persistent memory: github.com/tonydzi

🧩 One piece of a working system

This repository is one piece lifted out of a live operation: one engineer running a fleet of machines, built with Claude as implementation collaborator; the machines reach consensus with each other and wake the human only for money or the irreversible. It was extracted after it survived production, not written as a demo — and it runs on its own: nothing here phones home to the rest.

See how the whole thing fits together → SYSTEM.md

AI contributors

This project is built by a human + AI team, and the git log says so: Claude writes most of the code, Codex and Grok review it, Gemini feeds the research. Each is credited on a commit only if its output changed that commit's content — no decorative credits. Lab-wide policy, one source for every repo: AI-CONTRIBUTORS.md.

Available Tools

8 tools

cheapest_available_instanceA

Find the cheapest instance type that has capacity now. Filters: min_gpus, gpu_contains (e.g. "H100"), region (e.g. "us-east-1"), max_hourly_usd. Returns {"found": false} if nothing matches.

Inputs: region, min_gpus, gpu_contains, max_hourly_usd. Returns: object

get_instanceB

Get details of one instance by id.

Inputs: instance_id (required). Returns: object

list_file_systemsA

List your persistent file systems.