doca-urom-svc — Claude Code skill: what it does, how to install
doca-urom-svc guides configuration and operations for the DOCA UROM Service container on BlueField Arm to offload host remote memory tasks.
Apache-2.0 ★ 4,106 updated 2026-10-23
npx skills add NVIDIA/skills --skill doca-urom-svc -a claude-codeWhat doca-urom-svc does
This skill guides the operation of the DOCA UROM Service container running on BlueField Arm. The container receives remote memory operations—such as puts, gets, atomics, and UCX collectives—sent by a host system through doca-urom over DOCA Comch.
It covers image deployment from NVIDIA NGC, queue depth sizing, UCX component selection, and version matching between host and DPU. The skill also helps diagnose missing completions, throughput drops on collectives, and unexpected DOCA_ERROR_NOT_PERMITTED errors.
The container lacks internal access control. RDMA permissions and Comch pairing act as the sole security boundary. A running DOCA setup on the BlueField OS is necessary before deploying the service.
What it helps with
- configure the DOCA UROM Service container on BlueField Arm
- resolve DOCA_ERROR_NOT_PERMITTED errors during Comch pairing
- size enqueue queues and select UCX collective offloads
- trace stalled remote memory completions between host and DPU
Example prompts for the agent
- How do I configure DOCA UROM Service on BlueField for UCX collective offload?
- Host calls to doca-urom fail with NOT_PERMITTED, how do I check Comch pairing?
- Remote memory operations enqueue but never complete, how do I inspect the service?
How to install doca-urom-svc
1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-urom-svc -a claude-code2Manually: put the files in place
~/.claude/skills/doca-urom-svc/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/doca-urom-svc/
1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-urom-svc -a codex2Manually: put the files in place
.agents/skills/doca-urom-svc/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-urom-svc -a cursor2Manually: put the files in place
.cursor/skills/doca-urom-svc/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install NVIDIA/skills skills/doca-urom-svc2Manually: put the files in place
.github/skills/doca-urom-svc/SKILL.md1Skills CLI (Vercel)
npx skills add NVIDIA/skills --skill doca-urom-svc -a gemini-cli2Platform CLI
gemini skills install https://github.com/NVIDIA/skills --path skills/doca-urom-svcManually: put the files in place
.devin/skills/doca-urom-svc/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-urom-svc
How to install doca-urom-svc in Claude Code?
Run npx skills add NVIDIA/skills --skill doca-urom-svc -a claude-code.
What does doca-urom-svc do?
It handles deployment, queue tuning, and troubleshooting for the DOCA UROM Service container on BlueField Arm.
Can this skill help write host application code?
No, host-side application code linking against doca-urom belongs to a dedicated library skill, while this one targets only the DPU service container.
Source text
SKILL.md · Apache-2.0
--- license: Apache-2.0 name: doca-urom-svc description: > Operate the DOCA UROM Service container on BlueField Arm for remote memory operations (puts, gets, atomics, collectives) enqueued by a paired host using `doca-urom`: pull the NGC image, choose the UCX component, size queues, configure Comch pairing, and align host and service versions. SECURITY: the service has no standalone access control; Comch pairing and RDMA permissions are the boundary. Pair only intended hosts, expose least-privilege memory regions, and verify both views before start. Trigger for slow UCX collectives, unexpected NOT_PERMITTED, or missing completions. Do not use for host application code, MPI/UCX integration design, or DOCA install. metadata: author: NVIDIA <[email protected]> kind: service doca_version: "3.5" tags: - doca - urom - service compatibility: > BlueField-Arm-only DOCA service container; pulled from NVIDIA NGC and started under the BlueField OS container runtime. Host-side install is irrelevant — the host's relationship to this service is via the paired `doca-urom` library over a `doca-rdma` substrate. The validation steps require a live DOCA install. --- # DOCA UROM Service **Scope first.** This skill operates the DPU-side service container. Writing the host-side application code that submits offloaded operations (from an MPI or UCX job, for example) is not this skill: route it to `doca-urom/SKILL.md`, the host library, and come back here only for the service it pairs with. ## Examples - **"Slow UCX collectives on a BlueField pair."** — this is in scope for the DPU-side service container; host app code belongs to the `doca-urom` library skill. - **"Unexpected NOT_PERMITTED after start."** — verify Comch pairing and least-privilege memory regions before widening exposure. ## Instructions Follow Loading order below. Open the tasks companion for configure / pair / debug. Open the capabilities companion for queues and UCX components. **Where to start:** This skill is for *operating the DOCA UROM Service container* on the BlueField Arm side. It is *not* for *linking against* a library, and it is *not* the host-side enqueue surface. If the user wants to *deploy* or *run* the service container, start at the tasks companion `## configure`. If the question is *what shape of service is DOCA UROM Service, what does it execute, and how does it pair with the host-side library*, start at the capabilities companion. If DOCA is not installed on the BlueField yet, route to `doca-setup/SKILL.md` first. If the user's real question is about *writing host-side code that enqueues remote memory operations through the paired API*, the right skill is `doca-urom/SKILL.md` — the host-side library; this service is the DPU-side executor that library offloads to. **How to use this skill.** Read this file, then search the companion file for the `## <name>` heading the question needs and read that whole section. Answer completely from it, quoting only its symbols and commands. Do not browse docs; use the entry points in `doca-public-knowledge-map`. For out-of-scope requests, name the skill that owns them and stop. ## Example questions this skill answers well The CLASSES of DOCA UROM Service questions this skill is built to answer, each with one worked example. The class is the load-bearing piece; the worked example is one instance. - **"Is DOCA UROM Service the right thing to deploy on my BlueField, or do I just need the host library?"** — worked example: *"my MPI cluster's host nodes link against `doca-urom`; what runs on the BlueField side and why must it also be there?"*. Answered by the publisher / executor paired-contract model in the capabilities companion + the deploy-this-when path-selection rule in the capabilities companion + the env-prep checklist in the tasks companion. - **"Which library / service version pair am I supposed to run together?"** — worked example: *"the host fleet upgraded to a newer `doca-urom`; do I have to upgrade the service containers on every BlueField, or is the pairing flexible?"*. Answered by the version-contract overlay in the capabilities companion + the paired-version step in the tasks companion + `doca-version/SKILL.md` as the canonical body. - **"What does the service configure — UCX components, collectives, queue depths, how the host pairs over Comch?"** — worked example: *"my upstream stack wants to offload all-reduce collectives; how do I tell the service to expose that collective family and how does the host pair to it over DOCA Comch?"*. Answered by the configuration-axes table in the capabilities companion + the config-authoring step in the tasks companion. - **"Host's `doca-urom` calls fail with `NOT_PERMITTED` even though `doca_dev` access is fine — is this the service?"** — worked example: *"first enqueue from host returns `DOCA_ERROR_NOT_PERMITTED` after a clean `doca_ctx_start()`"*. Answered by the Comch-pairing / RDMA-permissions layer in the capabilities companion + the layered ladder in the tasks companion, which surfaces *"is the DOCA Comch endpoint pair correctly established and is the underlying RDMA permission stack happy"* BEFORE blaming a service-side authz layer (no such layer exists in the shipped binary — `NOT_PERMITTED` here is a Comch / RDMA signal, not a UROM-service authz signal). - **"Operations enqueue but never complete — service or substrate?"** — worked example: *"host enqueue succeeds, the progress engine never sees the completion, what layer is hung"*. Answered by the service-vs-substrate split in the capabilities companion + the layered ladder in the tasks companion, which separates *service queue full / handler stuck* from *underlying RDMA transport down* before recommending a fix on either side. - **"Performance with offload is worse than the host-CPU baseline — is the service the bottleneck?"** — worked example: *"we deployed the service, the workload runs, but collectives are slower than when the host CPU posted them itself"*. Answered by the offload-isn't-free rule in the capabilities companion + the smoke-before-scale step in the tasks companion, which surfaces *the workload's pattern may not actually benefit from DPU offload* as a legitimate diagnosis, not a service bug. ## Audience This skill serves **external operators and platform teams who deploy and operate the DOCA UROM Service container** on BlueField to receive and execute the remote memory operations HPC / UCX / MPI workloads on the host enqueue through `doca-urom`. Concretely: people running the service container on BlueField Arm, choosing which UCX components and collectives it exposes, sizing the enqueue queue depth, wiring the DOCA Comch endpoint pairing between host `doca-urom` and the service container (the shipped binary has NO standalone service-side "host-endpoint authorization list" — access is governed by Comch pairing + the underlying RDMA permissions), and validating the host-library + DPU-service paired contract end-to-end before scaling a real HPC workload on top. It is **not** for NVIDIA developers contributing to the DOCA UROM Service itself, nor a programming guide for building on DOCA libraries (see `doca-programming-guide/SKILL.md`). DOCA UROM Service is a **service**, not a library: the operator deploys a container and configures it; there is no `lib<uromservice>.so` to link. The paired host-side library `doca-urom/SKILL.md` is a separate skill with its own audience (HPC application developers, not service operators); refuse to collapse the two. **Path selection up front.** Deploy this service when the HPC cluster's host nodes use the `doca-urom` library and want host CPU freed for compute by offloading collective communication to the BlueField, when the team is building a custom HPC stack on top of `doca-urom`, or when an upstream MPI / UCX stack has been wired to use UROM as a transport. Do **not** deploy this service when the hosts are not using `doca-urom`, when the HPC stack is neither MPI nor UCX (this service won't help — it executes UROM-shaped offloads, not arbitrary networking), or when the BlueField hardware is too constrained for the intended offload (a cap-query at deploy time surfaces this upfront). Deploying speculatively where host workloads will not offload through `doca-urom` adds operational complexity with no benefit. ## When to load this skill Load this skill when the user is doing **hands-on DOCA UROM Service deployment work** on a BlueField where DOCA is already installed. Concretely: - Deciding *whether* DOCA UROM Service is the right answer for the user's HPC environment (vs. keeping the host CPU on the communication path with raw `doca-rdma` or with no DPU offload at all). - Deploying the service container on BlueField Arm — pulling the image per the public DOCA UROM Service Guide, setting the daemon's CLI flags / env (`SERVICE_ARGS`, `UROM_PLUGIN_PATH`) and mounting the `plugins/` directory, starting / stopping the container under the BlueField container runtime per the public Container Deployment Guide. - Choosing the service's configuration axes — which UCX components / collectives the service exposes (cap-bound to what the BlueField generation supports), enqueue queue depths for the offload path, and how the host's `doca-urom` library pairs to the service over DOCA Comch (access is governed by that Comch pairing + the underlying RDMA permissions — there is no service-side authorization list). Pair only explicitly intended hosts and keep RDMA exports and permissions to the minimum the workload requires; pre-start verification through the documented Comch and RDMA read-only surfaces is mandatory. - Confirming the host-library + DPU-service version pair is one the DOCA Compatibility Policy supports — a mismatch is the canonical subtle-failure mode for the paired contract. - Reading the service container's logs, the service's observability surface, and the underlying RDMA substrate counters to confirm the service is actually executing the operations the host enqueued. - Debugging a deployment where the container is healthy but the host's `doca-urom` enqueues fail or never complete, or where the offload's performance is worse than the host-CPU baseline. Do **not** load this skill for general DOCA orientation, install of DOCA itself, host-side `doca-urom` library API questions, or non-UROM HPC stack topics. For those, route via `doca-public-knowledge-map/SKILL.md`, `doca-setup/SKILL.md`, or the matching host-side library skill `doca-urom/SKILL.md`. ## What this skill provides This is a **thin loader**. Substantive material lives in two companion files: - the capabilities companion — the service's architecture (long-running container on BlueField Arm that executes UROM offloads from paired hosts), the publisher / executor paired-contract model and its load-bearing version-coupling rule, the configuration axes (UCX-component / collective surface, enqueue queue sizing, DOCA Comch endpoint pairing), the deployment shape (container on BlueField Arm per the public Container Deployment Guide), the pairing surface (host `doca-urom` library + underlying `doca-rdma` transport substrate), the observability surface (container state + service logs + RDMA counters), the error taxonomy (container-runtime vs service-side-resource vs transport-substrate vs paired-version-mismatch), and the safety policy (path-selection rule, version-contract rule, smoke-before-scale). - the tasks companion — step-by-step workflows for the in-scope service verbs: `configure`, `build`, `modify`, `run`, `test`, `debug`, plus a `Deferred task verbs` block routing out-of-scope questions and a `Command appendix` of recurring commands. The skill assumes a BlueField where DOCA is already installed and the operator has the privileges the public DOCA UROM Service Guide expects to pull, run, and configure containers on BlueField Arm. It does not cover installing DOCA — that path goes through `doca-setup/SKILL.md`. It does not cover the host-side `doca-urom` library API — that is `doca-urom/SKILL.md`. ## What this skill deliberately does not ship This skill is **agent guidance**, not a templates or sample-config bundle. To keep the boundary clean, it deliberately does not contain — and pull requests should not add: - **Pre-baked DOCA UROM Service flag / env bundles** (full UCX-component / collective exposure manifests, ready-to-run queue-depth `SERVICE_ARGS` strings) intended to be copy-pasted into production. Service configuration is deployment-specific (per the BlueField generation's capability cap, per the workload's collective pattern); the safe answer for an external operator is to derive the daemon's flags / env from the public DOCA UROM Service Guide against their own deployment. The agent's job is to prescribe the *procedure* and the *configuration-axes decision*, not to ship a config the user might run unmodified. - **Container image names, tags, or registry paths.** The authoritative image source is the public DOCA UROM Service Guide reachable through `doca-public-knowledge-map ## DOCA services` (`doca-public-knowledge-map/SKILL.md#doca-services`); the service's image tag is version-bound and changes between DOCA releases AND must match the host-side library version per the paired-contract rule. Inventing or memorizing a tag is the canonical hallucination failure mode for a service skill, and for this service in particular it can silently produce a host-library / service version mismatch. - **Host-side `doca-urom` application source code, build manifests, or MPI / UCX integration glue.** Those live on the host and belong to `doca-urom/SKILL.md` (host library API) or to upstream MPI / UCX documentation (stack-side integration). This skill names *that* the host side must be wired through `doca-urom` and *that* the version must pair with the service; the host-side bodies are out of scope. - **A `samples/`, `templates/`, or `reference/` subtree** of any kind. A mock artifact labeled *"reference"* reads as production-ready, and for a paired-contract service that implicitly claims a host-library version pairing the skill cannot guarantee. ## Loading order 1. Read this skill first to confirm the user's question is in scope **and** that the DOCA UROM Service is the right answer at all (vs. routing entirely to the host-side library skill, or away from UROM if the workload doesn't actually benefit from offload). 2. **For the service's deployment shape, the publisher / executor paired-contract model, the configuration axes, the host-library + RDMA-substrate pairing surface, the error taxonomy, the observability surface, the version-coupling rule, and the path-selection safety policy, see the capabilities companion.** 3. **For step-by-step workflows — configure, build, modify, run, test, debug — see the tasks companion.** ## Related skills - `doca-urom/SKILL.md` — the paired host-side library. Hosts link `doca-urom` to ENQUEUE remote memory operations; this service EXECUTES them. The two skills load together for any HPC offload deployment and they do NOT collapse into one another: the library never executes on its own; this service is never enqueued through by itself. Mismatches between the library and the service are the dominant subtle-failure mode for the paired contract. - `doca-rdma/SKILL.md` — the underlying RDMA transport substrate this service uses to actually move bytes once a host enqueue lands on the DPU. The service does NOT replace RDMA; it sits on top of it. A failing RDMA fabric surfaces at the service as *operations enqueued but never complete* and at the host as `DOCA_ERROR_IO_FAILED`; the fix is on the substrate side, not in this service's config. - `doca-public-knowledge-map/SKILL.md` — the routing table to the public DOCA UROM Service Guide and the rest of the public DOCA documentation set. The service URL is listed under `## DOCA services` (`doca-public-knowledge-map/SKILL.md#doca-services`). - `doca-setup/SKILL.md` — env preparation and install verification on the BlueField where the service container will run, including the *I have no install yet* path via the public NGC DOCA container. This skill assumes its preconditions are satisfied on BlueField Arm. - `doca-version/SKILL.md` — canonical DOCA version-handling rules. This service's container tag is version-bound AND its host-library pairing is version-bound; this skill's `## Version compatibility` cross-links the four-way match rule and adds the host-library + DPU-service paired-version overlay that is load-bearing for UROM. - `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 patterns. The DOCA UROM Service is service-shaped not library-shaped, so the build / modify / first-app pattern there does not apply directly, but the cross-library debug discipline (env-before-program, layer-before-config) remains useful when the service reports an error that originated in the container runtime or in a DOCA library it called. - `doca-debug/SKILL.md` — the cross-cutting debug ladder (install / version / build / link / runtime / program / driver). Service-specific debug (container not running, host-library / service version mismatch, transport substrate down, offload not actually helping) overlays on top of that ladder. - `doca-dms/SKILL.md` and `doca-firefly/SKILL.md` — sibling service skills. The agent reading these skills should see the same service-skill shape (container on BlueField Arm, public Container Deployment Guide as the canonical recipe, env preconditions checked first, configured via the documented per-service surface — for UROM that is the daemon's CLI flags / env, not a mounted config file — smoke-before-scale) layered on top of a different per-service problem domain (DMS = device management via gNMI / gNOI; Firefly = time synchronization via PTP; UROM Service = HPC remote memory operation execution via the paired `doca-urom` library).
© NVIDIA · Apache-2.0 · NVIDIA/skills