复制安装命令
用 Codex 或 Claude 安装复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它先审查 Skill 页面再帮你安装。
复制前请先查看来源、License 和安全提示。
SkillAtlasSkill 详情
doca-rdma
Official, NVIDIA-verified Agent Skills for Claude Code, Codex, and other coding agents.
审核状态：已审核Quality 72Security 52
项目 README
来源文件：README.md
NVIDIA Agent Skills
Official, NVIDIA-verified Agent Skills for Claude Code, Codex, and other coding agents.
📖 Docs: docs.nvidia.com/skills · 📺 Livestream: From Vulnerable to Verified · 📝 Blog: NVIDIA Verified Agent Skills: Capability Governance for AI Agents
Skills are portable instruction sets that teach AI agents how to use NVIDIA software optimally: Physical AI and robotics workflows, simulation, CUDA-X libraries, RAG and AI Blueprints, and platform tools. This repository is a catalog: skills are maintained in their respective product repos, and mirrored here daily via an automated sync pipeline. Skills are being added continuously, so check back for updates. We are building this infrastructure in the open, and contributions are welcome. See the Roadmap for what is planned next.
Quickstart
Install NVIDIA skills with the default skills CLI flow:
npx skills add nvidia/skills
The CLI runs through npx and prompts you to choose a skill and install destination. You do not need to clone this repo or copy skill folders by hand.
Requires a current
skillsCLI (v1.5.16 or newer). Installing vianpx skills@latest add nvidia/skillsalways uses the latest. On older CLIs (v1.5.15 and earlier), skills may install but not appear in Claude Code — see Troubleshooting.
The skill is available the next time your agent loads skills and encounters a relevant task. For example, ask your agent to "solve a linear programming problem with cuOpt" and the skill guides it through the cuOpt Python API. In Claude Code, run /reload-skills to load newly installed skills in your current session.
Install One Skill Without Prompts
Use this when you already know the skill name and want to skip prompts.
npx skills add nvidia/skills --skill cuopt-numerical-optimization-api --yes
Replace cuopt-numerical-optimization-api with any skill name from the Skill Catalog.
Install for a Specific Agent
Use --agent to target a specific AI coding agent. Initially, we'll support common client targets, expanding the list over time. For the full list of clients supported by the spec, see the skills CLI Supported Agents table.
Claude Code
npx skills add nvidia/skills --skill cuopt-numerical-optimization-api --agent claude-code
Codex
npx skills add nvidia/skills --skill cuopt-numerical-optimization-api --agent codex
Snowflake CoCo
npx skills add nvidia/skills --skill cuopt-numerical-optimization-api --agent cortex
Cursor
npx skills add nvidia/skills --skill cuopt-numerical-optimization-api --agent cursor
Kiro
npx skills add nvidia/skills --skill cuopt-numerical-optimization-api --agent kiro-cli
Use --agent more than once to install the same skill into multiple agents.
npx skills add nvidia/skills \
--skill cuopt-numerical-optimization-api \
--agent claude-code \
--agent codex \
--agent cursor \
--agent kiro-cli
Keep Skills Up to Date
New skills land continuously, and existing ones are revised, renamed, or consolidated as the catalog evolves. Refresh what you have installed with:
npx skills update
Run it interactively and the CLI also flags skills that were removed or merged upstream (for example, when several skills are consolidated into one) and offers to remove the stale local copies. Use npx skills list to see what is installed and npx skills check to preview what is out of date first.
Browse the Catalog
Use this when you want to see available NVIDIA skills before installing anything.
npx skills add nvidia/skills --list
For non-interactive installs, global installs, agent-specific installs, updates, removals, and fallback manual copying, see Advanced installation.
Skill Catalog
Getting Help & Contributing
Where to file an issue depends on what's broken:
- Skill content issues (a specific skill has a bug, missing functionality, or incorrect content) — file in the source repo for that product, using the per-product table below.
- Catalog issues (catalog README errors, sync workflow problems, distribution channels, signing/verification flow, docs in this repo) — file here using the catalog issue templates: Bug Report, Feature Request, or Documentation Request or Correction.
- Questions or general discussion — use Discussions. The issue tracker is reserved for bug reports, feature proposals with a design, and documentation issues.
- Security vulnerabilities — follow the disclosure process in SECURITY.md; do not open a public issue.
Per-product source repo links:
For issues with this catalog repo itself (README, structure, listing a new product): open an issue here.
Verifying Skills
Every published skill ships with a detached OMS signature (skill.oms.sig). The sync pipeline drops any skill missing the required artifacts before publishing, so every skill in the catalog carries:
SKILL.md— the skill instructions consumed by the agentskill-card.md— skill identity and governance cardskill.oms.sig— detached OMS signature (verifiable againstnv-agent-root-cert.pem)- A Tier-3 evaluation dataset — accepted at
evals/evals.json,evals/*.json,eval/*.json, orbenchmark/evals.json BENCHMARK.md— generated benchmark report capturing verifiable uplift data
Verify a skill against the NVIDIA trust anchor nv-agent-root-cert.pem:
pip install model-signing
model_signing verify certificate SKILL_DIR \
--signature SKILL_DIR/skill.oms.sig \
--certificate_chain nv-agent-root-cert.pem \
--ignore_unsigned_files
A successful verification confirms that the skill contents have not been modified since signing by NVIDIA.
See Verify Signed Agent Skills for signature layout, the trust pipeline, and policy options.
Roadmap
- ✅ Public skills catalog with NVIDIA-verified skills across multiple products
- ✅ Automated sync pipeline with skills mirrored from product repos daily
- ✅ Security scanning for all published skills covering instruction safety and supply-chain integrity
- ✅ Skills signing so every published skill carries a verifiable NVIDIA signature
- ✅ Skills universal evaluation criteria and task-specific criteria
- ✅ Skill Card with machine-readable metadata for identity, provenance, quality, and behavioral boundaries
- ✅ Sync-time compliance gates — signature drift detection and missing-artifact enforcement
- ✅ Syndication to external marketplaces — Skills.sh, Codex plugin, Claude Code plugin, ClawHub, Hermes Hub
- 🔲 Syndication to additional MCP hubs and partner channels
Repository Structure
NVIDIA/skills/
├── skills/ # NVIDIA-verified skills (count grows continuously),
│ │ synced from upstream product repos
│ ├── README.md # Browser-facing install guidance
│ ├── <product-prefix>-*/ # Flat layout — one dir per skill, product-prefixed
│ │ # e.g. aiq-*, cuopt-*, cupynumeric-*,
│ │ # dali-*, deepstream-*, dicom-*, digital-health-*,
│ │ # dynamo-*, earth2studio-*, holoscan-*, hsb-*,
│ │ # jetson-*, launch-nemo-rl, mcore-*,
│ │ # nemo-automodel-*, nemo-data-designer-plugin,
│ │ # nemo-evaluator-plugin, nemo-mbridge-* (20 skills),
│ │ # nemo-retriever, nemo-rl-* (4 skills),
│ │ # nemoclaw-user-guide, nemotron-*, nemotron-speech,
│ │ # nv-* (medical AI), physicsnemo-*, rag-*,
│ │ # skill-card-generator, tao-*, tilegym-*,
│ │ # vss-* (15 skills), accelerated-computing-cudf,
│ │ # cudaq-guide, portfolio-optimization
│ ├── omniverse-*/ # Physical AI — manually staged (see manual-components.yml)
│ └── physical-ai-*/ # Physical AI — manually staged
├── components.d/ # Product registry — one file per component, teams onboard here
│ ├── README.md # Schema and onboarding instructions
│ └── <product>.yml # one file per registered product
├── plugins/ # Packaged plugin distributions
│ └── nvidia-skills/ # Curated NVIDIA skills bundle (Claude Code, Codex)
├── plugins.d/ # Plugin build registry — config for `build-plugins.py`
│ ├── README.md
│ ├── _defaults.yml
│ └── nvidia-skills.yml
├── .claude-plugin/ # Claude Code marketplace metadata
│ └── marketplace.json
├── .agents/plugins/ # Agent marketplace metadata (other clients)
│ └── marketplace.json
├── docs/ # Long-form documentation (published via Fern)
│ ├── README.md # How to build the docs locally
│ ├── index.mdx
│ ├── advanced-install.mdx
│ ├── agent-skill-trust-pipeline.mdx
│ ├── release-checklist.mdx
│ ├── scanning-agent-skills.mdx
│ ├── signing-agent-skills.mdx
│ └── skill-cards.mdx
├── fern/ # Fern docs site configuration
├── .github/
│ ├── workflows/ # Sync pipeline, plugin validation, DCO check, author verify
│ └── scripts/ # regenerate-readme.sh, build-plugins.py,
│ # manual-components.yml (temp Physical AI catalog
│ # exception, removed after Computex 2026),
│ # marketplace/metadata.json (skill metadata sidecar)
├── nv-agent-root-cert.pem # Trust anchor for OMS signature verification
├── skills.sh.json # Skills.sh marketplace grouping config
├── CHANGELOG.md
├── CONTRIBUTING.md # Contribution guidelines
├── SECURITY.md # Security reporting policy
├── CODE_OF_CONDUCT.md # Community code of conduct
├── LICENSE-APACHE # Apache 2.0 (source code)
└── LICENSE-CC-BY-4.0 # CC BY 4.0 (documentation/skills)
Skills are maintained in their respective product repos (see the Source column in the Skill Catalog) and synced to this repo daily. Products only appear under skills/ after the sync pipeline confirms each skill carries:
skill.oms.sig— detached OMS-format signature (verifiable againstnv-agent-root-cert.pem)skill-card.md— skill identity and governance card- A Tier-3 evaluation dataset — accepted at
evals/evals.json,evals/*.json,eval/*.json, orbenchmark/evals.json
When evaluation runs produce a BENCHMARK.md, it ships alongside the skill so consumers can see verifiable benchmark uplift data.
Standards & Compatibility
This repository adheres to the Agent Skills specification:
- Skills are portable directories with a
SKILL.mdfile at their root. - Metadata uses YAML frontmatter with required
nameanddescriptionfields. - Skills follow a progressive disclosure model — lightweight metadata loads at startup, full instructions load on activation.
- Validate your skill using the
skills-refreference library.
License
Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
This code is dual-licensed with documentation/skills under the CC-BY-4.0 AND source code under Apache-2.0 license terms. The full license texts can be found in LICENSE-APACHE and LICENSE-CC-BY-4.0 respectively.
其他
高风险
- 来源需自行核对维护者身份。
- 包含脚本或命令调用，安装前请复核。
- 可能需要外部 token、网络权限或第三方服务。
- 存在潜在风险命令，请谨慎安装。
- 扫描发现：2 条。
Codex — Git Clone 安装
- 安装前请先查看来源仓库和风险报告。
- 克隆仓库：git clone https://github.com/NVIDIA/skills.git
- 将 "skills/doca-rdma" 文件夹复制到 Codex 的 skills 目录中。
- 重启 Codex 让新的 skill 生效。
Codex — 手动复制安装
- 安装前请先查看来源仓库和风险报告。
- 从源仓库下载 SKILL.md 及相关文件。
- 在 Codex 的 skills 目录中创建新文件夹。
- 将所有 skill 文件复制到新文件夹中。
- 重启 Codex 让新的 skill 生效。
Claude Code — Git Clone 安装
- 安装前请先查看来源仓库和风险报告。
- 克隆仓库：git clone https://github.com/NVIDIA/skills.git
- 将 "skills/doca-rdma" 文件夹复制到 Claude Code 的 skills 目录中。
- 重启 Claude Code 让新的 skill 生效。
Claude Code — 手动复制安装
- 安装前请先查看来源仓库和风险报告。
- 从源仓库下载 SKILL.md 及相关文件。
- 在 Claude Code 的 skills 目录中创建新文件夹。
- 将所有 skill 文件复制到新文件夹中。
- 重启 Claude Code 让新的 skill 生效。
Cursor — Git Clone 安装
- 安装前请先查看来源仓库和风险报告。
- 克隆仓库：git clone https://github.com/NVIDIA/skills.git
- 将 "skills/doca-rdma" 文件夹复制到 Cursor 的 skills 目录中。
- 重启 Cursor 让新的 skill 生效。
Cursor — 手动复制安装
- 安装前请先查看来源仓库和风险报告。
- 从源仓库下载 SKILL.md 及相关文件。
- 在 Cursor 的 skills 目录中创建新文件夹。
- 将所有 skill 文件复制到新文件夹中。
- 重启 Cursor 让新的 skill 生效。
GitHub Copilot — Git Clone 安装
- 安装前请先查看来源仓库和风险报告。
- 克隆仓库：git clone https://github.com/NVIDIA/skills.git
- 将 "skills/doca-rdma" 文件夹复制到 GitHub Copilot 的 skills 目录中。
- 重启 GitHub Copilot 让新的 skill 生效。
GitHub Copilot — 手动复制安装
- 安装前请先查看来源仓库和风险报告。
- 从源仓库下载 SKILL.md 及相关文件。
- 在 GitHub Copilot 的 skills 目录中创建新文件夹。
- 将所有 skill 文件复制到新文件夹中。
- 重启 GitHub Copilot 让新的 skill 生效。
Windsurf — Git Clone 安装
- 安装前请先查看来源仓库和风险报告。
- 克隆仓库：git clone https://github.com/NVIDIA/skills.git
- 将 "skills/doca-rdma" 文件夹复制到 Windsurf 的 skills 目录中。
- 重启 Windsurf 让新的 skill 生效。
Windsurf — 手动复制安装
- 安装前请先查看来源仓库和风险报告。
- 从源仓库下载 SKILL.md 及相关文件。
- 在 Windsurf 的 skills 目录中创建新文件夹。
- 将所有 skill 文件复制到新文件夹中。
- 重启 Windsurf 让新的 skill 生效。
查看 SKILL.md 原文
license: Apache-2.0
name: doca-rdma
description: >
Use this skill when the user is doing hands-on DOCA RDMA programming
on a BlueField DPU, ConnectX NIC, or DOCA host — bringing up an RDMA
context on a doca_dev, picking a connection method (RDMA CM,
bridge/OOB, or gRPC exchange of doca_rdma_export()), enabling one of
the eleven task types (Send/Receive/Send-Imm, Read/Write/Write-Imm,
Atomic CmpSwap/FetchAdd, Get/Set/Add Remote Sync Event), setting
matching mmap + RDMA permissions, sizing queues and connections,
querying doca_rdma_cap_*, or debugging DOCA_ERROR_* from an RDMA
call. Trigger even when the user does not mention "DOCA RDMA" —
typical implicit phrasings include "one-sided read returns permission
denied", "completions never arrive after submit", "connection
callback never fires", "how do I do atomic compare-and-swap over
RoCE", or "send queue hits DOCA_ERROR_FULL under burst". Refuse and
route elsewhere for general RDMA / ibverbs theory (queue pairs, MRs,
RoCE vs IB), installing DOCA itself, or non-RDMA DOCA libraries.
metadata:
kind: library
compatibility: >
Requires DOCA SDK on Linux (Ubuntu 22.04/24.04 or RHEL/SLES) with a
BlueField DPU or ConnectX NIC. Resolves the local install and module via
`pkg-config --list-all | grep -i doca` and
`pkg-config --variable=prefix MODULE`, replacing `MODULE` with the exact
name returned by the preceding query. The normal module is the umbrella
`doca`, while split installs may expose a per-library module.DOCA RDMA
Non-negotiable: the deliverable uses DOCA RDMA, not raw verbs
When this skill is in scope, the user is asking for DOCA RDMA. The
program you produce must link libdoca_rdma and call the
doca_rdma_* API (directly in C/C++, or through a thin FFI/cgo shim
from another language). Do NOT implement the request with raw
libibverbs / librdmacm / RDMA-CM and call it done. Those move bytes
but completely bypass DOCA — which defeats the entire purpose of using
this library, loses the DOCA programming model (progress engine, task/
event lifecycle, capability discovery, portability across BlueField/
ConnectX generations), and is the single most common failure mode.
"Raw verbs is fewer lines" / "it avoids building a DOCA binding layer"
is not an acceptable reason to bypass DOCA. The correct low-friction
path for a non-C language (Go, Rust, Python, …) is not to re-bind
the whole API — it is to start from a shipped DOCA RDMA sample under
$(pkg-config --variable=prefix doca)/samples/doca_rdma/ (substitute the
module resolved on the target) and wrap its entry functions in
a thin cgo/FFI shim built with #cgo pkg-config: doca (Go) or the
equivalent. That shim is a single small file, not "a large custom
binding layer". See TASKS.md ## build Step 0 and
TASKS.md ## modify.
If pkg-config doca or the DOCA build fails, fix the build (module
name, PKG_CONFIG_PATH, sample path) — do not silently fall back to
verbs. A binary whose ldd shows no libdoca_rdma is a failed
DOCA-RDMA task, regardless of whether bytes moved.
Where to start: This skill assumes DOCA is already installed and
the user is doing hands-on RDMA work on a BlueField / ConnectX /
host with DOCA. Open TASKS.md if the user wants to do
something (configure / build / modify / run / test / debug); open
CAPABILITIES.md when the question is what can
RDMA express on this version. If the user has not installed DOCA
yet, route to doca-setup first.
Example questions this skill answers well
The CLASSES of RDMA 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.
- "How do I bring up an RDMA context and connect two sides?" —
worked example: "set up sender + receiver with RDMA CM on a single
host for first-run testing". Answered by the lifecycle + connection
workflow in
TASKS.md ## configure+CAPABILITIES.md ## Capabilities and modesconnection-method selection. - "Which RDMA task type fits this data-movement pattern?" —
worked example: "one-sided write + completion via Send-with-Immediate
for a small control message". Answered by the task taxonomy in
CAPABILITIES.md ## Capabilities and modes- the task-config workflow in
TASKS.md ## modify.
- the task-config workflow in
- "What mmap permissions does this task need? Do I have to export
the mmap?" — worked example: "my Read task fails with insufficient
permissions". Answered by the permission matrix in
CAPABILITIES.md ## Safety policy- the mmap-export checklist in
TASKS.md ## test.
- the mmap-export checklist in
- "Is this RDMA capability supported on my device + transport?" —
worked example: "does this device support Atomic Compare-and-Swap
over RoCE". Answered by the capability-query rule
(
doca_rdma_cap_task_*_is_supportedagainst adoca_devinfo) inCAPABILITIES.md ## Capabilities and modes- the discovery step in
TASKS.md ## configure.
- the discovery step in
- "Is this RDMA API available on my installed DOCA version?" —
worked example: "is RDMA CM in DOCA 2.6.0". Answered by the
version-compatibility section in
CAPABILITIES.md ## Version compatibility- the version-discovery rule (
pkg-config --modversion doca) pinned inTASKS.md ## configure.
- the version-discovery rule (
- "What does this
DOCA_ERROR_*from an RDMA call mean and which layer caused it?" — worked example: "DOCA_ERROR_BAD_STATEfromdoca_rdma_connection_disconnect". Answered by the RDMA overlay on the cross-library taxonomy inCAPABILITIES.md ## Error taxonomy- the layered ladder in
TASKS.md ## debugthat escalates todoca-debug.
- the layered ladder in
Audience
This skill serves external developers building applications that
consume the DOCA RDMA library — i.e., users whose code calls
doca_rdma_* (directly in C/C++, or through FFI/bindings from
another language) to do RDMA data movement between two sides
(host↔host, host↔BlueField, DPU↔DPU, or SF↔SF on a BlueField). It
is not for NVIDIA developers contributing to DOCA RDMA itself.
Language scope. DOCA RDMA normally ships as a C library inside the
umbrella doca pkg-config module (public header doca_rdma.h, shared
object libdoca_rdma.so); split installs may expose a per-library module.
Always discover the module on the target (pkg-config --list-all | grep -i doca) rather than assuming either layout. The
shipped samples are written in C
(NVIDIA's choice). C and C++ consumers are the canonical case and
the worked examples in TASKS.md 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 lifecycle, capability-discovery, permission-matrix,
error-taxonomy, and connection-method guidance language-neutral, and
to route the agent to the public C ABI as the authoritative surface
that any wrapper will eventually call. The non-C deliverable is still
a DOCA program: a thin cgo/FFI shim over the shipped doca_rdma
sample that links libdoca_rdma (#cgo pkg-config: doca) — never a
raw-libibverbs reimplementation chosen to avoid wrapping DOCA (see the
mandate at the top of this file).
When to load this skill
Load this skill when the user is doing hands-on DOCA RDMA work, in any language. Concretely:
- Initializing an RDMA context on a
doca_devand configuring at least one task type beforedoca_ctx_start(). - Establishing a connection — picking between RDMA CM
(
doca_rdma_connect_to_addr()/doca_rdma_start_listen_to_port()/doca_rdma_connection_accept()), bridge / OOB (doca_rdma_bridge_*), or gRPC (out-of-band exchange ofdoca_rdma_export()output). - Setting permissions on
doca_mmapcorrectly for the chosen task type (Read needs RDMA-read + local read-write; Write needs RDMA-write; Atomic needs RDMA-atomic; Send needs only local read-write). - Reading / setting library properties via
doca_rdma_set_*anddoca_rdma_cap_get_*to size queues, list lengths, and transport-type selection. - Checking which RDMA task types and transport types are supported
on the active
doca_devinfo. - Debugging a
DOCA_ERROR_*returned from an RDMA call (lifecycle vs. permission vs. capability vs. driver-below) and the connection state-machine transitions (doca_rdma_set_connection_state_callbacks). - Designing or extending non-C bindings (Rust, Go, Python, …) that wrap the RDMA C ABI — for the lifecycle, permission, and capability rules the wrapper must honor.
Do not load this skill for general DOCA orientation, install of
DOCA itself, or non-RDMA library questions. For those, use
doca-public-knowledge-map.
What this skill provides
This is a thin loader. The body keeps only the orientation needed to pick the right next file. The substantive RDMA-specific material lives in two companion files:
CAPABILITIES.md— what RDMA can express on this version: the eleven task types and their permission matrix, the three connection methods, transport types (RC baseline and alpha-level DC for the export/connect CPU-datapath flow — there is no UD) — note these are the per-QP service type controlled bydoca_rdma_set_transport_type(), NOT the link-layer (IB vs RoCE) which is inherited from the device port configuration, the capability-query surface (doca_rdma_cap_*), the RDMA error taxonomy (mapped onto the cross-libraryDOCA_ERROR_*set), the observability surface (per-task events, connection state callbacks), and the safety policy that gates permission and export decisions.TASKS.md— step-by-step workflows for the six in-scope RDMA verbs:configure,build,modify,run,test,debug. Plus aDeferred task verbsblock that points out-of-scope questions at the right next skill.
The skill assumes a host or BlueField where DOCA is already
installed at the standard location and the user has the privileges
their public install profile expects. It does not cover installing
DOCA — that path goes through
doca-setup.
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 RDMA application source code, in any
language. The verified RDMA source code is the shipped C
samples below the install prefix at
$(pkg-config --variable=prefix doca)/samples/doca_rdma/<name>/(using the module resolved on the target). 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 indoca-programming-guide, layered with the RDMA-specific overrides inTASKS.md ## 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, wherepkg-config --modversion docais the source of truth (resolve the module perTASKS.md ## buildStep 0 — there is normally no separatedoca-rdma.pc). - A
samples/,bindings/, orreference/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
- Read this
SKILL.mdfirst to confirm the user's question is in scope. - If the question is what RDMA can express—task taxonomy, link-layer vs transport-type selection, connection methods, permissions, errors, observability, or safety—read CAPABILITIES.md.
- If the question is how to do it—configure, build, modify, run, test, or debug—read the matching H2 in TASKS.md. Read both companions only when the workflow depends on a capability or safety decision; do not load both unconditionally.
Both companion files cross-link to each other and to
doca-public-knowledge-map
whenever the right answer is "look it up in the public docs or the
installed package layout" rather than "RDMA-specific guidance".
Related skills
doca-public-knowledge-map— the routing table for every public DOCA documentation source and the on-disk layout of an installed DOCA package. Always available alongside this skill.doca-setup— env preparation, install verification, and the I have no install yet path with the public NGC DOCA container. This skill assumes its preconditions are satisfied.doca-programming-guide— general DOCA programming patterns shared by every library: the canonicalpkg-config+ meson build pattern, the universal modify-a-shipped-sample first-app workflow, the universal lifecycle, the cross-libraryDOCA_ERROR_*taxonomy, and the program-side debug order. This skill layers RDMA specifics on top.doca-debug— the cross-cutting debug ladder (install / version / build / link / runtime / program / driver). RDMA-specific debug (state-machine transitions, permission failures, connection callbacks) overlays on top of that ladder.
评论 (0)
暂无评论，成为第一个评论者吧！