> This page is for version 3.3.0 (default).
> For other versions, use one of these documentation indexes:
> - 3.3.0 (default): https://docs.nvidia.com/vss/3.3.0/llms.txt
> - Dev: https://docs.nvidia.com/vss/dev/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/vss/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/vss/_mcp/server.

# Setup VSS and Skills

Minimum path to a deployed VSS stack driven from the agent chat UI. Only VSS itself requires a GPU; NemoClaw and the VSS Orchestrator MCP server are CPU-only. NemoClaw can run on a separate machine from the VSS host, as remote deployment and VSS orchestration are supported by the VSS Orchestrator MCP server.

This guide uses the simplest layout and runs everything on a single VSS-capable host (such as the Brev instance) through two notebooks that run in order:

1. `deploy/docker/scripts/deploy_nemoclaw.ipynb` - pins Docker, installs
   NemoClaw, creates the sandbox from the VSS harness image, applies the VSS
   policy and deployment origin, optionally registers an HTTPS orchestrator
   path, configures optional webhooks, and opens the Agent UI.
2. `deploy/docker/scripts/deploy_vss_orchestrator.ipynb` - prepares the host for VSS, starts the VSS Orchestrator MCP server, and deploys and manages VSS from the Agent UI by chatting with the agent.

Follow the cells in each notebook in order. For the full variable reference and optional verification cells, see [Additional Configuration](/vision-agent/agent-harnesses/nemoclaw/additional-configuration).

> **Note**
>
> The prompts and screenshots use OpenClaw as an example. Run the equivalent checks in whichever agent harness you onboarded (`AGENT_RUNTIME`, for example OpenClaw or Hermes).

> **Note**
>
> To run NemoClaw on a separate machine from the VSS host, refer to the
> [NemoClaw for OpenClaw model card](https://build.nvidia.com/nvidia/nemoclaw-for-openclaw/nemoclawcard)
> and the [NemoClaw OpenClaw user guide](https://docs.nvidia.com/nemoclaw/latest/user-guide/openclaw/home).

## Prerequisites

* **Common to both notebooks**

  * Access to the [VSS repository](https://github.com/NVIDIA-AI-Blueprints/video-search-and-summarization/tree/v3.3.0).
  * Docker, `curl`, `python3`, and `uv` on the host that runs the notebook.
  * A Jupyter kernel with Python 3.11 or newer.

    * *Auto-fulfilled when running from the Brev Launchable below.*

* **Part 1 - Set up NemoClaw** (`deploy_nemoclaw.ipynb`, CPU only)

  * An agent chat model provider:

    * `NVIDIA_API_KEY` for the build.nvidia.com provider. Create one from
      [NVIDIA API Keys](https://build.nvidia.com/settings/api-keys), OR
    * `COMPATIBLE_API_KEY` for a cloud or local OpenAI-compatible endpoint,
      issued by that endpoint's provider.

* **Part 2 - Deploy VSS** (`deploy_vss_orchestrator.ipynb`, GPU required)

  * A VSS-capable GPU host, such as a preconfigured [Brev Launchable](https://brev.nvidia.com/launchable/deploy/now?launchableID=env-2tYIjRXL4eMCbH9Az8mJC5WPAI4) or your own GPU-enabled machine.

    * If you are using the Brev Launchable, you can edit the Brev hardware profile and cloud service provider (CSP). See [Brev hardware and CSP selection](/vision-agent/agent-harnesses/nemoclaw/additional-configuration#brev-hardware-and-csp-selection) before launching.
    * In the single-host layout used by this guide, this same machine also runs Part 1.

  * `NGC_CLI_API_KEY` (NGC Personal API Key) for `nvcr.io` login and the model weights the containers download from NGC.

  * `NVIDIA_API_KEY` for the VSS model endpoints.

  * A `HARDWARE_PROFILE` value matching the VSS deployment host.

## Part 1 - Set up NemoClaw

1. Prepare the VSS repository at `~/video-search-and-summarization` before opening either notebook.

   On Brev, the repository is cloned automatically. Click **Open Notebook** on the instance page, then open a terminal in JupyterLab and check out the [repository reference selected for this documentation build](https://github.com/NVIDIA-AI-Blueprints/video-search-and-summarization/tree/v3.3.0):

   **`Run in the VSS host terminal`**

   ```bash title="Run in the VSS host terminal"
   cd ~/video-search-and-summarization
   git fetch origin "v3.3.0"
   git checkout --detach FETCH_HEAD
   ```

   On your own host, clone the repository and check out the same reference:

   **`Run in the VSS host terminal`**

   ```bash title="Run in the VSS host terminal"
   git clone https://github.com/NVIDIA-AI-Blueprints/video-search-and-summarization.git ~/video-search-and-summarization
   cd ~/video-search-and-summarization
   git checkout "v3.3.0"
   ```

   If your checkout is elsewhere or the host has multiple clones, set `VSS_REPO_DIR` before launching Jupyter.

2. Open `deploy/docker/scripts/deploy_nemoclaw.ipynb` on the VSS host. If either setup notebook is already open, close and reopen it after checking out the reference so it loads the selected version.

   * If you are re-onboarding a host that previously ran an older OpenShell gateway, review the [NemoClaw sandbox lifecycle guidance](https://docs.nvidia.com/nemoclaw/manage-sandboxes/lifecycle) before running the notebook.

3. Follow the notebook sections in order:

   | Section | What it does                                                                                                                       |
   | ------- | ---------------------------------------------------------------------------------------------------------------------------------- |
   | 1       | Choose the agent chat model and review advanced settings.                                                                          |
   | 2       | Check host and repository prerequisites, then pin Docker to the tested versions.                                                   |
   | 3.1     | Install NemoClaw and create the sandbox from the selected harness image, replacing an existing sandbox by default.                 |
   | 3.2     | Apply the VSS sandbox policy and deployment origin.                                                                                |
   | 3.3     | Register the VSS Orchestrator MCP path only when `ORCHESTRATOR_ENABLE_HTTPS=True`; the default HTTP path requires no registration. |
   | 3.4     | Configure optional agent webhooks.                                                                                                 |
   | 3.5     | Open the Agent UI.                                                                                                                 |
   | 3.6     | Optionally verify the sandbox, policy, workspace, and webhooks.                                                                    |

![Agent UI chat interface](/vss/_fern-img/e3a6793cafb69259aa21aa6c2d5fdcede450c7b3b0a073fe75364c624b4b3612.webp)

If you are not running on Brev, forward the gateway port from your local machine before opening the UI:

**`Run in your local terminal`**

```bash title="Run in your local terminal"
ssh -L 18789:127.0.0.1:18789 <user>@<nemoclaw-host>
```

## Part 2 - Deploy VSS from chat

With the Agent UI open, open `deploy/docker/scripts/deploy_vss_orchestrator.ipynb` on the VSS host.

> **Note**
>
> In the single-host layout used by this guide, the VSS host is the same machine as Part 1. VSS and the VSS Orchestrator MCP server can also run on a separate machine from NemoClaw.

1. Set `NEMOCLAW_SANDBOX_NAME` to the sandbox you onboarded in Part 1 and set
   `HARDWARE_PROFILE` to match the VSS deployment host. For edge hardware
   profiles (`DGX-SPARK`, `IGX-THOR`, `AGX-THOR`), see [Run on DGX Spark](/vision-agent/agent-harnesses/nemoclaw/setup-vss-and-skills#run-on-dgx-spark) before you deploy.

2. Follow the notebook sections in order. The notebook covers:

   * Set NVIDIA credentials and hardware profile
   * Check host and repo prerequisites
   * Prepare the host for local NIM-backed profiles
   * Start the VSS Orchestrator MCP server
   * Deploy and manage VSS from chat
   * Optionally verify host reachability from inside the sandbox

![Agent UI listing the installed VSS skills](/vss/_fern-img/159c5c95f4b5be9c65e5654dff8ecf43ce1b86afd9d9bd437c5a592ae12fe63b.webp)![Deploying a VSS profile from the agent chat](/vss/_fern-img/12b68e0838fbca76c5b4ab812047bc6f01a88c01f8adf381d33a595edcf174d9.webp)

For the complete orchestrator tool reference, see [VSS Orchestrator MCP](/vision-agent/agent-harnesses/nemoclaw/vss-orchestrator-mcp).

## Run on DGX Spark

DGX Spark is a single-GPU edge system, so it needs a few adjustments before you deploy VSS from chat. Apply the following in `deploy_vss_orchestrator.ipynb`. The same guidance applies to the other edge profiles, `IGX-THOR` and `AGX-THOR`.

1. **Select the DGX Spark hardware profile** (Section 1.1):

   **`Set in deploy_vss_orchestrator.ipynb`**

   ```python title="Set in deploy_vss_orchestrator.ipynb"
   HARDWARE_PROFILE = "DGX-SPARK"
   ```

2. **Deploy only the base or alerts profiles.** `DGX-SPARK` is an edge profile, and the orchestrator supports only `base` and `alerts` on edge hardware. Requests to deploy `search` or `lvs` on an edge profile are rejected.

3. **Point the VSS LLM at a remote endpoint** (Section 1.2). A single GPU can run both a local LLM and the local VLM, but sharing the device often exhausts GPU memory. A remote LLM is recommended:

   **`Set in deploy_vss_orchestrator.ipynb`**

   ```python title="Set in deploy_vss_orchestrator.ipynb"
   LLM_NAME = "nvidia/nemotron-3.5-lightning-30b-a3b"
   LLM_ENDPOINT_URL = "https://integrate.api.nvidia.com"
   LLM_MODEL_TYPE = "openai"
   OPENAI_API_KEY = ""
   ```

   Leave `OPENAI_API_KEY` blank to fall back to `NVIDIA_API_KEY`, which is the key the `integrate.api.nvidia.com` endpoint expects. Set `OPENAI_API_KEY` only when the endpoint authenticates with its own key rather than an NVIDIA key, such as `https://api.openai.com`.

4. **Share the single GPU** (Section 1.2). With a remote LLM from the previous step, set `VLM_DEVICE_ID` to GPU `0` so the local VLM uses the only available GPU:

   **`Set in deploy_vss_orchestrator.ipynb`**

   ```python title="Set in deploy_vss_orchestrator.ipynb"
   LLM_DEVICE_ID = "0"  # ignored when LLM_ENDPOINT_URL is set (no local LLM NIM)
   VLM_DEVICE_ID = "0"  # meaningful setting: place the local VLM on the single GPU
   ```

5. **Expect the Docker pin to skip the downgrade** (`deploy_nemoclaw.ipynb` Section 2.1). On DGX Spark (DGX-OS, arm64), Pin Docker skips the exact-version downgrade when the installed Docker Engine is already within the tested range (`28.3.3` through `29.5.0`), because the DGX-OS apt repository may not carry the exact pinned versions. The packages are still held with `apt-mark hold` so the stack cannot drift past the tested range.

6. **Leave the orchestrator MCP config defaults unless you need to tune them.** `deploy/docker/scripts/vss_orchestrator_mcp_config.yml` already sets DGX Spark defaults such as `VLM_NIM_KVCACHE_PERCENT`, `RTVI_VLLM_GPU_MEMORY_UTILIZATION`, and the SBSA image tags. Change those values only if you need different GPU memory or image settings, then restart the MCP server. See [VSS Orchestrator MCP config YAML](/vision-agent/agent-harnesses/nemoclaw/additional-configuration#vss-orchestrator-mcp-config-yaml).

For the full variable reference, see [Additional Configuration](/vision-agent/agent-harnesses/nemoclaw/additional-configuration).

## Add Video Sources

Once the VSS stack is deployed, open the VSS UI and use the **Video Management** tab to upload video files (MP4, MKV) or add live RTSP camera streams for the agent to ingest. See [Video Management Tab](/system-components/user-interface#4-video-management-tab) for the full walkthrough of upload, RTSP setup, and stream management.