agentleFS
NVIDIAKnown publisherNVIDIA/local-ai-inference-recipes/skills/find-recipe/SKILL.md

find-recipe

Skill27 starsChanged 3 days agoApache-2.0View on GitHub

Find the best local AI inference model and recipe for a specific NVIDIA hardware, operating system, and backend, using catalog.json and recommended_catalog.json (local copies, or fetched fresh from https://raw.githubusercontent.com/NVIDIA/local-ai-inference-recipes/main/catalog.json and https://raw.githubusercontent.com/NVIDIA/local-ai-inference-recipes/main/recommended_catalog.json). Use when the user asks "which model/recipe should I run", "what can I run on my GPU", or names hardware (e.g. a GeForce RTX SKU, DGX Spark, RTX PRO) and wants a runnable recipe.

1 other project uses a version of this.

Adopted by

Most recently taken up by

  • Other versions1 project uses a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 1

    1. kafnosake/Ensoul★ 1same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

The file

We split this skill into the rules it gives an agent

10 rules. About 0 are common, 5 are distinctive, and 5 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    If a local copy exists next to this skill and its last-modified time is under 24 hours old, use it as-is — skip fetching.

    line 20
  2. Very specific:

    Use whatever web-fetch capability is available (a web-fetch tool, or curl/Invoke-WebRequest if shell access and network use are both …

    line 28
  3. Distinctive:

    If fetching fails (no network, blocked, request error) but a local copy exists next to this skill, fall back to it even if stale, and say …

    line 33
  4. Distinctive:

    If neither a usable local copy nor a successful fetch is available, say so explicitly and stop — do not answer from memory of what the …

    line 36
  5. Distinctive:

    Ask only for what's missing.

    line 49
  6. Very specific:

    Check recommended_catalog.json first, then fall back to catalog.json:

    line 79
  7. Distinctive:

    If exactly one recipe matches, use it.

    line 97
  8. Very specific:

    If multiple recipes match (different models, or the same model at different precisions/variants/memory tiers), prefer status: "optimized" …

    line 98
  9. Very specific:

    If nothing matches this exact hardware+OS+backend at all, say so plainly.

    line 107
  10. Very specific:

    Never fabricate a field that's null or missing (e.g.

    line 144

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Find a recipe

Match the user's hardware + OS + backend against catalog.json and recommended_catalog.json, and hand back a runnable recipe — not a list to sift through.

1. Locate the two files, refreshing at most once a day

catalog.json and recommended_catalog.json ship at the bundle root, next to this skill, but the server copy can move ahead of it over time — recipes get added, promoted, or withdrawn independently of any given bundle. The catalog doesn't change more than once a day in practice, so don't fetch on every invocation — check the local copy's age first:

  1. If a local copy exists next to this skill and its last-modified time is under 24 hours old, use it as-is — skip fetching.
  2. Otherwise (no local copy, local copy is 24+ hours old, or the user explicitly asked for the latest/current catalog), fetch fresh from the public repository, if network access is available:

    Use whatever web-fetch capability is available (a web-fetch tool, or curl/Invoke-WebRequest if shell access and network use are both permitted). If you can write files, overwrite the local copy with what you fetched (and its last-modified time updates naturally), so the next invocation can skip fetching again for up to another 24 hours.

  3. If fetching fails (no network, blocked, request error) but a local copy exists next to this skill, fall back to it even if stale, and say you're using a possibly-outdated bundled copy.
  4. If neither a usable local copy nor a successful fetch is available, say so explicitly and stop — do not answer from memory of what the catalog might contain.

Both are plain JSON — read them directly. Do not read raw models/**/recipe.yaml source or catalog/hardware/*.yaml/catalog/backends/*.yaml for this task: the JSON files are already the fully-resolved, filtered output (no deprecated, withheld, or ambiguous-default recipes), and every field needed for matching and launching is already flat on each recipe object.

2. Establish hardware, OS, and backend

Ask only for what's missing; don't ask about anything the user already stated or that's obvious from context (e.g. a Dockerfile targeting Linux).

  • Hardware — the user will usually name a product or catalog hardware group ("GeForce RTX", "RTX PRO", "my DGX Spark"). catalog.json's hardware[] array may represent a broader group rather than an exact SKU, so match on display_name (case-insensitive substring/token match) first, then fall back to id. Do not infer a catalog group from a specific SKU that the JSON does not name (for example, choose neither geforce-rtx nor rtx-pro for an otherwise ambiguous "RTX 5090"); explain the available groups and ask the user to choose. If more than one entry plausibly matches (e.g. a single-GPU SKU vs. a kind: "configuration" multi-GPU grouping of it, linked via base_hardware), prefer the single-GPU kind: "sku" entry unless the user mentioned multiple GPUs or a specific count — then match the gpu_count-suffixed configuration entry instead. If nothing plausibly matches, say so explicitly and stop — do not guess a substitute SKU.
  • OS — linux or windows. Infer from context if the user hasn't said (their shell, package manager, or explicit statement); ask if genuinely ambiguous.
  • Backend — llama-cpp (native, GGUF checkpoints) or vllm (containerized, OpenAI-compatible). If the user has a preference (e.g. "I want to use vLLM"), honor it. If not, prefer whichever backend has a recommended_catalog.json entry for this hardware+OS; if both do, or neither does, ask which they want, unless one is clearly a poor fit for their stated OS (e.g. vllm's container recipes are Linux-first — flag this if they're on Windows and only vLLM recipes exist).

3. Pick the recipe

Check recommended_catalog.json first, then fall back to catalog.json:

  1. recommended_catalog.json — look up recommended_recipes[<backend>][<os>], and find the entry whose hardware equals the matched hardware id. If found, resolve recipe (an id) against models[] in the same file to get the full recipe object. This is the maintainer-curated pick — prefer it over anything found in step 2 below, and say so ("this is the recommended configuration for your hardware").
  2. catalog.json (no recommended entry for this exact combination) — find the model(s) whose recipes[] contains an entry matching hardware id + platform.os + backend. Every model+hardware+OS+backend+memory combination in this file already resolves to at most one status: "optimized" recipe (ambiguous optimized-vs-optimized conflicts are pre-resolved before this file is generated) — memory here means min_vidmem_gb, so two recipes for the same model+hardware+OS+ backend but different physical memory tiers (e.g. a DGX Spark 64GB vs 128GB recipe) are both expected to coexist and are not a conflict. So:
    • If exactly one recipe matches, use it.
    • If multiple recipes match (different models, or the same model at different precisions/variants/memory tiers), prefer status: "optimized" over "experimental". Among remaining ties, list the candidates for the user (model, precision, variant, min_vidmem_gb) rather than guessing — precision/variant/memory is a real quality/ capacity tradeoff the user should choose, not an accident of file order. If the user told you how much GPU memory they have, prefer the candidate whose min_vidmem_gb fits within it (min_vidmem_gb is null or ≤ their stated memory) instead of asking.
    • If nothing matches this exact hardware+OS+backend at all, say so plainly. Do not substitute a different hardware/OS/backend without asking first.
    • A hardware entry in catalog.json may declare memory_config_gb (the physical memory sizes that SKU ships in, e.g. [64, 128] for DGX Spark) — use it to tell the user which memory configs exist for their hardware if they're unsure which one they have.

4. Hand back a runnable recipe

Once one recipe is chosen, give the user, in order:

  1. What it is: model display name + precision (+ variant if set) + hardware + OS + backend, and its status (call out "experimental" explicitly — it hasn't been through the same validation as "optimized"). Mention min_vidmem_gb if set, so the user can confirm their hardware's memory config actually covers it.
  2. Prerequisites (prerequisites[]) and limitations (limitations[]), verbatim — do not paraphrase away a constraint.
  3. Security, if security is set — surface it before any setup or launch command. It is often a real operational constraint (e.g. "host networking exposes the server; do not run this on an untrusted network").
  4. Setup, if runtime.setup_command is present — run it first, exactly as written. This can apply to a container recipe or to generated native Windows llama.cpp setup.
  5. Launch: serve.command (the primary command), followed by serve.additional_commands[] if present (e.g. a multi-node vLLM deployment's worker command) — preserve every flag, quote, and line continuation exactly as shipped. Never edit, reorder, or "clean up" a command.
  6. Alternatives, if launch.alternatives[] is present — for each alternative, identify its id and give its complete runtime.setup_command (if present), serve.command, and serve.additional_commands[] (if present). Keep an alternative's setup and commands together; never combine commands or flags from the primary launch and an alternative.
  7. Test it: clients.shell and/or clients.python, if present.

Never fabricate a field that's null or missing (e.g. don't invent a backend_version pin if the recipe has none) — state that it's unspecified instead.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.