Official agent skill

Deepstream Sop

OfficialApache-2.0Auto-check: notesBackend & APIs

Install Deepstream Sop

skills CLI

$ npx skills add NVIDIA/skills --skill deepstream-sop -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install NVIDIA/skills deepstream-sop --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/deepstream-sop .claude/skills/deepstream-sop && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "deepstream-sop" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/deepstream-sop into .claude/skills/deepstream-sop/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deepstream-sop", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/NVIDIA/skills/tree/main/skills/deepstream-sop

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add NVIDIA/skills --skill deepstream-sop -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install NVIDIA/skills deepstream-sop --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/deepstream-sop .agents/skills/deepstream-sop && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "deepstream-sop" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/deepstream-sop into .agents/skills/deepstream-sop/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deepstream-sop", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add NVIDIA/skills --skill deepstream-sop -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install NVIDIA/skills deepstream-sop --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/deepstream-sop .cursor/skills/deepstream-sop && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "deepstream-sop" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/deepstream-sop into .cursor/skills/deepstream-sop/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deepstream-sop", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/NVIDIA/skills.git --path skills/deepstream-sop

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add NVIDIA/skills --skill deepstream-sop -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install NVIDIA/skills deepstream-sop --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/deepstream-sop .gemini/skills/deepstream-sop && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "deepstream-sop" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/deepstream-sop into .gemini/skills/deepstream-sop/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deepstream-sop", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install NVIDIA/skills deepstream-sop

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add NVIDIA/skills --skill deepstream-sop -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/deepstream-sop .github/skills/deepstream-sop && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "deepstream-sop" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/deepstream-sop into .github/skills/deepstream-sop/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deepstream-sop", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add NVIDIA/skills --skill deepstream-sop -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install NVIDIA/skills deepstream-sop --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/NVIDIA/skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/deepstream-sop .opencode/skills/deepstream-sop && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "deepstream-sop" agent skill from https://github.com/NVIDIA/skills/tree/main/skills/deepstream-sop into .opencode/skills/deepstream-sop/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "deepstream-sop", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: deepstream-sop
GitHub stars: 3.5k
Token cost: ~4.7k tokens
SKILL.md length: 1,143 words
Files: 58 (incl. references)
Skills in repo: 380
Repo updated: Oct 7, 2026
First seen: Oct 7, 2026
Licence: Apache-2.0

At a glance

Even if the user does not name it: verify operator step sequence
SKILL.md covers Models, Architecture Overview, Section Index and Key Files Map, plus 1 more section
Runs Python and Shell scripts from its folder; calls docker
Out-of-order SOP steps

What it does

Deepstream Sop is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Use this skill when building, deploying, evaluating, debugging, or measuring latency for the DeepStream SOP Inference Microservice — a GPU-accelerated FastAPI service that detects whether operators perform assembly-line steps in order via event boundary detection (GEBD) plus VLM classification. Trigger even if the user does not name it: verify operator step sequence, detect missing or out-of-order SOP steps, score factory/work-cell video for procedure compliance, run VLM-based SOP checking on industrial cameras…

Its SKILL.md is about 4.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 60 other files, including reference files (for example `BENCHMARK.md`, `configs/actions.json` and `evals/evals.json`).

It sits in Backend & APIs, covering Operations and SOPs, Microservices and LLM inference and serving. It works with NVIDIA AI Platform, FastAPI, vLLM and Docker. The repository describes itself as: Agent Skills for NVIDIA products — install into Claude Code, Codex, and other coding agents to run Physical AI, robotics, simulation, CUDA, and RAG workflows end to end. The licence is Apache-2.0.

When your agent uses it

Even if the user does not name it: verify operator step sequence
Out-of-order SOP steps
Score factory/work-cell video for procedure compliance
Run VLM-based SOP checking on industrial cameras

Example prompts

“/deepstream-sop”

Requirements

Python 3
A Bash shell
Docker

What it can do on your machine

Read from SKILL.md and the folder at commit 67a13c0. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships script files (Python and Shell, from the files we listed), which the agent can run.
Shell commands in SKILL.md call:
- docker
From the folder's file list and the shell code blocks in SKILL.md.
Network
Links to these hosts (documentation or services it may open):
- github.com
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Deepstream Sop loads about 4.7k tokens when it runs, and up to ~147k if it reads all its reference files. Until then it costs about 243 tokens; SKILL.md has 1,143 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~243
When it runs · the whole SKILL.md, loaded when a task matches: ~4.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them: ~147k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

NoteMentions a .env fileSKILL.md:138

build_deploy.md) | Docker build, deploy, .env configuration |

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from NVIDIA/skills at commit 67a13c0, republished under its Apache-2.0 licence (© NVIDIA). 1,143 words, ~4,736 tokens.

Download SKILL.mdSave it as .claude/skills/deepstream-sop/SKILL.md (or your agent's skills folder). This skill also uses 57 other files; get the full folder from GitHub.

name: deepstream-sop
description: Use this skill when building, deploying, evaluating, debugging, or measuring latency for the DeepStream SOP Inference Microservice — a GPU-accelerated FastAPI service that detects whether operators perform assembly-line steps in order via event boundary detection (GEBD) plus VLM classification. Trigger even if the user does not name it: verify operator step sequence, detect missing or out-of-order SOP steps, score factory/work-cell video for procedure compliance, run VLM-based SOP checking on industrial cameras, or call /v1/chat/completions with a file, RTSP, or Basler camera. Also trigger for its internals: SOPVideoProcessor, DeepStream GEBD model (e.g. DDM) via Triton CAPI, nvds_custom_postprocess, Cosmos Reason 1/2 vLLM, SSE streaming, Kafka NvProto/JSON output, Basler/Pylon camera + emulation, Docker compose, chunk-level latency. Do NOT trigger for generic DeepStream pipelines, object detection/tracking, NIM imports, or video summarization.
owner: windy@nvidia.com
service: deepstream-sop
version: 1.0.0
license: CC-BY-4.0 AND Apache-2.0
reviewed: 2026-04-08
metadata.author: Wind Yuan <windy@nvidia.com>
metadata.tags: deepstream, sop, vlm, triton, gpu
metadata.languages: python
metadata.frameworks: deepstream, triton, fastapi
metadata.domain: video-analytics

DeepStream SOP Inference Microservice Skill

This skill guides AI coding assistants in building, extending, and debugging the NVIDIA DeepStream SOP (Standard Operating Procedure) Inference Microservice — a GPU-accelerated pipeline for temporal action detection and VLM-based SOP compliance monitoring on industrial video feeds.

Reference repository: https://github.com/NVIDIA/sop-monitoring-blueprints/tree/main/microservices/sop-inference-bp Local reference code: sop-inference-bp/ directory (from a local clone of the repository)

Models

Model-agnostic at both inference stages — swap via env var (and Triton dir for GEBD).

Stage	Role	Model class	Default	Swap via
Stage 1 (CV)	Per-frame boundary scoring → chunk segmentation	Generic Event Boundary Detection (GEBD)	DDM (MCG-NJU/DDM) via Triton Python backend	Replace `triton_model_repo/<model>/` + `DDM_MODEL_PATH` (§ 5)
Stage 3 (VLM)	Per-chunk action classification	Vision-language model via vLLM	Cosmos Reason 1 7B (Reason 2 also supported)	Set `VLLM_MODEL_PATH` to a different HF ID or local path

"GEBD" = swappable Stage-1 slot; "DDM" = the default architecture (terms used interchangeably).

Chunking is selectable per request (§ 2): default ddm-net uses GEBD; uniform produces fixed-length chunks and bypasses Stage-1 GEBD (§ 3, § 6). DDM temporal window is configurable via FRAMES_PER_SIDE / SEQUENCE_BATCH (§ 4, § 5), with optional TensorRT (§ 5).

Architecture Overview

Runs in a Docker container (nvds-action-sop) alongside a Kafka container. Full diagram: references/sop_architecture.svg.

Data flow through the 4-stage SOPVideoProcessor pipeline (per-request):

Input Sources                    Docker Container: nvds-action-sop
─────────────                    ──────────────────────────────────────────────────
Video Files ──┐                  FastAPI Server (port 8300)
RTSP Streams ─┤── base64/       ├─ /v1/chat/completions → SOPProcessManager
Basler Camera ┘   file/rtsp/       │
                  camera           │ ModelInitializer: VLM first, then DDM dummy pipeline
                                   │ 4 Thread Pools: cv(32), clip(32), vlm(64), vlm_req(64)
                                   │
                                   ▼ SOPVideoProcessor (per-request)
                                   ┌────────────────────────────────────────────────┐
                                   │ Stage 1: DeepStream Pipeline (GPU)             │
                                   │   Source → nvstreammux → tee1                  │
                                   │    ├─[inference] queue1 → nvdspreprocess       │
                                   │    │  → nvinferserver (Triton CAPI + DDM)      │
                                   │    │  → InferOutputTensorParser → score_queue  │
                                   │    ├─[frames]  queue3 → nvvideoconvert         │
                                   │    │  → capsfilter → appsink                   │
                                   │    │  → DecodedFrameRetriever → frame_queue    │
                                   │    └─[RTSP out] queue → convert → H.264 enc    │  (optional, § 18)
                                   │       → rtppay → udpsink → RTSPServer (§ 18)   │  opt-in only
                                   │              │ boundary scores                 │
                                   │              ▼                                 │
                                   │ Stage 2: Clip Post-Process                     │
                                   │   Boundary detection → chunk segmentation      │
                                   │              │ video frames + timestamps        │
                                   │              ▼                                 │
                                   │ Stage 3: VLM Inference                         │
                                   │   Embedded vLLM (Cosmos Reason 1/2)            │
                                   │   Frame sampling at VLM_FPS → classification   │
                                   │              │ action labels                    │
                                   │              ▼                                 │
                                   │ Stage 4: SOP Checker                           │
                                   │   Sequence validation → missing/misordered     │
                                   │              │ chunk results                    │
                                   │              ▼                                 │
                                   │         final_queue                            │
                                   └────────────────────────────────────────────────┘
                                          │
Output                                    ▼
──────                             ┌─────────────────┐
SSE Stream (chat.completion.chunk) │ Kafka Messages   │
Non-streaming (chat.completion)    │ (JSON/Protobuf)  │
Prometheus metrics (/v1/metrics)   └────────┬────────┘
                                            ▼
                                   Docker Container: kafka
                                   (apache/kafka:3.7.0)

Section Index

Each section is a standalone file in references/ — load only what your task needs.

§	File	Responsibility
1	`skill_01_fastapi_endpoints.md`	FastAPI endpoints, server init, Prometheus metrics
2	`skill_02_pydantic_schemas.md`	Request/response Pydantic models (`api_types.py`)
3	`skill_03_deepstream_pipeline.md`	DeepStream pyservicemaker pipeline, tensor parser, dummy pipeline
4	`skill_04_config_templates.md`	nvdspreprocess / nvinferserver config templates + rendering
5	`skill_05_triton_ddm_model.md`	Triton model repo, config.pbtxt, model.py, ddm_net.py
5b	`skill_05b_custom_postprocess.md`	C++ postprocess plugin, Makefile, IOptions API
6	`skill_06_sop_process_manager.md`	SOPProcessManager, SOPVideoProcessor, VLLMInference, Kafka
6b	`skill_06b_sop_checker.md`	SOP sequence and checker compliance: MissingNumberDetector, SopCheckerCache, SopCheckerRequest/Response
7	`skill_07_sse_streaming.md`	SSE generator, stream response formatting, dummy test mode
8	`skill_08_basler_camera.md`	Basler camera support, Pylon SDK, emulation, formats
9	`skill_09_docker_build_deploy.md`	Docker build, deploy, .env configuration
10	`skill_10_test_suite.md`	Test suite coverage, assertions, running tests
11	`skill_11_env_variables.md`	All environment variables reference
12	`skill_12_evaluation_workflow.md`	End-to-end eval workflow: static checks, build, launch, tests, API/camera/Kafka checks, report
13	`skill_13_verification_curl.md`	Verification steps and curl examples
14	`skill_14_implementation_checklist.md`	Implementation checklist: file copy list, generated files, Docker prereqs, verification
15	`skill_15_latency_measurement.md`	TTFC and C2C latency measurement for file input via SSE streaming
16	`skill_16_message_schema.md`	Kafka message schema selection (`JSON` default vs `NvProtoSchema`) and extending messages with custom data
17	`skill_17_camera_latency_measurement.md`	Camera / live-stream chunk_e2e latency measurement using internal pipeline timestamps
18	`skill_18_rtsp_streaming_output.md`	OPT-IN RTSP streaming output: `tee1`-tap re-stream, `RTSPStreamingServer`, `SW_ENCODER` toggle. Generate only when user explicitly requests RTSP

For end-to-end evaluation, read § 12 first; load build/test/curl/latency/camera/Kafka as needed.

§ 18 is opt-in — generate only when the user explicitly requests RTSP output; otherwise skip § 18 and the RTSP_* rules below.

Key Files Map

The full source-to-target file mapping lives in skill_14_implementation_checklist.md:

Files copied verbatim from references/ (non-trivial algorithms — cycle detection, qwen_vl_utils preprocessing, DeepStream IOptions API, protobuf sources) with the rationale per file.
Files copied as adaptable templates (Dockerfile, compose.yaml, Triton config and model.py, ddm_net.py, Pylon emulation config, etc.).
Files generated from skill sections — each annotated with the Critical Rules below that the generation must follow exactly.
Docker build prerequisites and post-build verification checklist.

Config files (nvds_preprocess_template.txt, nvds_inference_template.txt, vlm_prompts.txt) are used as-is from configs/.

When skill_06b is loaded, read configs/actions.json from the project root and run the § 6b-G generation workflow to produce nvds_action_detector/missing_number_detector.py. If configs/actions.json is absent or invalid, fall back to copying the reference file.

Show full SKILL.md (591 more words)Show less

Critical Rules

Each rule's full detail lives in the linked skill_NN_*.md reference file.

Tag	Rule summary	Details in
`MANAGER_INIT_IN_MAIN`	`SOPProcessManager` init in `main()` before `uvicorn.run()` — not inside `lifespan()`	`skill_01_fastapi_endpoints.md`
`NAMED_KWARGS`	`create_video_processor()` uses named kwargs; camera args as separate kwargs	`skill_06_sop_process_manager.md`
`LIVE_REQUIRES_STREAM_TRUE`	`stream: true` required for live inputs (RTSP / camera)	`skill_08_basler_camera.md`
`VLM_DISABLED_DISABLES_SOP_CHECKER`	`DISABLE_VLM_INFERENCE=true` auto-disables SOP checker at import	`skill_06_sop_process_manager.md`
`CHUNK_PARAMS_MAX_LENGTH`	`ChunkParams.max_length_sec` = 10s internal; 60s API default	`skill_06_sop_process_manager.md`
`VLM_WARMUP_BEFORE_DDM`	`ModelInitializer`: VLM warmup FIRST, then CV dummy pipeline	`skill_06_sop_process_manager.md`
`VLM_WARMUP_3_FRAMES`	VLM warmup needs 3 frames (`torch.zeros`) — Qwen3VL hangs on < 3	`skill_06_sop_process_manager.md`
`THREAD_POOL_SIZES`	4 thread pools: `cv`(32), `clip`(32), `vlm_inference`(64), `vlm_request`(64)	`skill_06_sop_process_manager.md`
`MEDIA_INFO_PYMEDIAINFO`	Media info via `pymediainfo`; live sources set fps=30/duration=inf directly	`skill_06_sop_process_manager.md`
`CAMERA_EMULATION_PYLON_CAMEMU`	`PYLON_CAMEMU=1` for camera emulation (serial `0815-0000`)	`skill_08_basler_camera.md`
`DEEPSTREAM_LIB_HIDE`	DeepStream lib hide trick: rename lib → lib.tmp during gst-plugin-pylon build	`skill_08_basler_camera.md`
`VLM_REAL_GPU_FRAMES`	VLM uses real GPU frames via `DecodedFrameRetriever`; never `torch.zeros` for inference	`skill_06_sop_process_manager.md`
`BUFFER_RETRIEVER_STATIC_BASE`	`DecodedFrameRetriever` MUST inherit `BufferRetriever` statically via `super().__init__()`; runtime `__class__.__bases__` mutation hangs `pipeline.attach()`	`skill_06_sop_process_manager.md`
`FRAME_RETRIEVER_PRIORITY`	`create_inference_pipeline`: `frame_retriever=` kwarg takes priority over `frame_queue`	`skill_03_deepstream_pipeline.md`
`MUX_ORIGINAL_RESOLUTION`	nvstreammux uses original resolution (not 224); pass `mux_width/mux_height` from `get_media_info()` (probe live RTSP for non-camera inputs; camera path unaffected)	`skill_03_deepstream_pipeline.md`, `skill_06_sop_process_manager.md`
`FILE_URI_NO_DOUBLE_PREFIX`	`create_inference_pipeline` file source: check `file_path.startswith("file://")` before prepending — API passes `file://` URLs directly	`skill_03_deepstream_pipeline.md`
`CLEANUP_ON_DISCONNECT`	Pipeline cleanup on client disconnect via `trigger_stop_processors` in `try/finally`	`skill_07_sse_streaming.md`
`UNIFIED_CLIP_POST_PROCESS`	Unified `clip_post_process()` for file + live; `stop()` puts `None` in `_score_queue`	`skill_06_sop_process_manager.md`
`ABORT_INFLIGHT_VLM`	Abort in-flight VLM requests on `stop()` via `llm.abort(req_id)`	`skill_06_sop_process_manager.md`
`LOGGER_EXPORT_GET_LOGGER`	`ds_logger.py` must export `get_logger`	`skill_06_sop_process_manager.md`
`KAFKA_USE_CREATE_PRODUCER`	Kafka: use `create_producer()` from `messager.py`; no `Messager` class	`skill_06_sop_process_manager.md`
`USER_PROMPT_PRIORITY`	User request text takes priority over `VLM_PROMPT_PATH` file; `{"type":"text"}` in the request overrides the config-file prompt	`skill_06_sop_process_manager.md`
`EVAL_USE_CONFIG_PROMPT`	Eval/latency requests omit request text by default so the VLM uses `VLM_PROMPT_PATH`	`skill_12_evaluation_workflow.md`, `skill_13_verification_curl.md`, `skill_15_latency_measurement.md`, `skill_17_camera_latency_measurement.md`
`CHUNK_SCHEMA_FIELD_NAMES`	Chunk schema: `chunk_idx`, `cv_boundary_score`, `checker_result`; summary `chunk_idx=-1`	`skill_06_sop_process_manager.md`
`SEQUENTIAL_FRAME_DRAIN`	Drain `decoded_frame_queue` (FIFO, shared across chunks) in a SINGLE thread and submit VLM per chunk incrementally; parallel drain steals frames → 0-frame chunks / wrong VLM input	`skill_06_sop_process_manager.md`
`WALL_CLOCK_BEFORE_GPU`	`DecodedFrameRetriever.consume()`: capture `wall_clock_entry = time.time()` BEFORE GPU dlpack; queue 3-tuple `(timestamp, wall_clock_entry, tensor)`	`skill_06_sop_process_manager.md`, `skill_17_camera_latency_measurement.md`
`CHUNK_E2E_PIPELINE_TIMESTAMPS`	Write `pipeline_chunk_end_timestamp` (last frame wall_clock) and `pipeline_vlm_ready_timestamp` (`tm_e2e.now()`) into `chunk_info` for camera latency (§ 17)	`skill_06_sop_process_manager.md`, `skill_17_camera_latency_measurement.md`
`VLM_INFERENCE_REQUIRED_KWARGS`	Every `VLLMInference.inference()` call must pass `video_fps`, `system_prompt`, `max_completion_tokens`	`skill_06_sop_process_manager.md`
`UNIFORM_CHUNKING_BYPASSES_DDM`	`chunking_options.algorithm="uniform"` → fixed-length chunks; `create_inference_pipeline(uniform_chunk=True)` skips DDM but keeps `tee1` fanout; Stage 2 uses `uniform_clip_post_process`	`skill_02_pydantic_schemas.md`, `skill_03_deepstream_pipeline.md`, `skill_06_sop_process_manager.md`
`DDM_TEMPORAL_CONFIGURABLE`	`SLIDING_WINDOWS_SIZE = 2*FRAMES_PER_SIDE + SEQUENCE_BATCH` rendered into preprocess/nvinferserver (no hard-coded 18); Triton `config.pbtxt` sequence dim `-1`	`skill_04_config_templates.md`, `skill_05_triton_ddm_model.md`
`DDM_TRT_OPTIONAL_PATH`	`DDM_TRT_OPTIMIZATION=true` runs DDM via TensorRT (per-thread contexts, fixed batch = SEQUENCE_BATCH); PyTorch fallback; never both. PyTorch is default	`skill_05_triton_ddm_model.md`
`DDM_TRT_STREAM_ORDERING`	`DDMTensorRTEngine.infer()`: `wait_stream(current)` → `execute_async_v3` → `torch.cuda.synchronize(device)` (NOT per-stream). Per-stream sync leaves TRT aux-stream work in flight → gst-CV SIGSEGV (NVBug 6289256)	`skill_05_triton_ddm_model.md`
`METADATA_LICENSE_FROM_FILE`	`/v1/metadata` reads `licenseInfo` from `DS_SOP_LICENSE_PATH` (default `/opt/nvidia/nvds_sop/license.txt`); never hard-code license text	`skill_01_fastapi_endpoints.md`
`CAMERA_EMULATION_FRAMES_RGB`	Pylon emulation PNGs must be explicit 3-channel RGB (matches `Emulation_0815-0000.pfs PixelFormat=RGB8Packed`); generate via `nvvideoconvert ! videoconvert ! "video/x-raw,format=RGB" ! pngenc`	`skill_08_basler_camera.md`
`COMPOSE_ENV_PASSTHROUGH`	`docker compose` only substitutes `${VAR}` references; every runtime env var must be explicitly listed under `environment:` to reach the container.	`skill_09_docker_build_deploy.md`

The four RTSP_* rules below apply only when the optional RTSP streaming-output feature (§ 18) is requested. They do not apply to the default build — skip them if the user did not ask for RTSP output.

| RTSP_OUTPUT_TAPS_TEE1 | RTSP output branch links from the existing tee1 (added after the main inference link) only when rtsp_port is present. | skill_18_rtsp_streaming_output.md | | RTSP_LEAKY_QUEUE_TINY | RTSP branch queue must be leaky=2 + tiny cap (max-size-buffers=2) to prevent backpressure and NVMM pool exhaustion. | skill_18_rtsp_streaming_output.md | | RTSP_KEYINT_MAX_30 | RTSP H.264 encoder must set key-int-max=30 (and B-frames disabled) to allow downstream seeking. | skill_18_rtsp_streaming_output.md | | RTSP_ENCODER_FALLBACK | Select software/hardware H.264 encoder based on SW_ENCODER with MJPEG fallback. | skill_18_rtsp_streaming_output.md |

Files

SKILL.md and 57 other files (references) in skills/deepstream-sop of NVIDIA/skills.

SKILL.md
BENCHMARK.md
configs/actions.json
configs/nvds_inference_template.txt
configs/nvds_preprocess_template.txt
configs/vlm_prompts.txt
evals/evals.json
references/Dockerfile_reference
references/Emulation_0815-0000.pfs
references/Makefile_custom_postprocess_reference
references/README_reference.md
references/compose_reference.yaml
references/copy_sources_reference.sh
references/ddm_net_reference.py
references/ddm_pytorch2.patch
references/eval_sop_prompt.md
references/example_sop_prompt.md
references/export_ddm_to_tensorrt_reference.py
… and 40 more

Open the folder on GitHubat commit 67a13c0

Compare with similar skills

Deepstream Sop next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Deepstream Sop compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Deepstream Sop this skillNVIDIA/skills	3.5k	—	~4.7k	Automated safety check: Notes	Apache-2.0	today
Multimodal Dataprep Devopen-edge-platform/edge-ai-libraries	169	—	~1.3k	Automated safety check: Pass	Apache-2.0	today
Spring Boot Saga Patterngiuseppe-trisciuoglio/developer-kit	355	—	~2.5k	Automated safety check: Notes	MIT	28 days ago
Scaffolding Fastapi Dapraiskillstore/marketplace	430	—	~2.2k	Automated safety check: Pass	None	yesterday
Dstack Prototypingdstackai/dstack	2.3k	—	~1.6k	Automated safety check: Pass	MPL-2.0	yesterday
Serving LLMs On Instinctamd/skills	398	—	~4k	Automated safety check: Notes	MIT	today

Similar skills

Multimodal Dataprep Dev
open-edge-platform/edge-ai-libraries
Develop and debug the Multimodal DataPrep microservice: its FastAPI media endpoints, in-process embedding pipeline, batch jobs, object detection, telemetry and Metrics Manager publishing, and…
169 GitHub stars~1.3k tokensUpdated today
Backend & APIsAuto-check passed
Spring Boot Saga Pattern
giuseppe-trisciuoglio/developer-kit
Provides distributed transaction patterns using the Saga Pattern for Spring Boot microservices.
355 GitHub stars~2.5k tokensUpdated 28 days ago
Backend & APIsAuto-check: notes
Scaffolding Fastapi Dapr
aiskillstore/marketplace
Build production-grade FastAPI backends with SQLModel, Dapr integration, and JWT authentication.
430 GitHub stars~2.2k tokensUpdated yesterday
Backend & APIsAuto-check passed
Dstack Prototyping
dstackai/dstack
Use with the dstack skill for model-serving work when the image, serving command, resources, backend/fleet choice, or service behavior is not proven.
2.3k GitHub stars~1.6k tokensUpdated yesterday
AI & LLM EngineeringAuto-check passed
Serving LLMs On Instinct
amd/skills
Serves AI models on AMD Instinct GPU hardware using vLLM. An agent skill from amd/skills.
398 GitHub stars~4k tokensUpdated today
AI & LLM EngineeringAuto-check: notes
LlamaGuard Content Moderation
Orchestra-Research/AI-Research-SKILLs
Uses Meta's LlamaGuard moderation model to screen prompts and model replies against six safety categories, with vLLM, FastAPI and NeMo Guardrails setups.
13k GitHub starsUsed in 3 repos~2.3k tokens
AI & LLM EngineeringAuto-check passed

More from NVIDIA/skills

All 380 skills in this repo

Vss Deploy Detection Tracking 2D
NVIDIA/skills
Official
A skill your agent uses when the user wants to deploy, run, debug, tear down, or call the REST API of the RTVI-CV 2D detection / tracking microservice.
3.5k GitHub starsUsed in 1 repo~4.5k tokens
Auto-check passed
HSB IP Def File Tool
NVIDIA/skills
Official
Generates, validates, compares and explains HOLOLINK_def.svh macro files for the HSB IP, using bundled Python scripts and asking before it writes anything.
3.5k GitHub stars~2.9k tokensUpdated today
Auto-check passed
Isaac Sim Mission Control Showcase
NVIDIA/skills
Official
Runs and validates an end-to-end Mission Control demo in a locally installed Isaac Sim, with a Nova Carter robot driven through a Python server.
3.5k GitHub stars~4.8k tokensUpdated today
Auto-check passed
Defect Image Generation with Cosmos AnomalyGen
NVIDIA/skills
Official
Orchestrates defect image generation for PCBA, metal surface and glass inspection with NVIDIA Cosmos AnomalyGen on OSMO, from cold-start Day 0 to real-photo Day 1 labeling.
3.5k GitHub stars~5k tokensUpdated today
Auto-check: notes
Physical AI Video Augmentation on OSMO
NVIDIA/skills
Official
Orchestrates video data augmentation and auto-labeling workflows on OSMO, from flow selection and preflight checks to submission, monitoring and output download.
3.5k GitHub stars~4.7k tokensUpdated today
Auto-check: notes
TAO Detection KPI Analysis
NVIDIA/skills
Official
Runs NVIDIA TAO Data Services KPI analysis on object detection results, comparing predictions to ground truth and writing per-class precision, recall and AP to a CSV.
3.5k GitHub stars~2.7k tokensUpdated today
Auto-check: notes

Works with

Questions about Deepstream Sop

What does Deepstream Sop do?

A skill your agent uses when building, deploying, evaluating, debugging, or measuring latency for the DeepStream SOP Inference Microservice — a GPU-accelerated FastAPI service that detects whether…. Deepstream Sop is an agent skill from NVIDIA/skills, published by the product's own GitHub organization. Use this skill when building, deploying, evaluating, debugging, or measuring latency for the DeepStream SOP Inference Microservice — a GPU-accelerated FastAPI service that detects whether operators perform assembly-line steps in order via event boundary detection (GEBD) plus VLM classification.

When should I use Deepstream Sop?

Deepstream Sop fits situations like: even if the user does not name it: verify operator step sequence; out-of-order SOP steps; score factory/work-cell video for procedure compliance; run VLM-based SOP checking on industrial cameras.

How do I install Deepstream Sop in Claude Code?

Run `npx skills add NVIDIA/skills --skill deepstream-sop -a claude-code`. Or copy the skill folder (skills/deepstream-sop in NVIDIA/skills) into .claude/skills/deepstream-sop in your project. Claude Code loads it when a task matches its description.

How do I install Deepstream Sop in Codex?

Run `npx skills add NVIDIA/skills --skill deepstream-sop -a codex`. Or copy the skill folder (skills/deepstream-sop in NVIDIA/skills) into .agents/skills/deepstream-sop in your project. Codex loads it when a task matches its description.

Can I use Deepstream Sop in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add NVIDIA/skills --skill deepstream-sop -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/deepstream-sop, .gemini/skills/deepstream-sop, .github/skills/deepstream-sop and .opencode/skills/deepstream-sop in your project.

What does Deepstream Sop need to run?

Going by SKILL.md and its folder, Deepstream Sop needs Python and a shell for the scripts in its folder and the command-line tools its instructions call (docker). Our summary lists: Python 3; A Bash shell; Docker.

Does Deepstream Sop access the network?

SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.

Is Deepstream Sop safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Deepstream Sop use?

Deepstream Sop is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Deepstream Sop use?

About 4.7k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 143k tokens, read only when the agent opens those files.

What are the alternatives to Deepstream Sop?

Skills that share tags, products or a category with Deepstream Sop: Multimodal Dataprep Dev (open-edge-platform/edge-ai-libraries, 169 stars), Spring Boot Saga Pattern (giuseppe-trisciuoglio/developer-kit, 355 stars), Scaffolding Fastapi Dapr (aiskillstore/marketplace, 430 stars) and Dstack Prototyping (dstackai/dstack, 2.3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Deepstream Sop?

NVIDIA (a GitHub organization, an official publisher) maintains it in NVIDIA/skills, which has 3,539 GitHub stars. The repository holds 380 skills in this directory. The repository was last updated on October 7, 2026.

Source: NVIDIA/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Deepstream Sop

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

DeepStream SOP Inference Microservice Skill

Models

Architecture Overview

Section Index

Key Files Map

Critical Rules

Files

Compare with similar skills

Similar skills

More from NVIDIA/skills

Related

Questions about Deepstream Sop