Catalog
huggingface/hf-mem

huggingface

hf-mem

Hugging Face CLI to estimate the required memory to load Safetensors or GGUF model weights for inference from the Hugging Face Hub

global
New~823
v1.0Saved Jul 11, 2026

hf_mem estimates the required memory for inference, including model weights and an optional KV cache, for Safetensors and GGUF for models on the Hugging Face Hub using HTTP Range requests i.e., without downloading or loading any weights locally.

When to use?

  • User asks how much VRAM or memory a model needs to run
  • User wants to know if a model fits on their GPU or a given instance
  • User references a Hugging Face model ID or URL and asks about inference requirements

What are the requirements?

  • uv installed (for uvx)
  • HF_TOKEN env var or --hf-token flag (for gated or private models only)

How to run?

Run with --model-id pointing to the Hugging Face Hub repository which will check that it either contains Safetensors (via model.safetensors, model.safetensors.index.json if sharded, or model_index.json for Diffusers) or GGUF model weights within.

uvx hf-mem --model-id <model-id> --json-output

If the repository contains GGUF model weights in multiple precisions / quantizations, the estimations will be on a per-file basis, whereas for inference you won't load all of those but rather only a single precision. This being said, for GGUF you might as well need to provide --gguf-file to target the specific file (or path if sharded) you want to run.

uvx hf-mem --model-id <model-id> --gguf-file <file-or-path> --json-output

Additionally, hf-mem comes with an --experimental flag that will also calculate the KV cache memory requirements too, useful for large-language models, meaning it applies to LLMs (...ForCausalLM), VLMs (...ForConditionalGeneration), and GGUF models.

As per the context window, it will be read from the default or overridden with --max-model-len a la vLLM. And, same goes for the KV cache precision, which will default to the model precision unless manually set via --kv-cache-dtype a la vLLM too.

For Safetensors use as:

uvx hf-mem --model-id <model-id> --experimental [--max-model-len N] [--batch-size N] [--kv-cache-dtype auto|bfloat16|fp8|fp8_ds_mla|fp8_e4m3|fp8_e5m2|fp8_inc] --json-output

And, for GGUF use as:

uvx hf-mem --model-id <model-id> --gguf-file <file-or-path> --experimental [--max-model-len N] [--batch-size N] [--kv-cache-dtype auto|F32|F16|Q4_0|Q4_1|Q5_0|Q5_1|Q8_0|Q8_1|Q2_K|Q3_K|Q4_K|Q5_K|Q6_K|Q8_K|IQ2_XXS|IQ2_XS|IQ3_XXS|IQ1_S|IQ4_NL|IQ3_S|IQ2_S|IQ4_XS|I8|I16|I32|I64|F64|IQ1_M|BF16|TQ1_0|TQ2_0|MXFP4] --json-output

Examples

For Transformers with Safetensors weights:

uvx hf-mem --model-id MiniMaxAI/MiniMax-M2 --json-output

For Diffusers with Safetensors weights:

uvx hf-mem --model-id Qwen/Qwen-Image --json-output

For Sentence Transformers with Safetensors weights:

uvx hf-mem --model-id google/embeddinggemma-300m --json-output

With --experimental to include the KV cache estimation for LLMs and VLMs:

uvx hf-mem --model-id mistralai/Mistral-7B-v0.1 --experimental --json-output

And, for LLMs or VLMs with GGUF weights:

uvx hf-mem --model-id unsloth/Qwen3.5-397B-A17B-GGUF --gguf-file Q4_K_M --experimental --json-output
Files1
1 files · 11.1 KB

Select a file to preview

Overall Score

82/100

Grade

B

Good

Safety

85

Quality

82

Clarity

85

Completeness

75

Summary

A CLI wrapper skill that teaches users how to use `hf-mem` — a Hugging Face utility for estimating memory requirements for model inference without downloading weights. The skill provides syntax examples for Safetensors and GGUF models, including optional KV cache estimation via the `--experimental` flag.

Detected Capabilities

command execution (uvx)hugging face hub api access (implicit via hf-mem tool)environment variable reads (HF_TOKEN)http range requests (no download)json output parsing

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

estimate model memorycheck gpu vrammodel size inferencegguf memory requirementshuggingface hub modelkv cache memoryquantization memory footprint

Risk Signals

INFO

HF_TOKEN environment variable access for private/gated models

Requirements section
INFO

Network access to Hugging Face Hub via hf-mem tool

How to run section

Referenced Domains

External domains referenced in skill content, detected by static analysis.

www.apache.org

Use Cases

  • Estimate VRAM requirements before attempting GPU inference
  • Check if a model fits on a specific GPU or instance type
  • Calculate memory needs for both Safetensors and GGUF quantizations
  • Estimate KV cache memory for large language models and vision-language models
  • Compare memory footprints across different model precisions or quantizations

Quality Notes

  • Skill clearly documents when to use it with concrete user intents (memory estimates for GPU/instance)
  • Requirements section explicitly lists dependencies (uv installed, HF_TOKEN for gated models)
  • Well-structured examples covering three model architectures (Transformers, Diffusers, Sentence Transformers) plus GGUF variants
  • Explains the semantic difference between Safetensors and GGUF (sharded vs single-file) with guidance on file selection
  • Experimental flags documented with both Safetensors and GGUF variants including all supported KV cache dtypes
  • Context window and batch size parameters clearly tied to vLLM conventions
  • Output format (--json-output) consistently used across all examples for machine-readable results
  • No edge case documentation (e.g., how to handle models with no Safetensors/GGUF, or missing context window metadata)
Model: claude-haiku-4-5-20251001Analyzed: Jul 11, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Add huggingface/hf-mem to your library

Command Palette

Search for a command to run...