Skip to main content
Glama
nodegrove VRAM: can I run it?

nodegrove VRAM: can I run it?

Official

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

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

CapabilityDetails
tools
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
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

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.6/5.0

Scored across 6 tools

Disambiguation4/5

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.

Naming Consistency3/5

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.

Tool Count5/5

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.

Completeness4/5

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

ActivityActive
ResponsivenessNo recent community issues