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., "@gguf-mcp What quant is this GGUF and how much VRAM does it need?"
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.
An MCP server that inspects local model files — GGUF and safetensors — so Claude and other LLMs can answer questions about the models on your disk:
"What is this .gguf? Architecture, quantization, parameter count?"
"Will this model fit in my 12 GB GPU at 8k context?"
"What tensors are inside, with what shapes?"
"Show me its chat template / RoPE settings / tokenizer config."
Headers only. The parser never touches tensor data, so inspecting a 70 GB model takes milliseconds and a few MiB of I/O. No network, no API keys, no telemetry — your files never leave your machine.
Claude Code
claude mcp add gguf -- npx -y gguf-mcpClaude Desktop — add to claude_desktop_config.json:
{
"mcpServers": {
"gguf": {
"command": "npx",
"args": ["-y", "gguf-mcp"]
}
}
}The same npx invocation works in Cursor, Windsurf, and any other MCP client.
Related MCP server: cancerbero
Tool | What it does |
| One-call summary: format, architecture, parameters, quantization, context length, file size, tensor count |
| Tensor names, shapes, and storage types — filterable ( |
| Fit check: exact weights size + modeled fp16 KV cache for your chosen context length |
| The GGUF key-value store (or safetensors |
Paths can be a .gguf file, a .safetensors file, a *.safetensors.index.json, or a model directory (sharded HuggingFace layouts are aggregated across shards). Extension-less GGUF blobs — like the ones in Ollama's ~/.ollama/models/blobs — are detected by magic bytes.
Context-friendly by construction. A tokenizer vocabulary is 100k+ strings; metadata arrays are returned as {count, sample} summaries and long strings (chat templates) are truncated with a marker. The full data stays on disk where it belongs.
Honest estimates. estimate_vram reports exact on-disk weight bytes plus the standard KV-cache formula (2 × layers × context × KV heads × head dim × 2 bytes), and says what it excludes rather than faking precision.
Defensive parsing. Magic checks, version checks (incl. big-endian detection), truncation detection, and sanity caps on header sizes — malformed files produce specific, actionable errors.
Zero runtime dependencies beyond the MCP SDK and zod. The GGUF binary reader and safetensors parser are hand-rolled and unit-tested against synthetic files built in the test suite — no fixtures, no downloads.
npm install
npm test # offline unit tests (vitest) — synthetic model files
npm run build # tsc → dist/
node scripts/smoke.mjs # end-to-end: generates models, drives the server over stdioArchitecture: src/gguf.ts (binary header parser + VRAM math) and src/safetensors.ts (JSON header + shard index) are pure logic with no MCP imports; src/index.ts is the MCP wiring and path/format detection.
Tensor statistics (would require reading data), PyTorch .bin (pickle — unsafe by design), ONNX, and remote HuggingFace queries (HuggingFace has an official MCP server for that).
MIT
Will this model fit? Estimates memory as exact weights size plus a modeled fp16 KV cache (GGUF; context defaults to min(model context, 8192)). Safetensors models get a weights-only figure.
Inputs: path (required), context_length.
The model's metadata key-value store (GGUF) or metadata block (safetensors). Large arrays arrive as {count, sample} summaries and long strings are truncated, so tokenizer vocabularies can't flood the context. Filter keys by substring (e.g. 'tokenizer' or 'rope').
Inputs: path (required), filter.
Summarize a local GGUF or safetensors model: architecture, parameter count, quantization, context length, file size, tensor count. Reads only headers — inspecting a 70 GB model is instant. Works on extension-less GGUF blobs (e.g. Ollama's).
Inputs: path (required).
Tensor names, shapes, and storage types inside a model file. Filter by substring (e.g. 'attn' or 'blk.0').
Inputs: path (required), limit, filter.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 4 tools
Each tool targets a distinct aspect of model file inspection: summarize, list tensors, estimate VRAM, and get metadata. No overlap in purpose.
All tool names follow a consistent verb_noun pattern (inspect, list, estimate, get), making the set predictable and easy to navigate.
Four tools is well-scoped for a specialized inspection server, covering core operations without bloat or gaps.
The tool set fully covers the domain of local model file inspection: overview, detailed tensors, VRAM fitting, and metadata. No obvious missing operations.
Will this LLM fit on your GPU, multi-GPU rig or Mac? Exact VRAM & KV-cache math. Read-only.
Read-only: which local LLMs a GPU or Mac can run - VRAM fit, tokens/sec, model specs.
Search open model file records, inspect recorded SHA-256 hashes and license labels, and check estimated memory fit. Public reads need no account. Connect over Streamable HTTP. Public board and request tools require user consent. A matching hash checks bytes; fit and license labels do not establish successful execution or permission for every use. Hosted MCP: https://huggingbay.xyz/api/mcp Install: npx -y hugging-bay-mcp@0.1.13 Docs: https://huggingbay.xyz/docs Repository: https://github.com/barneywohl/hugging-bay
Can this LLM run on my GPU? VRAM, speed ceiling and what fits instead, for any model and GPU.
