nodegrove VRAM: can I run it?
OfficialServer Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
Answers whether an open-weight LLM fits a GPU, with the formulas nodegrove.io publishes. Use can_i_run for "can my GPU run this model", what_fits for "what can my GPU run", estimate_vram for memory at each quantisation, estimate_from_hf_repo to read any Hugging Face repo, and list_models / list_gpus to find ids. Figures are estimates from stated formulas over config.json values and makers' specs, never benchmarks, and speeds are upper bounds: say so when you quote them, and give the page link from the result. The data is CC BY 4.0: credit Nodegrove (nodegrove.io).
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": true
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| can_i_runA | 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. |
| what_fitsA | 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. |
| estimate_vramA | 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). |
| estimate_from_hf_repoA | 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. |
| list_modelsB | 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. |
| list_gpusB | 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. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
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.