Where My Hug At?

Tell your AI agent what you want a model to do. It searches Hugging Face for each part of the job and tells you which parts already exist there: which are an exact fit, which to fine-tune, which to train, and which are just code. Every model it names is real, current, and sized for your hardware.

Works with Claude Code, Codex, Copilot, Cursor, Gemini CLI, Cline, Devin, Open WebUI and any other MCP client, or as an Agent Skill.

Its companion, Git for Me, does the same for open-source repos on GitHub, GitLab and Codeberg.

Contents

• Try it
• How it works: four questions · parts · the search · verdicts · the live check · flags · sizes
• Example: recipe cards
• Install (every agent, step by step: USAGE.md)
• What leaves your machine · Limits · Security
• Development · License

Try it

Add it to your agent (Claude Code here; every other option below):

claude mcp add --scope user where-my-hug -- npx -y where-my-hug

Then ask:

Where my hug at for transcribing handwritten recipe cards?

Your agent asks the few things it can't guess, splits the job into parts, and comes back with a report like the one below, every model and dataset in it looked up on Hugging Face moments before. It works for any job a model might do:

Where my hug at for spotting which birds visit my feeder camera?
Where my hug at for sorting support emails by how urgent they are?
Where my hug at for pulling the totals off scanned receipts?

How it works

1. Four questions first

Ask for "a model that reads handwriting" and you get whatever is popular: often too big for your GPU, under a license you can't ship, or in a format your code can't load. So before anything is named, four details come first. Your agent fills in what the conversation or your codebase already says, and asks you the rest:

"Not sure yet" is a fine answer: the picks then cover the range, and every model shows the memory it needs, so the report helps you decide.

2. Split the job

The agent breaks the need into parts, each with an input and an output (photo → text, text → fields). A part that isn't a model's job (rules, geometry, parsing, lookups) is marked WRITE: code does it exactly. Most needs have one. A model doing work that code does exactly is a cost, not a feature.

3. Search Hugging Face for each part

What an agent remembers of Hugging Face is as old as its training, and misses the long tail. So nothing is picked from memory. For every other part, the agent writes a search (the Hub's task tag, a few keywords, the job in a few words), and it runs four ways:

The ways take turns in the results, so a niche fine-tune isn't buried under whatever is popular for the task.

4. Decide each part from what turned up

The agent judges the results by what they say: task, card, downloads, age. It may add a model it knows that the search missed, but that pick ranks after the search's, and the report marks it from memory.

5. Check every pick

Every pick is looked up on Hugging Face, live. Any that don't exist are dropped, and the agent goes back to the search for others. The rest are flagged for what would bite later and sized against your compute, and that report is what you see. It also lists what the search found that wasn't picked, so nothing it turned up is hidden. A TRAIN part whose search found models says to check them before training one. Every fact in the report (license, size, downloads, freshness) comes from Hugging Face.

Under the hood it's an MCP server with three tools: where_my_hug for the method (steps 1, 2 and 4), where_my_hug_search for step 3, and where_my_hug_verify for step 5.

Flags

Sizes: what runs here, and what might do better

Every model shows the memory it needs to run: 2.4 bytes per parameter, half precision plus room for activations. A model to fine-tune also shows what that takes: about 1 byte per parameter with QLoRA, 16 in full. Against the compute you gave (its first "N GB"):

• The first model that fits heads its part.
• Bigger ones follow under "If you can make it work": the search's picks first, then any from memory. A stretch fits only quantized to 4 bits (0.6 bytes per parameter), or on a bigger GPU. Cloud needs more than that: the report names the providers serving it on Hugging Face, or says rented GPUs.
• A part where nothing fits still shows its bigger options. It isn't sent back for replacements, since the hardware might be found.

A model named as a dataset (or the other way round) is found under the right kind. Licenses come from the card's metadata: license, license_name for custom terms (reported as other (qwen-research)), or a license: tag.

Example: recipe cards

The prompt above, from a live run on 2026-10-14 for one 24 GB GPU (abridged):

_Searched and checked on Hugging Face just now: 7 named, 1 from memory rather than the search, 0 not there and dropped._

## USE  ·  Read the card
**Model: zai-org/GLM-OCR**
license mit · 1.3B parameters (~3.2 GB to run) · 1.7M downloads a month · found: name has ocr, most downloaded for image-to-text
If you can make it work, bigger than one 24 GB GPU:
- Qwen/Qwen3.8-27B: a stretch: ~66.7 GB to run, ~16.7 GB quantized to 4 bits, hosted by novita, cerebras, …
- google/gemma-4-31B-it: a stretch: ~75.1 GB to run, ~18.8 GB quantized to 4 bits, hosted by novita, …
Also: deepseek-ai/DeepSeek-OCR
The search also found, not picked:
- google/gemma-4-26B-A4B-it (11.3M downloads a month): found as most downloaded for image-text-to-text
- openbmb/MiniCPM-V-4.7-35B-A3B (4.2k downloads a month): found as trending for image-text-to-text

## TUNE  ·  Read the hard hands
**Model: microsoft/trocr-base-handwritten**
license mit · 333.3M parameters (~0.8 GB to run; to fine-tune, ~0.3 GB with QLoRA, ~5.3 GB in full) · found: name has handwritten
**Data: Voxel51/iam_handwriting_finevision**
license cc · 1.9k downloads a month · found: name has handwriting
Also: Teklia/IAM-line (stale, from memory)

## WRITE  ·  Parse the amounts
No model: write this one.

Every model there was turned up by the search, including ones released this year. The one dataset the agent added from what it remembered is marked.

Install

Needs Node 22.18 or later. USAGE.md has step-by-step setup and links for 20+ agents: Claude Code and Desktop, Codex, Copilot (CLI and VS Code), Cursor, Windsurf, Devin, Cline, Gemini CLI, Goose, OpenCode, Zed, Junie, Kiro, Amp, Warp, Continue, LM Studio, Hermes, Mistral Vibe and Open WebUI. The quick routes:

Claude Code, Codex, Copilot CLI, as a plugin: the tools, plus a skill that knows when to reach for them. One marketplace serves all three.

/plugin marketplace add bikemeardsley/where-my-hug          # Claude Code
/plugin install where-my-hug@where-my-hug

codex plugin marketplace add bikemeardsley/where-my-hug      # Codex
codex plugin add where-my-hug@where-my-hug

copilot plugin marketplace add bikemeardsley/where-my-hug    # Copilot CLI
copilot plugin install where-my-hug@where-my-hug

Any other MCP client: a stdio server in the client's config. Most call the key mcpServers (USAGE.md has the exceptions).

{ "mcpServers": { "where-my-hug": { "command": "npx", "args": ["-y", "where-my-hug"] } } }

Gemini CLI, as an extension: gemini extensions install https://github.com/bikemeardsley/where-my-hug

As an Agent Skill, for agents that read SKILL.md: npx skills add bikemeardsley/where-my-hug.

HF_TOKEN (optional). Everything public works without one. To include private or gated repos your account can see, pass a Hugging Face token as HF_TOKEN (how, per agent); the Claude Code plugin asks for it and keeps it in secure storage. Without a token, a private repo looks missing, because Hugging Face answers 401 for both.

What leaves your machine

The search the agent writes for each part (a task tag, keywords, a few words about the job) and the ids it picks, as GETs to huggingface.co/api, plus your token if you set one. The token is sent only there and never appears in a report. The need as you wrote it, the method and the report stay between you and your agent.

Starting it with npx (as the MCP server, or the skill's shell fallback) downloads the where-my-hug package from the npm registry, registry.npmjs.org. Nothing is sent there but the request for the package.

Limits

• Sizes come from safetensors metadata. Repos with only GGUF or .bin weights show no parameter count, so they can't be sized against the compute.
• License flags read the card's metadata, not the license text.
• The search finds what the Hub's own search can: names and tags, and the text of cards. A model with an unrelated name and a bare card can still be missed.
• Card text is searched through the API behind the Hub's search page, which isn't documented. If it changes, that way fails and the results say so; the other three carry on.

Security

Report a vulnerability privately through GitHub Security Advisories, not a public issue. SECURITY.md lists what it touches: GETs to Hugging Face, and nothing on your machine.

Development

node src/server.ts   # the server, straight from source
npm test             # offline: Hugging Face is mocked, and the server is driven over stdio and HTTP
npm run check        # types

npm install also builds JavaScript into build/, which is what npx runs: Node won't strip types from a package inside node_modules.

License

MIT