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
- 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).
- 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.
- 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).
1---2license: Apache-2.03name: doca-urom-svc4description: >5 Operate the DOCA UROM Service container on BlueField Arm for remote6 memory operations (puts, gets, atomics, collectives) enqueued by a7 paired host using `doca-urom`: pull the NGC image, choose the UCX8 component, size queues, configure Comch pairing, and align host and9 service versions. SECURITY: the service has no standalone access10 control; Comch pairing and RDMA permissions are the boundary. Pair11 only intended hosts, expose least-privilege memory regions, and verify12 both views before start. Trigger for slow UCX collectives, unexpected13 NOT_PERMITTED, or missing completions. Do not use for host application14 code, MPI/UCX integration design, or DOCA install.15metadata:16 source: https://skillmd.com/skills/nvidia/doca-urom-svc17 author: NVIDIA <doca-feedback@nvidia.com>18 kind: service19 doca_version: "3.5"20 tags:21 - doca22 - urom23 - service24compatibility: >25 BlueField-Arm-only DOCA service container; pulled from NVIDIA NGC and26 started under the BlueField OS container runtime. Host-side install is27 irrelevant — the host's relationship to this service is via the paired28 `doca-urom` library over a `doca-rdma` substrate. The validation steps29 require a live DOCA install.30---3132# DOCA UROM Service3334**Scope first.** This skill operates the DPU-side service container.35Writing the host-side application code that submits offloaded36operations (from an MPI or UCX job, for example) is not this skill:37route it to `doca-urom/SKILL.md`, the host38library, and come back here only for the service it pairs with.3940## Examples4142- **"Slow UCX collectives on a BlueField pair."** — this is43 in scope for the DPU-side service container; host app code44 belongs to the `doca-urom` library skill.45- **"Unexpected NOT_PERMITTED after start."** — verify Comch46 pairing and least-privilege memory regions before widening47 exposure.4849## Instructions5051Follow Loading order below. Open the tasks companion for configure /52pair / debug. Open the capabilities companion for queues and53UCX components.5455**Where to start:** This skill is for *operating the DOCA UROM56Service container* on the BlueField Arm side. It is *not* for57*linking against* a library, and it is *not* the host-side58enqueue surface. If the user wants to *deploy* or *run* the59service container, start at the tasks companion `## configure`. If the question is *what60shape of service is DOCA UROM Service, what does it execute, and61how does it pair with the host-side library*, start at62the capabilities companion. If DOCA is not installed63on the BlueField yet, route to64`doca-setup/SKILL.md` first. If the user's65real question is about *writing host-side code that enqueues66remote memory operations through the paired API*, the right67skill is `doca-urom/SKILL.md` — the68host-side library; this service is the DPU-side executor that69library offloads to.7071**How to use this skill.** Read this file, then search the companion file72for the `## <name>` heading the question needs and read that whole section.73Answer completely from it, quoting only its symbols and commands. Do not74browse docs; use the entry points in `doca-public-knowledge-map`. For75out-of-scope requests, name the skill that owns them and stop.7677## Example questions this skill answers well7879The CLASSES of DOCA UROM Service questions this skill is built80to answer, each with one worked example. The class is the81load-bearing piece; the worked example is one instance.8283- **"Is DOCA UROM Service the right thing to deploy on my84 BlueField, or do I just need the host library?"** — worked85 example: *"my MPI cluster's host nodes link against86 `doca-urom`; what runs on the BlueField side and why must it87 also be there?"*. Answered by the publisher / executor88 paired-contract model in89 the capabilities companion90 + the deploy-this-when path-selection rule in91 the capabilities companion92 + the env-prep checklist in93 the tasks companion.94- **"Which library / service version pair am I supposed to95 run together?"** — worked example: *"the host fleet upgraded96 to a newer `doca-urom`; do I have to upgrade the service97 containers on every BlueField, or is the pairing flexible?"*.98 Answered by the version-contract overlay in99 the capabilities companion100 + the paired-version step in101 the tasks companion +102 `doca-version/SKILL.md` as the canonical103 body.104- **"What does the service configure — UCX components,105 collectives, queue depths, how the host pairs over Comch?"** — worked106 example: *"my upstream stack wants to offload all-reduce107 collectives; how do I tell the service to expose that108 collective family and how does the host pair to it over DOCA109 Comch?"*. Answered by the configuration-axes table in110 the capabilities companion111 + the config-authoring step in112 the tasks companion.113- **"Host's `doca-urom` calls fail with `NOT_PERMITTED` even114 though `doca_dev` access is fine — is this the service?"** —115 worked example: *"first enqueue from host returns116 `DOCA_ERROR_NOT_PERMITTED` after a clean `doca_ctx_start()`"*.117 Answered by the Comch-pairing / RDMA-permissions layer in118 the capabilities companion119 + the layered ladder in120 the tasks companion, which surfaces *"is121 the DOCA Comch endpoint pair correctly established and is the122 underlying RDMA permission stack happy"* BEFORE blaming a123 service-side authz layer (no such layer exists in the shipped124 binary — `NOT_PERMITTED` here is a Comch / RDMA signal, not a125 UROM-service authz signal).126- **"Operations enqueue but never complete — service or127 substrate?"** — worked example: *"host enqueue succeeds, the128 progress engine never sees the completion, what layer is129 hung"*. Answered by the service-vs-substrate split in130 the capabilities companion131 + the layered ladder in132 the tasks companion, which separates133 *service queue full / handler stuck* from *underlying RDMA134 transport down* before recommending a fix on either side.135- **"Performance with offload is worse than the host-CPU136 baseline — is the service the bottleneck?"** — worked137 example: *"we deployed the service, the workload runs, but138 collectives are slower than when the host CPU posted them139 itself"*. Answered by the offload-isn't-free rule in140 the capabilities companion141 + the smoke-before-scale step in142 the tasks companion, which surfaces *the143 workload's pattern may not actually benefit from DPU offload*144 as a legitimate diagnosis, not a service bug.145146## Audience147148This skill serves **external operators and platform teams who149deploy and operate the DOCA UROM Service container** on150BlueField to receive and execute the remote memory operations151HPC / UCX / MPI workloads on the host enqueue through152`doca-urom`. Concretely: people running the service container153on BlueField Arm, choosing which UCX components and collectives154it exposes, sizing the enqueue queue depth, wiring the DOCA155Comch endpoint pairing between host `doca-urom` and the156service container (the shipped binary has NO standalone157service-side "host-endpoint authorization list" — access is158governed by Comch pairing + the underlying RDMA permissions),159and validating the host-library + DPU-service paired contract160end-to-end before scaling a real HPC workload on top.161162It is **not** for NVIDIA developers contributing to the DOCA163UROM Service itself, nor a programming guide for building on164DOCA libraries (see `doca-programming-guide/SKILL.md`). DOCA165UROM Service is a **service**, not a library: the operator166deploys a container and configures it; there is no167`lib<uromservice>.so` to link. The paired host-side library168`doca-urom/SKILL.md` is a separate169skill with its own audience (HPC application developers, not170service operators); refuse to collapse the two.171172**Path selection up front.** Deploy this service when the HPC173cluster's host nodes use the `doca-urom` library and want host174CPU freed for compute by offloading collective communication175to the BlueField, when the team is building a custom HPC stack176on top of `doca-urom`, or when an upstream MPI / UCX stack has177been wired to use UROM as a transport. Do **not** deploy this178service when the hosts are not using `doca-urom`, when the HPC179stack is neither MPI nor UCX (this service won't help — it180executes UROM-shaped offloads, not arbitrary networking), or181when the BlueField hardware is too constrained for the182intended offload (a cap-query at deploy time surfaces this183upfront). Deploying speculatively where host workloads will184not offload through `doca-urom` adds operational complexity185with no benefit.186187## When to load this skill188189Load this skill when the user is doing **hands-on DOCA UROM190Service deployment work** on a BlueField where DOCA is already191installed. Concretely:192193- Deciding *whether* DOCA UROM Service is the right answer for194 the user's HPC environment (vs. keeping the host CPU on the195 communication path with raw `doca-rdma` or with no DPU196 offload at all).197- Deploying the service container on BlueField Arm — pulling198 the image per the public DOCA UROM Service Guide, setting the199 daemon's CLI flags / env (`SERVICE_ARGS`, `UROM_PLUGIN_PATH`)200 and mounting the `plugins/` directory, starting / stopping201 the container under the BlueField container runtime per the202 public Container Deployment Guide.203- Choosing the service's configuration axes — which UCX204 components / collectives the service exposes (cap-bound to205 what the BlueField generation supports), enqueue queue206 depths for the offload path, and how the host's `doca-urom`207 library pairs to the service over DOCA Comch (access is208 governed by that Comch pairing + the underlying RDMA209 permissions — there is no service-side authorization list).210 Pair only explicitly intended hosts and keep RDMA exports211 and permissions to the minimum the workload requires;212 pre-start verification through the documented Comch and213 RDMA read-only surfaces is mandatory.214- Confirming the host-library + DPU-service version pair is215 one the DOCA Compatibility Policy supports — a mismatch is216 the canonical subtle-failure mode for the paired contract.217- Reading the service container's logs, the service's218 observability surface, and the underlying RDMA substrate219 counters to confirm the service is actually executing the220 operations the host enqueued.221- Debugging a deployment where the container is healthy but222 the host's `doca-urom` enqueues fail or never complete, or223 where the offload's performance is worse than the host-CPU224 baseline.225226Do **not** load this skill for general DOCA orientation,227install of DOCA itself, host-side `doca-urom` library API228questions, or non-UROM HPC stack topics. For those, route via229`doca-public-knowledge-map/SKILL.md`,230`doca-setup/SKILL.md`, or the matching231host-side library skill232`doca-urom/SKILL.md`.233234## What this skill provides235236This is a **thin loader**. Substantive material lives in two237companion files:238239- the capabilities companion — the service's architecture (long-running240 container on BlueField Arm that executes UROM offloads from241 paired hosts), the publisher / executor paired-contract242 model and its load-bearing version-coupling rule, the243 configuration axes (UCX-component / collective surface,244 enqueue queue sizing, DOCA Comch endpoint pairing), the deployment245 shape (container on BlueField Arm per the public Container246 Deployment Guide), the pairing surface (host `doca-urom`247 library + underlying `doca-rdma` transport substrate), the248 observability surface (container state + service logs + RDMA249 counters), the error taxonomy (container-runtime vs250 service-side-resource vs251 transport-substrate vs paired-version-mismatch), and the252 safety policy (path-selection rule, version-contract rule,253 smoke-before-scale).254- the tasks companion — step-by-step workflows for the in-scope service255 verbs: `configure`, `build`, `modify`, `run`, `test`,256 `debug`, plus a `Deferred task verbs` block routing257 out-of-scope questions and a `Command appendix` of recurring258 commands.259260The skill assumes a BlueField where DOCA is already installed261and the operator has the privileges the public DOCA UROM262Service Guide expects to pull, run, and configure containers263on BlueField Arm. It does not cover installing DOCA — that path264goes through `doca-setup/SKILL.md`. It does265not cover the host-side `doca-urom` library API — that is266`doca-urom/SKILL.md`.267268## What this skill deliberately does not ship269270This skill is **agent guidance**, not a templates or271sample-config bundle. To keep the boundary clean, it272deliberately does not contain — and pull requests should not273add:274275- **Pre-baked DOCA UROM Service flag / env bundles**276 (full UCX-component / collective exposure manifests,277 ready-to-run queue-depth `SERVICE_ARGS` strings) intended278 to be copy-pasted into279 production. Service configuration is deployment-specific280 (per the BlueField281 generation's capability cap, per the workload's collective282 pattern); the safe answer for an external operator is to283 derive the daemon's flags / env from the public DOCA UROM284 Service Guide against their own deployment. The agent's job is to285 prescribe the *procedure* and the *configuration-axes286 decision*, not to ship a config the user might run287 unmodified.288- **Container image names, tags, or registry paths.** The289 authoritative image source is the public DOCA UROM Service290 Guide reachable through291 `doca-public-knowledge-map ## DOCA services` (`doca-public-knowledge-map/SKILL.md#doca-services`);292 the service's image tag is version-bound and changes293 between DOCA releases AND must match the host-side library294 version per the paired-contract rule. Inventing or295 memorizing a tag is the canonical hallucination failure296 mode for a service skill, and for this service in297 particular it can silently produce a host-library / service298 version mismatch.299- **Host-side `doca-urom` application source code, build300 manifests, or MPI / UCX integration glue.** Those live on301 the host and belong to302 `doca-urom/SKILL.md` (host library303 API) or to upstream MPI / UCX documentation (stack-side304 integration). This skill names *that* the host side must305 be wired through `doca-urom` and *that* the version must306 pair with the service; the host-side bodies are out of307 scope.308- **A `samples/`, `templates/`, or `reference/` subtree** of309 any kind. A mock artifact labeled *"reference"* reads as310 production-ready, and for a paired-contract service that311 implicitly claims a host-library version pairing the skill312 cannot guarantee.313314## Loading order3153161. Read this skill first to confirm the user's question317 is in scope **and** that the DOCA UROM Service is the318 right answer at all (vs. routing entirely to the host-side319 library skill, or away from UROM if the workload doesn't320 actually benefit from offload).3212. **For the service's deployment shape, the publisher /322 executor paired-contract model, the configuration axes,323 the host-library + RDMA-substrate pairing surface, the324 error taxonomy, the observability surface, the325 version-coupling rule, and the path-selection safety326 policy, see the capabilities companion.**3273. **For step-by-step workflows — configure, build, modify,328 run, test, debug — see the tasks companion.**329330## Related skills331332- `doca-urom/SKILL.md` — the paired333 host-side library. Hosts link `doca-urom` to ENQUEUE remote334 memory operations; this service EXECUTES them. The two335 skills load together for any HPC offload deployment and they336 do NOT collapse into one another: the library never executes337 on its own; this service is never enqueued through by338 itself. Mismatches between the library and the service are339 the dominant subtle-failure mode for the paired contract.340- `doca-rdma/SKILL.md` — the underlying341 RDMA transport substrate this service uses to actually move342 bytes once a host enqueue lands on the DPU. The service does343 NOT replace RDMA; it sits on top of it. A failing RDMA fabric344 surfaces at the service as *operations enqueued but never345 complete* and at the host as `DOCA_ERROR_IO_FAILED`; the fix346 is on the substrate side, not in this service's config.347- `doca-public-knowledge-map/SKILL.md`348 — the routing table to the public DOCA UROM Service Guide349 and the rest of the public DOCA documentation set. The350 service URL is listed under351 `## DOCA services` (`doca-public-knowledge-map/SKILL.md#doca-services`).352- `doca-setup/SKILL.md` — env preparation353 and install verification on the BlueField where the service354 container will run, including the *I have no install yet*355 path via the public NGC DOCA container. This skill assumes356 its preconditions are satisfied on BlueField Arm.357- `doca-version/SKILL.md` — canonical358 DOCA version-handling rules. This service's container tag is359 version-bound AND its host-library pairing is version-bound;360 this skill's `## Version compatibility` cross-links the361 four-way match rule and adds the host-library + DPU-service362 paired-version overlay that is load-bearing for UROM.363- `doca-structured-tools-contract/SKILL.md`364 — the bundle's structured-tools precedence rule (detect /365 prefer / fall back / report). The Command appendix in366 the tasks companion honors this contract.367- `doca-programming-guide/SKILL.md`368 — general DOCA patterns. The DOCA UROM Service is369 service-shaped not library-shaped, so the build / modify /370 first-app pattern there does not apply directly, but the371 cross-library debug discipline (env-before-program,372 layer-before-config) remains useful when the service373 reports an error that originated in the container runtime374 or in a DOCA library it called.375- `doca-debug/SKILL.md` — the cross-cutting376 debug ladder (install / version / build / link / runtime /377 program / driver). Service-specific debug (container not378 running, host-library / service version mismatch,379 transport substrate down, offload380 not actually helping) overlays on top of that ladder.381- `doca-dms/SKILL.md` and382 `doca-firefly/SKILL.md` — sibling service383 skills. The agent reading these skills should see the same384 service-skill shape (container on BlueField Arm, public385 Container Deployment Guide as the canonical recipe, env386 preconditions checked first, configured via the documented387 per-service surface — for UROM that is the daemon's CLI flags388 / env, not a mounted config file — smoke-before-scale)389 layered on top of a different390 per-service problem domain (DMS = device management via391 gNMI / gNOI; Firefly = time synchronization via PTP;392 UROM Service = HPC remote memory operation execution via393 the paired `doca-urom` library).