# modelread

> modelread is an MCP server for ai models and llm tooling. Checks whether a Hugging Face LLM fits your hardware, with speed ranges and launch. It runs as a hosted remote server, so there is nothing to install locally.

- **Kind:** MCP server
- **Platforms:** Web, API, CLI
- **Website:** https://modelread.com
- **MCP Registry name:** com.modelread/modelread
- **Categories:** [AI models and LLM tooling](https://ai-powered.com/categories/ai-and-llm)
- **Listing updated:** 2026-11-19

## About

The site reads real file sizes and tensor headers from a Hugging Face repo, then picks the quantization that fits a chosen device and reports an expected tokens-per-second range, the longest usable context, and a ready-to-run llama.cpp, vLLM or MLX command. Each speed figure is labeled by where it came from: measured on that device, calibrated, or an uncalibrated estimate.

Device coverage spans GPUs from several vendors, Apple Silicon, Jetson boards, phones, Raspberry Pi, and VPS or cloud instances priced per hour. Sizing for mixture-of-experts, sliding-window and hybrid architectures is based on the model's own weights and KV cache layout rather than a generic rule.

The same answers are exposed as an MCP server and as JSON, so coding agents such as Claude Code, Cursor or Codex can size a model and launch it on the user's behalf. It suits developers choosing a local model before downloading it, and people comparing one model across several machines.

## Features

- **Hardware fit check:** Estimates whether a given Hugging Face model fits a chosen GPU, Mac, phone or cloud instance.
- **Speed as ranges:** Shows tokens per second as a band tagged with whether it was measured, calibrated or estimated.
- **Best quantization pick:** Selects the quantization level that fits the device memory for the model.
- **Launch command output:** Generates the exact llama.cpp, vLLM or MLX command to run the model.
- **Cross-device comparison:** Compares one model across up to eight devices side by side.
- **MCP and JSON access:** Exposes the same estimates to coding agents over MCP and as JSON.

## Good for

- Check whether a model will fit on a laptop or phone before downloading it
- Compare how one model performs across several GPUs or cloud instances
- Find a suitable model for a task on a specific device
- Let a coding agent size and launch a local model

## Install

### Claude Code (Terminal)

```sh
claude mcp add --transport http modelread https://modelread.com/mcp
```

### Claude Desktop (Settings → Connectors → Add custom connector)

```sh
https://modelread.com/mcp
```

### Cursor (~/.cursor/mcp.json)

```json
{
  "mcpServers": {
    "modelread": {
      "url": "https://modelread.com/mcp"
    }
  }
}
```

### VS Code (.vscode/mcp.json)

```json
{
  "servers": {
    "modelread": {
      "type": "http",
      "url": "https://modelread.com/mcp"
    }
  }
}
```

### Windsurf (~/.codeium/windsurf/mcp_config.json)

```json
{
  "mcpServers": {
    "modelread": {
      "serverUrl": "https://modelread.com/mcp"
    }
  }
}
```

### Grok Bot (Grok Bot desktop app → Connect apps → Add a custom connector)

```sh
https://modelread.com/mcp
```

Enter a Name (for example "modelread"), choose Type: Remote HTTPS, paste this as the Server URL and choose Add plugin.

### Other clients (your client's MCP settings (most use this shape))

```json
{
  "mcpServers": {
    "modelread": {
      "type": "http",
      "url": "https://modelread.com/mcp"
    }
  }
}
```

## Tools

All 6 tools say they're read-only. From the server's own tool annotations; not verified by us.

- `estimate_fit` (says read-only): Will this Hugging Face repo run on this hardware? Checks the repo and its quantized derivatives (GGUF/MLX/AWQ...) and returns, per candidate: verdict (fits | fits-tight | offload | no | unknown), memory placement (VRAM / RAM / SSD), longest context that fits, decode and prefill tok/s bands with basis, concurrent-serving aggregate, runtime support (llama.cpp / vLLM / MLX registries) and an exact la
- `compare_hardware` (says read-only): Run one repo against several devices and return the best candidate per device (verdict, quant, decode band, max context, launch command), sorted best first. Use for 'which of my machines should run X' or 'is a 4090 or an M4 Max better for X'. hardware: comma-separated list of presets / free text (max 8).
- `find_models` (says read-only): Recommend models for a task on given hardware, written as a natural question, e.g. 'best coding model for an RTX 4090 + 64GB RAM at 32k context', 'Japanese chat on a Galaxy S25 Ultra', 'serve 8 users on 2x RTX 3090'. Ranks indexed Hub models (~20k, refreshed nightly) by fit, task benchmark percentile (provenance-tagged, vendor vs independent), speed and adoption; each result carries a full fit est
- `ask` (says read-only): Free-form question about running Hugging Face models locally or self-hosted (runtimes, quant choice, KV cache, why something OOMs, MoE offload); returns markdown plus the parsed query and notes.
- `search_models` (says read-only): Search the model index without estimating (fast): ids, task, library, params, downloads, likes, license, created date. task: chat|coding|vision|embedding|... ; query: substring of the repo id (e.g. 'qwen3', 'gemma-4'); max_params_billion filters by size.
- `list_hardware` (says read-only): List hardware presets (330+: GPUs of every vendor and segment, multi-GPU nodes, Apple, Jetson/APUs, phones, tablets, SBCs, VPS tiers). filter: words matched against id/name/vendor/segment, e.g. 'h100', 'amd datacenter', 'phone samsung', 'vps'. Returns id, name, kind, memory, bandwidth, backend.

## FAQ

### Which MCP transports does it support?

The registry entry lists streamable-http remotes at modelread.com/mcp and a Hugging Face Space endpoint.

### Which clients can connect to it?

The site says a single line adds it to Claude Code, and the Connect page covers Cursor, VS Code, Codex, Gemini CLI, Zed and LM Studio.

### Where do the file sizes come from?

The site says sizes are read from the repository's actual weights rather than estimated from the model name.

### How do I add modelread to Claude Code?

Run this command in your terminal: claude mcp add --transport http modelread https://modelread.com/mcp

### What are the best alternatives to modelread?

The closest alternatives to modelread are LLM Configurator, Model Tested, Quelllm MCP, StudioTV LLM VRAM Calculator and Local AI MCP.

## Where this comes from

- Description: written from the project's website and its MCP Registry entry.
- Status and tools: checked automatically by AIPoweredBot on 19 November 2026.
- Install steps: from the official MCP Registry entry.

## Alternatives

- [LLM Configurator](https://ai-powered.com/mcp/llm-configurator): LLM Configurator is a free MCP server for ai models and llm tooling.
- [Model Tested](https://ai-powered.com/mcp/model-tested): Model Tested is a free MCP server for ai models and llm tooling.
- [Quelllm MCP](https://ai-powered.com/mcp/quelllm-mcp): Quelllm MCP is an open-source MCP server for ai models and llm tooling.
- [StudioTV LLM VRAM Calculator](https://ai-powered.com/mcp/studiotv-llm-vram-calculator): StudioTV LLM VRAM Calculator is a free MCP server for ai models and llm tooling.
- [Local AI MCP](https://ai-powered.com/mcp/local-ai-mcp): Local AI MCP is an open-source MCP server for ai models and llm tooling.
- [AI Host Optimizer](https://ai-powered.com/mcp/ai-host-optimizer): AI Host Optimizer is an open-source MCP server for ai models and llm tooling.
- [AI Compute Radar](https://ai-powered.com/mcp/ai-compute-radar): AI Compute Radar is a free MCP server for ai models and llm tooling.
- [NoGPU](https://ai-powered.com/mcp/nogpu): NoGPU is a freemium MCP server for ai models and llm tooling.

---
Source: https://ai-powered.com/mcp/modelread
