NVIDIA Corporation

Deploy and troubleshoot a CollectX telemetry collector on a host or BlueField. Connect sources of device metrics, configure outputs such as Prometheus or Fluent Bit, and verify that collected measurements reach their downstream destination.

• Set up a collector with Prometheus output
• Add a source of device counters
• Investigate missing collected data

Build and troubleshoot custom plug-ins for workloads that doca-bench cannot measure with its built-in modes. Use the shipped CUDA example to guide shared-library construction, check loading and version compatibility, and verify a small test before larger runs.

• Checking whether a workload needs a custom extension
• Building a GPU benchmark plug-in from the shipped example
• Diagnosing a custom shared library that will not load

Build and troubleshoot data transfers with DOCA RDMA, which accesses remote memory over a network adapter. Start from installed samples, choose connection methods and permissions, check device capabilities, and investigate missing completions or queue errors.

• Building data transfers between processes or hosts
• Diagnosing permission errors in remote reads and writes
• Investigating missing completions or queue saturation

Guide DOCA Management programming for BlueField and ConnectX devices. Set up management contexts, query capabilities, change device settings, and investigate errors, using installed reference samples and checks before and after changes.

• Querying BlueField device capabilities in a fleet tool
• Changing data-direct settings for a virtual function
• Setting ICM quotas for devices or representors

Load and configure a custom congestion control algorithm on a BlueField DPU from the host. The skill guides port attachment, capability checks, and troubleshooting when loading fails or the algorithm has no effect on RoCE traffic.

• Load a custom algorithm onto a BlueField port
• Check device and firmware support for custom PCC
• Diagnose algorithm loading errors

Build SHA hashing applications for BlueField or ConnectX accelerators with guidance on single-request versus chunked processing, supported algorithms, buffer sizes, memory permissions, and errors returned by the DOCA SHA API.

• Offloading SHA-256 hashing to BlueField
• Choosing single-request or chunked hashing
• Checking algorithm support and buffer limits

Prepare an environment for evaluating speech recognition on clinical terms. Checks the API key and Python dependencies, then tests NVIDIA's hosted services by generating speech from one synthetic sentence and transcribing it before the next stage.

• Preparing a clinical speech recognition evaluation
• Checking API access from a fresh environment
• Testing speech synthesis and transcription together

Modify command-line options in DOCA applications while preserving standard flags. This skill guides parameter registration, parser lifecycle, JSON configuration, and error diagnosis using the installed SDK and its shipped samples.

• Add custom flags to a DOCA sample
• Load application settings from a JSON file
• Diagnose argument registration and value errors

Develop host-side applications that run work on BlueField's DPA, a data-path processor. Load compiled application images, launch kernels, observe completion, check supported features, and investigate errors involving hardware capabilities or DOCA and DPACC compatibility.

• Loading a DPA application image and launching kernels from the host
• Investigating missing kernel completion notifications
• Checking which DPA features a BlueField supports

Check DOCA installation health, prepare build and runtime requirements, and investigate environment failures such as missing libraries or memory settings. Helps choose container learning or hardware deployment paths based on the available system.

• Check whether a DOCA installation is healthy
• Investigate library detection and runtime environment failures
• Start learning through an NGC DOCA container without hardware

Build a first DOCA application by adapting an installed sample. Get guidance on build configuration, object setup and shutdown order, and common errors, plus how other languages access DOCA through its public C interface.

• Adapting an installed sample into a first DOCA application
• Configuring a build with pkg-config and meson
• Checking object lifecycle order and common errors

Configure DOCA Ethernet packet queues on BlueField or ConnectX devices. Get guidance on choosing receive queue types, submitting packets for transmission, checking device capabilities, and diagnosing errors while managing receive and transmit queues separately.

• Setting up Ethernet receive and transmit queues
• Choosing a receive queue type for incoming data
• Checking burst limits and checksum offload support

Implement memory copies with DOCA DMA, which transfers data using the device rather than the host CPU. Get guidance on initialization, buffer limits, memory permissions, task completion, and diagnosing errors against the locally installed SDK.

• Implement a host-to-BlueField memory copy
• Check buffer size limits and scatter-gather support
• Investigate permission errors or missing task completion

Develop messaging between a host and BlueField using DOCA Comch. Guides server and client setup, selection of simple messaging or higher-throughput data transfer, capability checks, and diagnosis of connection, permission, and API errors.

• Exchange control messages between a host and BlueField
• Choose a transfer mode for bulk data
• Check message-size and client-count limits

Build and troubleshoot applications that move DEFLATE compression and decompression, or LZ4 decompression, to DOCA-supported hardware. Guidance covers device capabilities, buffer sizes, memory permissions, validation, and deciding when CPU processing is more suitable.

• Moving bulk DEFLATE compression to hardware
• Decompressing incoming network data
• Checking device support and buffer limits

Build custom emulated PCIe devices that a host recognizes as peripherals while BlueField DPU code handles their operation. Get guidance on DOCA sub-library selection, capability checks, setup within an installed environment, and debugging device visibility or driver binding.

• Expose a custom PCIe device to a host
• Choose PCI Generic, virtio-net, or virtio-fs
• Investigate missing devices or driver binding failures

Configure DOCA GPI so CUDA kernels can initiate RDMA, direct remote memory access, without host CPU mediation. The skill guides channel setup, memory attachment, GPU handle handoff, library selection, and diagnosis of GPI errors.

• Choose between GPI and GPUNetIO for GPU-driven communication
• Configure GPI channels and remote endpoint connections
• Pass a GPI channel handle to a CUDA kernel

Build and run the GPUNetIO benchmark to measure sustained RDMA WRITE bandwidth, a remote-memory transfer rate driven by a CUDA kernel. Interpret results, investigate run-to-run variation, and identify GPU, network adapter, or link bottlenecks.

• Measure sustained GPU-initiated RDMA WRITE bandwidth
• Investigate bandwidth variation between runs
• Identify GPU, network adapter, or link bottlenecks

Operate NVIDIA DOCA Management Service to read, change, and monitor BlueField or ConnectX settings locally or remotely. Get guidance on deployment, authentication, management requests, logs, and diagnosing failures across the service and its backend.

• Read or change local BlueField settings
• Choose deployment and authentication for remote management
• Read, update, and subscribe to settings through gNMI

Inspect which devices, libraries, and capabilities DOCA recognizes on a host using a read-only command-line tool. Narrow results to a PCIe address and capture a capability snapshot for installation checks or troubleshooting.

• Check whether DOCA recognizes a BlueField device
• List DOCA libraries available on the current OS
• Inspect capabilities for a specific PCIe address

Explore competing goals such as cost and service quality through repeated cuOpt solves. Organize efficient alternatives into a Pareto frontier, a set of tradeoff choices, and explain what each improvement costs in another objective.

• Compare cost and service quality
• Explore return and risk tradeoffs
• Compare delivery distance and vehicle count

Generate DNA sequences with NVIDIA Evo 2, check their length and alphabet, and save sequence files alongside probabilities and timing metrics. A local deployment also supports extracting numerical outputs from selected internal model layers.

• Generate DNA from a starting sequence
• Save generated sequences and metrics
• Extract internal layer outputs from a local model

Monitor KERMT jobs running in the background by reading run records, Docker container status, and logs. Summarize training progress and validation metrics, stream logs, or report final test metrics when a finetune run completes successfully.

• Check progress on a background pretraining run
• Watch training logs and validation metrics live
• Review test metrics after finetuning completes

Customize NVIDIA Nemotron Voice Agent’s Generic Pipecat example for appointment scheduling, five-field patient intake, or a custom healthcare conversation. Build prompts and tool handlers without a separate backend, then validate conversation behavior, services, and voice interaction.

• Build an appointment-scheduling voice agent
• Collect five patient-intake fields through conversation
• Design a custom healthcare conversation with tool calls