Koskamo

modelread MCP

A hardware-aware fit checker for Hugging Face models that determines if a model runs on specific hardware, identifies the best quantization, estimates tokens per second, and provides exact launch commands for inference engines like llama.cpp, vLLM, or MLX.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

modelread MCP logo, by modelreadVendor evidenceStreamable HTTPNo sign-inEndpoint checked 2026-11-19Operated by modelread
MCP endpoint (Streamable HTTP)
https://modelread.com/mcp
Vendor documentation

What its tools do

6 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

6 of 6 have a description · 6 of 6 declare behavior hints · 0 of 6 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Passed Official MCP Registry namespace is tied to modelread.com ·
  • Passed Endpoint is on the registry namespace domain ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Check if a Hugging Face model fits on a specific device
  • Find the best quantization for a model on given hardware
  • Estimate inference speed (tokens/sec) for a model
  • Generate exact launch commands for model serving

Source and maintenance

Vendor evidenceRegistry 0.3.1

Protocol and capabilities

Server
modelread 0.3.0
MCP protocol negotiated in check
2025-11-25
Tools
6 advertised
Resources
1 advertised
Resource templates
0 advertised
Prompts
3 advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": false
  },
  "prompts": {
    "listChanged": false
  },
  "resources": {
    "subscribe": false,
    "listChanged": false
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Use modelread whenever the user asks whether a Hugging Face / open-weights model will run on a GPU, Mac, phone, multi-GPU node or cloud instance; how many tokens/sec to expect; which GGUF/MLX/AWQ/FP8 quant fits in VRAM; how much context fits; what to run on a given machine; or needs a llama.cpp / vLLM / MLX / Ollama launch command (also before downloading, quantizing or serving a model). modelread: will a Hugging Face model run on given hardware, how fast, which quant, with what command. Numbers come from real repo file sizes, GGUF/safetensors tensor headers and configs (nothing is downloaded), plus calibration measured on real devices. Pick the tool by the question: - a specific repo + one device -> estimate_fit - a specific repo + several devices ('which of my machines') -> compare_hardware - 'what should I run on X for task Y' -> find_models - anything else (runtimes, KV cache, why it OOMs) -> ask - just listing/searching models -> search_models; device ids -> list_hardware (use a filter). Hardware can be a preset id (rtx4090, m4max-128, 8x-h100-sxm, iphone-17pro-12, rpi5-8, vps-4vcpu-8gb), any '<N>x-<gpu id>' multi-GPU spec, free text ('two RTX 3090s', 'MacBook Pro M3 Max 128GB', 'Galaxy S25 Ultra'), or 'gpu=24,ram=64,bw=936' / 'unified=1,ram=96,bw=256'. Speeds are bands (lo/mid/hi) with their basis; decode_tps.aggregate gives concurrent-serving throughput at 1-32 parallel sequences. Respect 'verdict', 'unknowns' and 'confidence': never present an 'unknown' verdict as a fit, and quote the band, not just mid.

Tools

6 advertised

estimate_fit — Estimate model fit and speed
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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 launch command. repo: 'org/name' (base model or a GGUF repo). hardware: preset id, '<N>x-<id>', free text, or 'gpu=..,ram=..,bw=..'. ctx in tokens.

estimate_fit input schema
{
  "type": "object",
  "title": "estimate_fitArguments",
  "required": [
    "repo",
    "hardware"
  ],
  "properties": {
    "ctx": {
      "type": "integer",
      "title": "Ctx",
      "default": 8192
    },
    "repo": {
      "type": "string",
      "title": "Repo"
    },
    "ram_gb": {
      "anyOf": [
        {
          "type": "number"
        },
        {
          "type": "null"
        }
      ],
      "title": "Ram Gb",
      "default": null
    },
    "hardware": {
      "type": "string",
      "title": "Hardware"
    },
    "include_vision": {
      "type": "boolean",
      "title": "Include Vision",
      "default": false
    },
    "kv_cache_dtype": {
      "type": "string",
      "title": "Kv Cache Dtype",
      "default": "f16"
    },
    "check_quantized_derivatives": {
      "type": "boolean",
      "title": "Check Quantized Derivatives",
      "default": true
    }
  }
}
estimate_fit annotations
{
  "title": "Estimate model fit and speed",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
compare_hardware — Compare one model across devices
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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).

compare_hardware input schema
{
  "type": "object",
  "title": "compare_hardwareArguments",
  "required": [
    "repo",
    "hardware"
  ],
  "properties": {
    "ctx": {
      "type": "integer",
      "title": "Ctx",
      "default": 8192
    },
    "repo": {
      "type": "string",
      "title": "Repo"
    },
    "hardware": {
      "type": "string",
      "title": "Hardware"
    }
  }
}
compare_hardware annotations
{
  "title": "Compare one model across devices",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
find_models — Find the best models for a device
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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 estimate. Tasks understood: chat, coding, agentic, vision, ocr, math, reasoning, multilingual, function-calling, embedding, reranking, speech-to-text, tts, image-generation, video-generation.

find_models input schema
{
  "type": "object",
  "title": "find_modelsArguments",
  "required": [
    "question"
  ],
  "properties": {
    "question": {
      "type": "string",
      "title": "Question"
    }
  }
}
find_models annotations
{
  "title": "Find the best models for a device",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
ask — Ask about running models
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

ask input schema
{
  "type": "object",
  "title": "askArguments",
  "required": [
    "question"
  ],
  "properties": {
    "question": {
      "type": "string",
      "title": "Question"
    }
  }
}
ask annotations
{
  "title": "Ask about running models",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
search_models — Search the model index
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

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.

search_models input schema
{
  "type": "object",
  "title": "search_modelsArguments",
  "properties": {
    "task": {
      "type": "string",
      "title": "Task",
      "default": "chat"
    },
    "limit": {
      "type": "integer",
      "title": "Limit",
      "default": 20
    },
    "query": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Query",
      "default": null
    },
    "max_params_billion": {
      "anyOf": [
        {
          "type": "number"
        },
        {
          "type": "null"
        }
      ],
      "title": "Max Params Billion",
      "default": null
    }
  }
}
search_models output schema
{
  "type": "object",
  "title": "search_modelsOutput",
  "required": [
    "result"
  ],
  "properties": {
    "result": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": true
      },
      "title": "Result"
    }
  }
}
search_models annotations
{
  "title": "Search the model index",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
list_hardware — List hardware presets
Advertised by the server during the last successful anonymous check.
Advertised 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.

list_hardware input schema
{
  "type": "object",
  "title": "list_hardwareArguments",
  "properties": {
    "limit": {
      "type": "integer",
      "title": "Limit",
      "default": 40
    },
    "filter": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "title": "Filter",
      "default": null
    }
  }
}
list_hardware output schema
{
  "type": "object",
  "title": "list_hardwareOutput",
  "required": [
    "result"
  ],
  "properties": {
    "result": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": true
      },
      "title": "Result"
    }
  }
}
list_hardware annotations
{
  "title": "List hardware presets",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

3 advertised

will_it_run — Will it run?

Advertised by the server during the last successful anonymous check.

Check whether a model fits a device and how to launch it.

repo
No description (required)
hardware
No description (required)
ctx
No description
best_for_my_machine — Best model for my machine

Advertised by the server during the last successful anonymous check.

Rank models for a task on a device.

task
No description (required)
hardware
No description (required)
ctx
No description
size_a_server — Size a server

Advertised by the server during the last successful anonymous check.

Pick hardware and settings to serve a model to many users.

repo
No description (required)
users
No description
candidates
No description

Resources

1 advertised

hardware_catalog — Hardware catalog

Advertised by the server during the last successful anonymous check.

Every device preset (id, name, kind, segment, memory, bandwidth, backend) as JSON.

hardware_catalog URI
modelread://hardware

MIME type: application/json

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (11 of 11 answered).

  1. 2026-11-19: 3 of 3 checks answered
  2. 2026-11-20: 3 of 3 checks answered
  3. 2026-11-21: 4 of 4 checks answered
  4. 2026-11-22: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
792 ms
95th percentile latency
792 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 792 ms · metadata changed · 6 tool(s), 1 resource(s), 0 resource template(s), 3 prompt(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http modelread-mcp https://modelread.com/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add modelread-mcp --url https://modelread.com/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable modelread-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "modelread-mcp": {
      "url": "https://modelread.com/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "modelread-mcp": {
      "type": "streamableHttp",
      "url": "https://modelread.com/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start modelread-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "modelread-mcp": {
      "type": "http",
      "url": "https://modelread.com/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http modelread-mcp https://modelread.com/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://modelread.com/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "modelread-mcp": {
      "serverUrl": "https://modelread.com/mcp"
    }
  }
}

Let your agent find its tools

Find servers like modelread MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Do you run modelread MCP?

Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.

Claim this listing