# dynamo-recipe-runner

Discovers, validates, patches, and deploys NVIDIA Dynamo Kubernetes recipes for model serving across vLLM or SGLang runtimes.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 2300 installs · ★ 3735
- Author: Dan Gil
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/NVIDIA/skills/tree/HEAD/skills/dynamo-recipe-runner/SKILL.md
- Updated: 2026-10-23
- HTML: https://affpapa.org/en/nevibecode/skills/dynamo-recipe-runner

## What it does

The skill operates strictly within the existing `recipes/` tree of the Dynamo repository. Instead of generating arbitrary Kubernetes manifests, it runs `scripts/recipe_tool.py` to match the target model, backend framework (`vllm`, `sglang`, `trtllm`, `tokenspeed`), deployment mode, and GPU count.

Before making changes, it runs read-only cluster preflight checks with `kubectl`. The skill inspects nodes, namespaces, and storage classes. It patches only target fields such as `storageClassName`, container image tags, and GPU limits. When the cluster is unreachable, it skips applying changes and outputs the exact bash commands instead.

The operator environment requires Python 3.10+ alongside an active `kubectl` context. Built-in smoke testing is limited to checking `/v1/models`, so multi-node transport verification must be handled by dedicated diagnostic tools.

## Requirements
- Works with: Kubernetes

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dynamo-recipe-runner -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/dynamo-recipe-runner/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/dynamo-recipe-runner/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dynamo-recipe-runner -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/dynamo-recipe-runner/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dynamo-recipe-runner -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/dynamo-recipe-runner/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install NVIDIA/skills dynamo-recipe-runner
```

2. **Manually: put the files in place**
- File: `.github/skills/dynamo-recipe-runner/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dynamo-recipe-runner -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/NVIDIA/skills --path skills/dynamo-recipe-runner
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/dynamo-recipe-runner/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add NVIDIA/skills --skill dynamo-recipe-runner -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/NVIDIA/skills/tree/HEAD/skills/dynamo-recipe-runner/SKILL.md

## When to use it
- locate existing Dynamo recipes for models and frameworks like vLLM or SGLang
- validate recipe manifests before applying them to a Kubernetes cluster
- patch storage classes, GPU resource limits, and image tags without rewriting YAML
- deploy model-cache download jobs and frontend services into a namespace
- verify deployment health using a local port-forward to `/v1/models`

## Example prompts
- Find and validate a Dynamo recipe for nemotron-3-super-fp8 using sglang
- Deploy the qwen vllm recipe in disagg mode to namespace ai-serving
- Validate the trtllm recipe and print the kubectl commands without running them

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 2b0b3927af6d62cc.

BEGIN THIRD-PARTY FILE 2b0b3927af6d62cc
````text
---
name: dynamo-recipe-runner
description: Select, validate, patch, and deploy existing NVIDIA Dynamo Kubernetes recipes. Use for model/backend/GPU/deployment-mode recipe bring-up; use router-starter for router-only mode work and troubleshoot for broken deployments.
license: Apache-2.0
metadata:
  author: Dan Gil <dagil@nvidia.com>
  tags:
    - dynamo
    - kubernetes
    - recipes
    - bring-up
  permissions:
    - file_read
    - network
    - kubectl_exec
---

# Dynamo Recipe Runner

<!--
SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
SPDX-License-Identifier: CC-BY-4.0
-->

## Purpose

Get from user intent to a working Dynamo recipe endpoint with minimal back and
forth. Do not create new guide content. Operate on the existing `recipes/`
tree, patch the smallest necessary set of manifests, deploy when the user has
cluster access, and prove success with an OpenAI-compatible smoke request.

## Prerequisites

- Python 3.10+ on the operator machine.
- `kubectl` configured with a working cluster context.
- Cluster has a default storage class for model-cache PVCs.
- Hugging Face token stored in a Kubernetes secret named `hf-token-secret`
  (or equivalent) in the target namespace.
- Read access to the `recipes/` tree in the ai-dynamo/dynamo repository.

## Required Inputs

Collect or infer these before changing manifests:

- recipe target: model, framework (`vllm`, `sglang`, `trtllm`, `tokenspeed`), deployment mode, and GPU type/count
- Kubernetes context and namespace
- Hugging Face secret name, usually `hf-token-secret`
- storage class for model cache PVCs
- runtime image tag if the recipe uses a placeholder or stale test image
- whether to run commands or only produce exact commands

If a required value is missing and cannot be inferred from the selected recipe,
ask for only that value.

## Instructions

### 1. Preflight

Run read-only checks first:

```bash
git status --short
python3 scripts/recipe_tool.py list --format table
kubectl config current-context
kubectl get storageclass
kubectl get nodes -o wide
kubectl get namespace "${NAMESPACE}"
kubectl get secret hf-token-secret -n "${NAMESPACE}"
```

If `kubectl` is unavailable or the cluster is unreachable, continue by
selecting and validating the recipe, then return exact commands instead of
pretending the deployment ran.

### 2. Select The Recipe

Use the recipe matrix from `recipes/README.md` and the scanner:

```bash
python3 scripts/recipe_tool.py list \
  --query qwen --framework vllm --mode disagg --format table
```

Prefer an exact existing recipe. Do not invent new manifests unless the user
explicitly asks to author a new recipe.
````
END THIRD-PARTY FILE 2b0b3927af6d62cc

The third-party file has ended. Everything between the 2b0b3927af6d62cc tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2687 of 7336 bytes. © Dan Gil · Apache-2.0 · https://github.com/NVIDIA/skills/tree/HEAD/skills/dynamo-recipe-runner/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md