This MCP server lets an agent manage Nosana GPU deployments: browse templates and GPU markets, estimate costs, create and monitor deployments, then use or stop them.
Check account credits (assigned, reserved, settled, available).
List/search ready-to-run templates and get details like variants, VRAM, and hardware requirements.
Inspect GPU markets by hourly price, idle availability, VRAM, queue status, and template fit.
Dry-run deployment plans with estimate_deployment to show cost and warnings before spending.
Create and start deployments from templates or custom job definitions, with confirmation, GPU strategy, timeout, replicas, and safeguards against queueing/duplicates.
Poll deployment status with wait_for_deployment until online, completed, failed, or pending; get status, endpoints, jobs, and events.
Retrieve endpoint usage info, job results/logs, and scheduler events.
Stop deployments to end billing, restart stopped/draft deployments, and extend timeouts.
Allows deploying Jupyter notebook environments on Nosana GPU infrastructure and managing their lifecycle.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Nosana MCP Estimate a 2-hour MiniMax H3 deployment on an RTX 5090."
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.
Let your AI agent rent a GPU and deploy models on Nosana. Nosana MCP is a Model Context Protocol server that gives Claude Code, Claude Desktop, Cursor, Codex, OpenClaw and any other MCP client the tools to browse Nosana's ready-to-run templates (MiniMax H3 video, Qwen and Gemma LLMs, ComfyUI, Jupyter, VS Code), compare GPU markets by live price and availability, estimate the cost, deploy, and hand back the running endpoint. Everything is paid with Nosana account credits through a single API key. No wallet, no tokens.
"Deploy MiniMax H3 on an RTX 5090 and give me the ComfyUI link." The agent checks your credits, picks the 32 GB variant, shows you the price (about 0.40 credits per hour on a 5090), waits for your yes, deploys, polls until ComfyUI answers, and returns the URL. When you are done: "stop it".
A companion CLI, nosana-deploy, ships in the same package for humans, scripts and CI. See docs/CLI.md.
Sign in at deploy.nosana.com.
Billing: add credits with a card or crypto.
Account > API Keys > Create Key. Copy it once.
Claude Code:
claude mcp add nosana --env NOSANA_API_KEY=nos_your_key -- npx -y nosana-mcpClaude Desktop, Cursor, Windsurf and most other clients take the same JSON:
{
"mcpServers": {
"nosana": {
"command": "npx",
"args": ["-y", "nosana-mcp"],
"env": { "NOSANA_API_KEY": "nos_your_key" }
}
}
}Codex CLI:
codex mcp add nosana --env NOSANA_API_KEY=nos_your_key -- npx -y nosana-mcpRunning from a clone instead of npm:
git clone https://github.com/SohniSwatantra/nosana-mcp.git && cd nosana-mcp
npm install && npm run build
# then point your client at: node /absolute/path/to/nosana-mcp/dist/mcp/index.jsInstead of the environment variable you can run nosana-deploy login once; the server also reads the key that command stores in ~/.config/nosana-deploy/config.json.
"Deploy Qwen 3.6 27B on the cheapest idle GPU and give me the OpenAI-compatible URL."
"Deploy MiniMax H3 image-to-video. If no 5090 is idle, show me the alternatives."
"What is running right now and what does it cost per hour?" / "Stop everything."
The agent must show you the estimate and get a yes before it can call create_deployment. Bundled prompts: deploy_template, deploy_llm, deploy_comfy, deploy_minimax_h3, stop_when_done.
After adding or changing the server configuration, restart the client or reconnect its MCP servers (Claude Code: /mcp); tools are discovered at session start.
Related MCP server: terahood-agent
Every tool returns one JSON object, both as text and as MCP structuredContent: {ok, message, next_tool, next_args, ...}. ok is false only when the tool itself failed; deployment outcomes live in outcome. Agents never have to parse prose.
Tool | What it does | Spends credits |
| Checks the key, credits and every Nosana API; returns the exact fix (install command, restart hint). | no |
| Assigned, reserved, settled and available credits. | no |
| Catalog with kind (comfyui, llm, notebook, ide), VRAM from the template itself, variants, hardware notes, typical boot time. | no |
| Markets in buyer buckets: | no |
| One call from a workload ("minimax-h3/i2v-32gb", "qwen3-6-27b", "gemma3 12b", or a job definition) to the cheapest ready GPU, cost, similar deployments already running, and exact | no |
| Dry run of | no |
| Creates and starts. Needs | yes |
| Watches up to 45 s per call (MCP clients time out at 60 s). Returns | no |
| Status, phase, endpoints with a real readiness probe, price per hour, recent jobs and events. | no |
| How to use the running service: ComfyUI | no |
| Logs and the scheduler's event log. | no |
| Stops jobs; billing stops with them. | ends spending |
| Restart a stopped deployment (needs | yes |
Resources: nosana://templates, nosana://gpus. Prompts: deploy_template, deploy_llm, deploy_comfy, deploy_minimax_h3, stop_when_done.
recommend_plan("qwen3-6-27b") -> ready_now GPU, cost, create_args
create_deployment(create_args, confirm=true) after the user says yes
wait_for_deployment(id) x N -> pending(phase) ... online
get_endpoint_usage(id) -> OPENAI_BASE_URL, /v1/models, curl example
stop_deployment(id) when the user is doneConfirmation before spending. create_deployment and start_deployment do nothing without confirm=true; their descriptions tell the agent to show the estimate first, and MCP annotations mark them non-read-only so clients prompt for approval.
No silent queueing. With gpu: "auto" only a GPU that fits and has an idle host is chosen. If none is ready, the response lists fits_but_queued and idle_with_risk and asks for a decision (accept_queue or force). Unsupported hardware (a non-Blackwell card for MiniMax H3) is never offered, because it would download 45 GB of weights and then fail.
No accidental duplicates. Creating a workload that is already running is refused unless allow_duplicate=true.
60-minute minimum. Nosana only schedules credit-paid jobs of 3600 seconds or more; shorter values are rejected before anything is created. Workloads that download weights default to 120 minutes.
Real readiness. Nosana's endpoint flag is advisory: it can report online while the container is still loading, and it can lag for many minutes after the service already answers. Once a job is running the server probes the service itself (/ for web UIs, /api/tags or /v1/models for LLMs) and reports online only on a real answer.
Stopped is not failed. A deployment stopped by the user or its timeout reports outcome: "stopped", so agents do not "fix" it by restarting and paying the boot again.
Fail fast, retry the transient. Repeated scheduler errors end the wait with the error text; transient 5xx and network blips are retried with backoff.
Short calls. No tool blocks longer than 45 seconds. Pending results carry poll_after_seconds and next_args so the agent can loop safely.
Prices come from the live market list and include the network fee, so they match deploy.nosana.com. Every plan and every online result carries usd_per_hour, estimated_credits, boot_minutes_typical and the billing rules (idle time bills, there is no pause, stopping ends billing, restarting pays the boot again). See docs/COST.md for numbers from real runs.
npm install
npm run build
npm run test:mcp # read-only smoke test with assertions against the live API (needs NOSANA_API_KEY)
SMOKE_DEPLOY=1 npm run test:mcp # also deploys hello-world once (about 0.05 credits)
npm run inspect # MCP Inspector UI against the built serverLayout: src/core (Nosana Kit wrappers: templates, markets, deployments, cost, readiness), src/mcp (server and tools), src/cli (the nosana-deploy command). Both surfaces share the core, so a fix in one place fixes both.
MIT. Not affiliated with Nosana; built on the public @nosana/kit SDK and API.
SPENDS CREDITS. Creates a Nosana deployment from a template or job definition on the chosen GPU and starts it. Requires confirm=true, which you must only pass after the user has seen the estimate from estimate_deployment and agreed. Returns the deployment id; then poll wait_for_deployment until the endpoint is ready or the job completes.
Inputs: gpu (required), name, force, start, +10 more.
Dry run: resolve the template/variant and GPU, validate the plan, and return the cost in credits for one timeout window plus warnings (too little VRAM, non-Blackwell card, insufficient credits, no idle hosts). Nothing is created. Call this before create_deployment and show the user the cost.
Inputs: gpu (required), variant, replicas, schedule, +5 more.
Sets a new timeout in minutes for a deployment (minimum 60). Longer timeouts reserve more credits.
Inputs: deployment_id (required), timeout_minutes (required).
Credits on the Nosana account behind the API key: assigned, reserved by running deployments, settled (spent) and available. 1 credit is priced like 1 USD.
Inputs: no named parameters.
Current status of a deployment with endpoints (tunnel online and whether the service actually answers), recent jobs and recent events.
Inputs: deployment_id (required).
Scheduler event log for a deployment (job listed, stopped, errors such as insufficient funds or bad timeout). Newest first.
Inputs: deployment_id (required), limit.
Logs and results of a deployment job (latest job by default).
Inputs: deployment_id (required), job.
Details of one template or variant: VRAM needed, hardware notes (e.g. MiniMax H3 needs a Blackwell GPU), whether it exposes a web endpoint, variants, and optionally the job definition it deploys.
Inputs: template (required), variant, include_readme, include_job_definition.
Deployments on this account (newest first) with status, strategy, active jobs and timeout.
Inputs: limit, search, status.
GPU markets with price per hour (network fee included, matches deploy.nosana.com), idle hosts available right now, VRAM, and, when a template is given, whether each GPU fits it.
Inputs: variant, template, min_vram_gb, include_queue, +1 more.
Ready-to-run Nosana templates (MiniMax H3 video, Qwen and Gemma models via Ollama, ComfyUI, Jupyter, VS Code, Whisper, ...). Templates with variants need a variant id when deploying.
Inputs: search.
SPENDS CREDITS. Starts a DRAFT or STOPPED deployment again with its existing settings. Requires confirm=true after the user agreed.
Inputs: deployment_id (required), confirm.
Stops a deployment and its running jobs. Billing stops with them. Use when the user is done or when a deployment can never schedule.
Inputs: deployment_id (required).
Blocks up to max_seconds (default 60, max 120) watching a deployment. Returns outcome "online" (service answers; includes ready URLs), "completed" (job finished; includes logs), "failed" (with the scheduler error), or "pending" (call again). Safe to call repeatedly.
Inputs: deployment_id (required), max_seconds.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 14 tools
Each tool targets a distinct resource or action: balance, templates, GPUs, deployment lifecycle, and job artifacts are clearly separated. Even the closely related get_deployment, wait_for_deployment, and get_job_result serve different purposes (status snapshot, blocking wait, and log retrieval) without meaningful overlap.
All tools follow a consistent verb_noun snake_case pattern, such as get_balance, list_templates, create_deployment, and extend_deployment. The naming is predictable and makes the action and target of each tool immediately obvious.
14 tools is a reasonable size for a deployment platform that covers credits, templates, GPU availability, cost estimation, deployment lifecycle, and job results. Each tool represents a distinct capability needed to follow the user's workflow from planning through execution to cleanup.
The core lifecycle is covered well: estimate, create, wait, poll, stop, start, extend, and fetch results. The main gap is the lack of a delete/remove operation for deployments, so users cannot fully clean up old or unwanted deployments from their account.
Rent cloud GPUs from AI agents: live prices, VRAM estimates, launch, logs and stop.
On-demand GPU nodes for agents: create nodes, run commands, and submit jobs, billed by the minute.
Rent A100 and H100 GPUs by the minute from your agent, within a spending limit you set.
Find, price, rent and stop GPUs on AmpleRun. Paid in USDC or USDT on Base. Flat 5% fee.
