nodegrove VRAM: can I run it?
OfficialAn MCP server that tells you whether an open-weight LLM fits a given GPU's VRAM, and what would fit instead.
can_i_run — asks if a specific model (name/id, Hugging Face repo, or manual architecture) fits a specific GPU: returns fits/tight/no, the weights + KV cache + overhead split, a decode-speed ceiling, the longest context that still fits, and on a "no", every change that would make it fit (quant, KV cache, context, another card, smaller model).
what_fits — ranks every model in its table against one GPU at a chosen quantisation/context, giving a recommended everyday pick, the largest that fits, the best at Q8, and the first out of reach.
estimate_vram — computes weights + KV cache + overhead for a model at one or all six quantisations, plus the smallest common card class that holds each.
estimate_from_hf_repo — reads any Hugging Face repo's
config.jsonlive and reports its attention layout (standard, sliding-window, hybrid, latent), memory per 1,000 context tokens, and totals at every quantisation.list_models / list_gpus — browsable, searchable lists of verified models (size, attention design, native context, licence, Q4/8k memory) and GPUs (memory, usable memory, bandwidth), each with a nodegrove.io page link.
Accepts flexible inputs — model names as people type them, HF repo ids, GPU names or raw
vram_gb/bandwidth, Apple unified memory flags, and MoE active-parameter counts for speed estimates.All six tools are read-only; every answer returns the numbers as fields along with the assumptions behind them.
Reads any public Hugging Face model repository's config.json and metadata to estimate its memory requirements: the attention layout, the cost of each 1,000 tokens of context, memory at every quantisation, and whether the model fits a given GPU. Also backs the built-in model table, which was read from each model's config.json and checked against Hugging Face.
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., "@nodegrove VRAM: can I run it? can I run Llama 3.3 70B on an RTX 4090?"
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.
Can my RTX 4090 run Llama 3.3 70B?
No: Llama 3.3 70B at Q4_K_M with 8,192 tokens of context needs 45.8 GB, and the RTX 4090 holds 22.8 GB after headroom. Short by 23 GB. What would work instead:
No context length helps: the weights alone are 43.1 GB before a single token of conversation.
RTX 6000 Ada (48 GB) is within a whisker: 45.8 GB against 45.6 GB after headroom. With the KV cache at Q8 it needs 44.4 GB and fits.
The smallest card here that runs it exactly as asked: A100, 80 GB usable.
The biggest model your card does run at these settings, counting mixture-of-experts models at their dense equivalent: Gemma 4 31B, 20.9 GB at ~39 tokens/s.
That is the server's own answer, word for word, from the same code as the GPU compatibility checker on nodegrove.io. Every figure is a stated formula over the model's config.json and the card's published specs: no benchmarks, no guesses. It is free, read-only, and needs no account or key.
Connect
Remote: nothing to install
https://mcp.nodegrove.io/mcp
# Claude Code (add --scope user to have it in every project)
claude mcp add --transport http nodegrove-vram https://mcp.nodegrove.io/mcp
# Codex CLI
codex mcp add nodegrove-vram --url https://mcp.nodegrove.io/mcp
# Gemini CLI
gemini mcp add -s user --transport http nodegrove-vram https://mcp.nodegrove.io/mcpClaude (claude.ai and the desktop app): Customize → Connectors → Add → Add custom connector. Name it
Nodegrove VRAM, paste the URL, choose No sign-in, then turn it on in a chat from + → Connectors.ChatGPT: Settings → Security and login → turn on Developer mode. At chatgpt.com/plugins, add the URL with No Authentication, then pick it in a chat from + → Developer mode.
Most other clients take this in their mcp.json. Cline, Zed, Open WebUI, Devin Desktop and the rest are covered step by step at nodegrove.io/mcp.
{ "mcpServers": { "nodegrove-vram": { "url": "https://mcp.nodegrove.io/mcp" } } }Local: over stdio
Needs Node.js 20 or newer:
{
"mcpServers": {
"nodegrove-vram": {
"command": "npx",
"args": ["-y", "@nodegrove/vram-mcp"]
}
}
}Related MCP server: chimeraforge
Tools
Tool | Ask it | It answers with |
| Can my RTX 4090 run Llama 3.3 70B with 32k of context? | Fits, tight or no; the memory split; a speed ceiling; the longest context that fits; and on a no, every change that would make it fit |
| What is the best model for my 16 GB card? | Every model checked on one card, with a recommended everyday pick, the largest that fits, the best at Q8 and the first out of reach |
| How much VRAM does Qwen3 32B need at 64k? | Weights, KV cache and overhead at each quantisation, and the smallest common card that holds each |
| How much memory does | Any Hugging Face repo, read from its |
| Which GPUs do you know? | The models and cards with their specs, ids and pages |
Models can be named the way people type them ("llama 3.3 70b", Llama-3.3-70B-Instruct) or given as any Hugging Face repo id. Cards can be named ("4090", "M4 Max") or described by their memory and bandwidth. Every answer carries the numbers as fields, links to the model and card pages on nodegrove.io, and the assumptions behind each figure. All six tools are read-only.
How the numbers are made
Memory is weights + KV cache + overhead. Weights are parameters × bytes per parameter at the quantisation: FP16 2.00, Q8_0 1.06, Q6_K 0.82, Q5_K_M 0.71, Q4_K_M 0.58, Q3_K_M 0.47. Overhead is 0.5 GB plus 4% of the weights.
The KV cache is counted the way each model caches. Sliding-window layers stop at their window, hybrid models (linear attention or Mamba) grow a cache only on their few full-attention layers, and latent attention stores one compressed vector per layer. A standard-transformer formula would overstate these models several times over at long context.
Fit means at most 95% of the memory a runtime can address; above 85% it is tight. Apple silicon gives the GPU about 75% of unified memory.
Speed is 0.7 × memory bandwidth ÷ bytes of active weights read per token. It is a single-stream ceiling, not a measurement, and the faster the figure, the further real runtimes fall below it.
The model table was read from each model's
config.jsonand checked against Hugging Face. Any other repo is read live by the same rules, which reproduce every row of the table; anything the reader cannot model is named in the answer, never guessed.
The full method, with every constant, is at nodegrove.io/data. The same figures are an open dataset under CC BY 4.0, DOI 10.5281/zenodo.22966137.
The math as a library
The server is a thin layer over @nodegrove/llm-math, the package nodegrove.io's pages and calculators are built on:
npm install @nodegrove/llm-mathimport { modelById, estimate } from '@nodegrove/llm-math';
estimate({ ...modelById('llama-3.3-70b')!, quant: 'q4', context: 8192 }).totalGb; // 45.77Privacy
The remote server runs on Cloudflare Workers. Nodegrove keeps no request logs and no record of what you ask: each request is answered by a fresh, stateless instance and forgotten. Cloudflare keeps standard edge logs for a short period, as for any website. Requests are rate-limited to 120 a minute per address. When you ask about a Hugging Face repo, the server fetches that repo's public config.json and metadata; only the repo name is sent. The local version contacts nothing but huggingface.co, and only when you ask about a repo there. Details: nodegrove.io/privacy.
Run your own
The remote endpoint is mcp/src/worker.ts. To deploy a copy to your Cloudflare account, change the route in mcp/wrangler.jsonc, then:
cd mcp && npm install && npx wrangler deployDevelopment
cd llm-math && npm install && npm test
cd mcp && npm install && npm test && npm run buildllm-math/ is the package of formulas and data; mcp/ is the server, with the stdio entry (src/stdio.ts), the Worker (src/worker.ts) and the tools (src/tools.ts). This repository is published from Nodegrove's main repository, where the site uses the same package. Issues and pull requests are welcome here; accepted changes are applied upstream and credited.
Found a figure that disagrees with its source? Open an issue with the model or card and the link. To report a security problem, see SECURITY.md.
Licence
The code is MIT. The model and GPU data, llm-math/src/models.ts and llm-math/src/gpus.ts, is CC BY 4.0: use it for anything, and credit Nodegrove (nodegrove.io).
Model and GPU names are trademarks of their owners.
Available Tools
6 toolscan_i_runCan I run it?ARead-onlyIdempotentInspect
Can this GPU run this open-weight LLM? Returns fits, tight or no, the memory split (weights, KV cache, overhead), a decode-speed ceiling, the longest context that fits and, on a no, every change that would make it fit: quantisation, KV cache, context, another card or a smaller model. Model: a name or id from list_models, any Hugging Face repo id, or its architecture. GPU: a name or id from list_gpus, or vram_gb for any other card.
Inputs: gpu, model, quant, context, +6 more.
estimate_from_hf_repoEstimate VRAM from a Hugging Face repoARead-onlyIdempotentInspect
Reads any Hugging Face model repo's config.json and parameter count and estimates its memory: the attention layout found (standard, sliding-window, hybrid or latent), how much each 1,000 tokens of context costs, and weights + KV cache + overhead at every quantisation. For models nodegrove.io has not reviewed; anything the reader cannot model is listed in warnings.
Inputs: repo (required), context, kv_cache, active_params_b.
estimate_vramEstimate VRAMARead-onlyIdempotentInspect
How much memory an LLM needs: weights + KV cache + overhead at each quantisation (or one), at a given context, and the smallest common card class that holds each. Model: a name or id from list_models, any Hugging Face repo id, or its architecture (params_b, layers, kv_heads, head_dim).
Inputs: model, quant, context, kv_cache, +2 more.
list_gpusList GPUsBRead-onlyIdempotentInspect
The GPUs and machines nodegrove.io covers: memory, the memory a runtime can use and bandwidth, from the makers' specs, with each one's page.
Inputs: search.
list_modelsList modelsBRead-onlyIdempotentInspect
The open-weight LLMs nodegrove.io has verified against their config.json (data version 2026-11-03): id, size, attention design, native context, licence, memory at Q4 with 8k context and each model's page.
Inputs: search.
what_fitsWhat fits my GPU?ARead-onlyIdempotentInspect
Which open-weight LLMs fit this GPU: every model in list_models checked at one quantisation and context, with a recommended everyday model (the biggest class that fits with room for context at conversational speed), the largest that fits, the best at Q8 and the first out of reach. GPU: a name or id from list_gpus, or vram_gb for any other card.
Inputs: gpu, quant, context, vram_gb, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool has a discernible niche: list_models/list_gpus are catalog reads, can_i_run is single model+GPU verdict, what_fits is many-models-on-one-GPU batch, estimate_vram is memory-only math. The main overlap is estimate_vram vs estimate_from_hf_repo, since estimate_vram explicitly accepts Hugging Face repo ids too, so an agent could pick the weaker path for an unreviewed model. The split is defensible (curated model vs arbitrary repo with warnings) but not crisp.
Four tools follow a clean verb_noun pattern (list_models, list_gpus, estimate_vram, estimate_from_hf_repo), but can_i_run and what_fits use question-style phrasings that break the convention. It is readable and arguably intentional, but it is a mixed convention across the set.
Six tools is well inside the sweet spot and each covers a distinct step: enumerate models, enumerate GPUs, estimate memory, estimate from a repo, check one fit, check all fits. Nothing feels padded or missing at this scope.
The surface covers the CRUD-equivalent lifecycle for its domain: catalogs, memory math, single-fit verdicts, and batch fit search, plus an escape hatch for unreviewed HF repos. The notable gap is the reverse query—listing every GPU that would run a given model, or comparing multiple cards against one model—which forces repeated can_i_run calls.
Maintenance
Related MCP Connectors
Will this LLM fit on your GPU, multi-GPU rig or Mac? Exact VRAM & KV-cache math. Read-only.
Does an LLM fit on your GPU? VRAM, KV cache and GPU count for any Hugging Face model.
Find open-weight AI models that fit your hardware, with weight sizes, memory and sources.
Read-only: which local LLMs a GPU or Mac can run - VRAM fit, tokens/sec, model specs.
Related MCP Servers
- AlicenseAqualityCmaintenanceProvides tools to inspect local GGUF and safetensors model files, returning metadata, tensor info, and VRAM estimates without reading tensor data. Enables asking natural-language questions about model architecture, quantization, size, and compatibility.479 npmMIT
- AlicenseAqualityBmaintenanceLLM deployment planner: given a model and a GPU, answers will it fit, will it hit your SLO, and what will it cost. Sizes VRAM and KV-cache from the model's real architecture, and labels every number measured, estimated, or unknown.5979 PyPI3MIT
- FlicenseNot gradedqualityBmaintenanceEnables AI agents and MCP clients to estimate VRAM footprint and tensor parallelization requirements for quantized llama.cpp models, returning structured outputs without external dependencies.8-
- AlicenseAqualityBmaintenanceEnables engineers to estimate LLM costs, check GPU VRAM fit, audit MCP configs for security risks, and analyze network device config changes and compliance—all locally, with no account or telemetry.7MIT