doca-rmax — Claude Code skill: ST 2110 stream debugging
doca-rmax — a skill for debugging precision-timed media stream reception (SMPTE ST 2110, market data, scientific feeds) on BlueField DPU via DOCA Rivermax. Helps when packets don't arrive, jitter spikes, or license validation fails.
Apache-2.0 ★ 4,106 updated 2026-10-23
npx skills add NVIDIA/skills --skill doca-rmax -a claude-codeWhat doca-rmax does
doca-rmax serves developers working with Rivermax apps that run exclusively on BlueField DPU. The skill covers stream object setup (doca_rmax_in_stream), precondition checks (Rivermax SDK and license installed separately), capability queries (doca_rmax_get_*_supported), pairing with doca-eth queues and doca-flow steering, and error diagnosis from DOCA_ERROR_* calls.
For the skill to work, Rivermax libraries (doca-sdk-rmax) and a valid license must already be installed on the target DPU—this is separate from DOCA and requires a distinct installation path. The skill declines to help with queue programming (handled by doca-eth), steering rules (doca-flow), clock sync (doca-firefly), or plain packet I/O.
Trigger the skill on phrases like "ST 2110 receive gets no frames", "sub-microsecond jitter on the receiver", "NOT_SUPPORTED from doca_rmax_init", or "license check failing"—even without explicitly naming Rivermax.
What it helps with
- diagnose why a Rivermax stream stops receiving packets
- check if device supports the needed receive mode (PTP, packet placement)
- decode NOT_SUPPORTED or other DOCA_ERROR_* from init
- configure a receive session for SMPTE ST 2110 video or audio on DPU
- verify Rivermax SDK and license are present before first run
Example prompts for the agent
- My Rivermax stream starts but recv events never fire—help me debug
- Does this hardware support ST 2110-20 with sequence-number placement?
- doca_rmax_init returns NOT_SUPPORTED—what's wrong with the SDK or license?
How to install doca-rmax
1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-rmax -a claude-code2Manually: put the files in place
~/.claude/skills/doca-rmax/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/doca-rmax/
1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-rmax -a codex2Manually: put the files in place
.agents/skills/doca-rmax/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-rmax -a cursor2Manually: put the files in place
.cursor/skills/doca-rmax/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install NVIDIA/skills skills/doca-rmax2Manually: put the files in place
.github/skills/doca-rmax/SKILL.md1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-rmax -a gemini-cli2Platform CLI
gemini skills install https://github.com/NVIDIA/skills --path skills/doca-rmaxManually: put the files in place
.devin/skills/doca-rmax/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about doca-rmax
How do I install doca-rmax in Claude Code?
Run npx skills add NVIDIA/skills --skill doca-rmax -a claude-code, then open ~/.claude/skills/doca-rmax/SKILL.md.
What does doca-rmax do?
It helps debug reception of precision-timed media streams (ST 2110, market data, scientific feeds) on BlueField DPU using DOCA Rivermax. Checks SDK and license preconditions, diagnoses errors, advises which capability queries to run before changing stream setup.
What do I need to use doca-rmax?
DOCA SDK 3.5+ on target BlueField DPU (Ubuntu 22.04/24.04, RHEL, SLES), plus separately installed Rivermax libraries (doca-sdk-rmax) and a valid Rivermax license. Validation requires a working DOCA installation.
Source text
SKILL.md · Apache-2.0
--- license: Apache-2.0 name: doca-rmax description: > DOCA Rivermax (doca_rmax) receive streams for timing-precise media over IP (SMPTE ST 2110 video / audio, market data, scientific feeds) on a target BlueField DPU (DOCA Rivermax apps run only there), once the Rivermax libraries and license are installed; getting them is doca-setup / doca-public-knowledge-map territory. Trigger on "ST 2110 receive isn't getting frames", "sub-microsecond jitter on my media receiver", "NOT_SUPPORTED from doca_rmax_init", "no recv events after stream start", or "license check failing on a media receiver", even without naming Rivermax. Covers doca_rmax_in_stream sessions, the SDK + license precondition check, doca_rmax_get_*_supported capability queries, pairing with doca-eth queues and doca-flow steering, and DOCA_ERROR_* from Rivermax calls. Refuse and route elsewhere for programming the underlying queue (doca-eth), steering rules (doca-flow), PTP / clock sync (doca-firefly), or best-effort packet I/O. metadata: author: NVIDIA <[email protected]> kind: library doca_version: "3.5" tags: - doca - rmax - rivermax compatibility: > Requires DOCA SDK at /opt/mellanox/doca on Linux (Ubuntu 22.04/24.04 or RHEL/SLES) on the target BlueField DPU (DOCA Rivermax apps run only there), with `doca-sdk-rmax` from the DOCA repo AND a separately obtained Rivermax license readable by the user. Reads the local install via `pkg-config doca-rmax`; route Rivermax SDK install/license questions to the public Rivermax guide. The validation steps require a live DOCA install. --- # DOCA Rivermax ## Examples - **"ST 2110 receive isn't getting frames."** — this is in scope after Rivermax SDK + license are already present. - **"How do I obtain / install the Rivermax SDK and its license?"** — out of scope for this skill. Say so, give no install or licensing steps, and route: DOCA packages to `doca-setup/SKILL.md`, the Rivermax SDK + license to the public DOCA Rivermax guide via `doca-public-knowledge-map/SKILL.md`. Come back here once both are present. - **"NOT_SUPPORTED from doca_rmax_init."** — run the `doca_rmax_get_*_supported` queries before changing stream setup. ## Instructions Follow Loading order below. Open the tasks companion for configure / stream / debug. Open the capabilities companion for Rivermax preconditions. Do not open every companion file. **Where to start:** This skill assumes DOCA is already installed on the target BlueField DPU (DOCA Rivermax apps run only on the target DPU), **AND** that the Rivermax libraries (`doca-sdk-rmax` / `libdoca-sdk-rmax-dev` from the DOCA repo) are installed with a valid Rivermax license present on the DPU. The agent's FIRST action on any Rivermax question is to confirm both — without the Rivermax libraries + license, `doca-rmax` cannot function regardless of how clean the DOCA-side code is, and this is the #1 first-app confusion (the Rivermax license, and the driver per the Rivermax SDK page, are obtained separately from DOCA). Open the tasks companion if the user wants to *do* something (configure / build / modify / run / test / debug); open the capabilities companion when the question is *what can DOCA Rivermax express* on this version + this Rivermax install. If the user has not installed DOCA yet, route to `doca-setup/SKILL.md` first; for the Rivermax SDK + license install itself, route to the public DOCA Rivermax guide (slug `DOCA-Rivermax`) via `doca-public-knowledge-map/SKILL.md`. If the user is asking *"how do I get packets to land on my Rivermax input stream at all"*, the answer is layered: `doca-rmax` is the *Rivermax integration* surface, `doca-eth/SKILL.md` is the *queue* surface that carries the packets, and `doca-flow/SKILL.md` is the *steering* surface that directs them. ## Example questions this skill answers well The CLASSES of DOCA Rivermax questions this skill is built to answer, each with one worked example. The agent should treat the *class* as the load-bearing piece — the worked example is a single instance. - **"Can I even use `doca-rmax` on this host?"** — worked example: *"the public docs mention `doca-rmax`; is it usable without doing anything else?"*. Answered by the Rivermax-SDK + license precondition rule in ## Safety policy + the env-prep checklist in ## configure step 1, which routes the install-side question to the public Rivermax guide via `doca-public-knowledge-map/SKILL.md` and refuses to recommend a fallback to `doca-eth` alone that would silently lose the timing properties. - **"How do I set up a SMPTE ST 2110 video receive stream?"** — worked example: *"line up an inbound Rivermax stream on a representor of a BlueField port for first-run testing"*. Answered by the per-stream object lifecycle in ## configure + ## Capabilities and modes input stream capability table. - **"Which `doca_rmax_get_*_supported` query do I have to call before picking a PTP clock or hardware packet-placement order?"** — worked example: *"can this device + this Rivermax install use ST 2110-20 sequence-number placement?"*. Answered by the capability-query rule in ## Capabilities and modes + step 3 in ## configure. - **"My stream is set up but no packets arrive — why?"** — worked example: *"the Rivermax stream object started cleanly but no recv events fire"*. Answered by the precondition matrix in ## Safety policy + the env-prep checklist in ## configure step 1, which routes the steering side to `doca-flow/SKILL.md`, the queue side to `doca-eth/SKILL.md`, and the license side back to the Rivermax-side precondition. - **"Is this Rivermax integration capability available on my device + my installed DOCA + my Rivermax SDK?"** — worked example: *"does this device + this Rivermax version advertise the PTP clock or placement mode I need"*. Answered by the capability-query rule in ## Capabilities and modes + the version-and-device overlay in ## Version compatibility, which adds the *Rivermax-side version is a second axis* rule on top of the canonical DOCA version-handling chain in `doca-version/SKILL.md`. - **"What does this `DOCA_ERROR_*` from a Rivermax call mean and which layer caused it?"** — worked example: *"`DOCA_ERROR_NOT_SUPPORTED` from `doca_rmax_init()`"*. Answered by the Rivermax overlay on the cross-library taxonomy in ## Error taxonomy + the layered ladder in ## debug that escalates to `doca-debug/SKILL.md`, and which preserves the installed header's call-specific mapping: init-time `_NOT_SUPPORTED` routes first to Rivermax SDK / license checks; later errors are interpreted from the exact failing call rather than generalized into a license diagnosis. ## Audience This skill serves **external developers building applications that consume the DOCA Rivermax integration** — i.e., users whose code calls `doca_rmax_*` (directly in C/C++, or through FFI/bindings from another language) to drive timing-precise media-over-IP streams (SMPTE ST 2110, real-time market data, high-throughput scientific instrument streams) on top of a separately-installed NVIDIA Rivermax SDK on a BlueField or ConnectX host. It is *not* for NVIDIA developers contributing to DOCA Rivermax itself, and it is *not* for users who want best-effort packet I/O — for that, route to `doca-eth/SKILL.md` directly. **Language scope.** DOCA Rivermax ships as a C library with `pkg-config` module name `doca-rmax`. The shipped samples live under `/opt/mellanox/doca/samples/doca_rmax/` and are written in C. C and C++ consumers are the canonical case; the worked examples in the tasks companion assume that path. Other-language consumers (Rust, Go, Python, …) consume the same `*.so` through FFI or language-specific bindings; the skill's contribution in that case is to keep the precondition rule (Rivermax SDK + license), per-stream lifecycle, capability-discovery, permission, scheduling-discipline, and error-taxonomy guidance language-neutral, and to route the agent to the public C ABI as the authoritative surface that any wrapper will eventually call. ## When to load this skill Load this skill when the user is doing hands-on DOCA Rivermax work, in any language. Concretely: - Confirming that the NVIDIA Rivermax SDK and a valid Rivermax license are present on the host before any DOCA-side code is written — this is a **mandatory precondition**, not an error path; without it the answer is *"`doca-rmax` cannot be used; pick a different library"*, not *"let's try and see what fails"*. - Initializing the global DOCA Rivermax engine with `doca_rmax_init()` / `doca_rmax_release()`, then creating a `doca_rmax_in_stream` (receive) context with `doca_rmax_in_stream_create()` on a `doca_dev` opened against a physical port, a representor, or an SF, and converting it via `doca_rmax_in_stream_as_ctx()` before `doca_ctx_start()`. The public DOCA Rivermax API is receive-only — there is no transmit/output stream object. - Configuring a Rivermax input stream for SMPTE ST 2110 audio + video over IP, real-time market data feeds, or a scientific instrument stream — with awareness that PTP-clock and hardware packet-placement-order support are device- and Rivermax-conditional and gate on the matching `doca_rmax_get_*_supported` query. - Reading or setting Rivermax stream properties via `doca_rmax_in_stream_set_*` and querying device + Rivermax capability via the `doca_rmax_get_*_supported` family before assuming PTP-clock or hardware packet-placement-order support. - Pairing the Rivermax stream with the `doca-eth` queue surface that carries the packets and the `doca-flow` rules that steer them — Rivermax does not program steering itself. - Designing the real-time scheduling discipline for the streaming threads (the underlying Rivermax stack expects real-time priority for sub-microsecond jitter; the canonical scheduling guidance lives in the Rivermax SDK docs reachable through `doca-public-knowledge-map/SKILL.md`). - Debugging a `DOCA_ERROR_*` returned from a Rivermax call (lifecycle vs. license / permission vs. capability vs. driver-below) where the cause may live in the DOCA-side wrapper, the underlying Rivermax stack, or the licensing layer. - Designing or extending non-C bindings (Rust, Go, Python, …) that wrap the DOCA Rivermax C ABI — for the precondition rule, lifecycle, capability, permission, and scheduling rules the wrapper must honor. Do **not** load this skill for general DOCA orientation, for installing DOCA itself, for installing the Rivermax SDK or managing the Rivermax license file (those live in the public Rivermax SDK guide reachable through `doca-public-knowledge-map/SKILL.md`), for best-effort packet I/O without timing requirements (use `doca-eth/SKILL.md` directly), or for pure host-side data processing without networking. For DOCA documentation orientation, use `doca-public-knowledge-map/SKILL.md`. ## What this skill provides This is a **thin loader**. The body keeps only the orientation needed to pick the right next file. The substantive Rivermax-specific material lives in two companion files: - the capabilities companion — what DOCA Rivermax can express on this version *and this Rivermax SDK install*: the Rivermax-as-hard-dependency rule, the receive-only `doca_rmax_in_stream` object model, the capability-query surface (`doca_rmax_get_*_supported`), the Rivermax error taxonomy (mapped onto the cross-library `DOCA_ERROR_*` set, with Rivermax-specific causes called out per row), the observability surface (per-stream progress engine events, capability snapshots, Rivermax-side license + driver state), and the safety policy that gates the Rivermax-SDK-present / license-present / device-access / scheduling-discipline preconditions. - the tasks companion — step-by-step workflows for the six in-scope Rivermax verbs: `configure`, `build`, `modify`, `run`, `test`, `debug`. Plus a `Deferred task verbs` block that points out-of-scope questions (installing Rivermax, managing the license, programming steering, programming the underlying queue) at the right next skill, and a `Command appendix` of the recurring commands the agent reaches for. The skill assumes a host or BlueField where DOCA is already installed at the standard location, the NVIDIA Rivermax SDK is installed at its expected location with a valid license, and the user has the privileges their public install profile expects (typically sudo or `mlnx`-group membership to open a `doca_dev` against a port). It does not cover installing DOCA — that path goes through `doca-setup/SKILL.md`. It does not cover installing Rivermax or its license — that path goes through the public Rivermax SDK guide reachable through `doca-public-knowledge-map/SKILL.md`. ## What this skill deliberately does not ship This skill is **agent guidance**, not a samples or templates bundle. To keep the boundary clean, it deliberately does not contain — and pull requests should not add: - **Pre-written DOCA Rivermax application source code, in any language.** The verified Rivermax source code is the shipped C samples at `/opt/mellanox/doca/samples/doca_rmax/<name>/`. The agent's job is to route the user to those files and prescribe a minimum-diff modification on them via the universal modify-a-sample workflow in `doca-programming-guide/SKILL.md`, layered with the Rivermax-specific overrides in ## modify. - **Standalone build manifests** (`meson.build`, `CMakeLists.txt`, `Cargo.toml`, …) parked inside the skill. The agent constructs the build manifest *in the user's project directory* against the user's installed DOCA, where `pkg-config --modversion doca-rmax` is the source of truth. - **Quoted Rivermax symbol names beyond the public family pattern (`doca_rmax_get_*_supported` for capability discovery, receive-only `doca_rmax_in_stream` session objects driven by the standard DOCA Core context lifecycle).** Exact Rivermax symbol names are install-bound and Rivermax-SDK-version- bound; the agent should read them from the installed headers at $(pkg-config --variable=includedir doca-common) and from the public DOCA Rivermax guide rather than rely on agent memory. - **A `samples/`, `bindings/`, or `reference/` subtree** of any kind. A mock or incomplete artifact in this skill's tree, even one labeled *"reference"*, is misleading: users will read it as buildable. ## Loading order 1. Read this skill first to confirm the user's question is in scope **and** that the Rivermax-SDK + license precondition has been considered. 2. **For the Rivermax capability matrix, the receive-only input stream model, capability-query rules, error taxonomy, observability, and safety policy, see the capabilities companion.** 3. **For step-by-step workflows — configure, build, modify, run, test, debug — see the tasks companion.** Both companion files cross-link to each other, `doca-version/SKILL.md` for the canonical DOCA version-handling rules (Rivermax adds a Rivermax-SDK- version axis on top), `doca-eth/SKILL.md` for the queue surface that carries the packets, `doca-flow/SKILL.md` for the steering side that decides which packets land on which queue, and `doca-public-knowledge-map/SKILL.md` whenever the right answer is *"look it up in the public Rivermax SDK guide or the installed package layout"* rather than *"Rivermax-integration-specific guidance"*. ## Related skills - `doca-public-knowledge-map/SKILL.md` — the routing table for every public DOCA documentation source and the on-disk layout of an installed DOCA package. The Rivermax URL slug is `DOCA-Rivermax`; the public Rivermax SDK guide (separate product) is reachable from the same routing table when the user asks how to install Rivermax or its license. - `doca-setup/SKILL.md` — env preparation, install verification, port-state checks (`devlink dev show`, `ip link`), permission and group-membership requirements for opening a `doca_dev`. This skill assumes its preconditions are satisfied; the Rivermax-SDK + license preconditions are layered on top. - `doca-version/SKILL.md` — canonical DOCA version-handling rules. This skill's `## Version compatibility` cross-links the four-way match rule and adds the Rivermax-specific overlay (Rivermax SDK version is a second axis; the capability set on this host is the intersection of DOCA-side cap-query results and Rivermax-side capabilities). - `doca-structured-tools-contract/SKILL.md` — the bundle's structured-tools precedence rule (detect / prefer / fall back / report). The Command appendix in the tasks companion honors this contract. - `doca-programming-guide/SKILL.md` — general DOCA programming patterns shared by every library: the canonical `pkg-config` + meson build pattern, the universal modify-a-shipped-sample first-app workflow, the universal lifecycle, the cross-library `DOCA_ERROR_*` taxonomy, and the program-side debug order. This skill layers Rivermax specifics on top. - `doca-eth/SKILL.md` — the queue surface that carries the packets a Rivermax stream produces or consumes. DOCA Rivermax does *not* program the underlying queue itself; it integrates with the queue programmed via `doca-eth`. The two skills' lifecycles are independent. - `doca-flow/SKILL.md` — the steering surface that decides which packets land on which queue. DOCA Rivermax does *not* program steering itself; an empty Rivermax input stream almost always means a missing or wrong Flow rule (or a missing Rivermax license), not a Rivermax bug. - `doca-debug/SKILL.md` — the cross-cutting debug ladder (install / version / build / link / runtime / program / driver). Rivermax-specific debug (license precondition gaps, stream-type / packet-rate capability mismatches, scheduling-discipline jitter symptoms) overlays on top of that ladder.
© NVIDIA · Apache-2.0 · NVIDIA/skills