DeepStreamコーディングエージェントを使用したビジョンAIパイプライン構築方法
NVIDIAは、リアルタイムビジョンAIアプリケーション開発の複雑さを軽減するために、DeepStream Coding Agentsを用いたAIパイプライン構築方法を開発者向けに紹介している。
キーポイント
開発課題の解決
リアルタイムビジョンAIアプリケーション開発における複雑なデータパイプラインと膨大なコード記述という課題を、DeepStream Coding Agentsが解決する。
エージェントの機能
DeepStream Coding Agentsは、開発者が自然言語で指示を与えることで、複雑なビジョンAIパイプラインのコードを自動生成・最適化する機能を提供する。
実用性の強調
このアプローチにより、開発者はインフラ構築や最適化に費やす時間を削減し、アプリケーションの核心的なAIロジックの開発に集中できるようになる。
NVIDIAプラットフォームの統合
DeepStream Coding Agentsは、NVIDIAのDeepStream SDKやその他のAIツールチェーンと統合されており、同社のエコシステム内での効率的な開発を可能にする。
影響分析・編集コメントを表示
影響分析
この記事は、AI開発の民主化と効率化をさらに推し進める可能性を示している。特に、複雑なビジョンAIパイプライン構築のハードルを下げることで、より多くの開発者が高度なAIアプリケーション開発に参入できる環境を整備する。NVIDIAのプラットフォーム戦略の一環として、自社エコシステムの価値を高める効果も期待される。
編集コメント
技術的な詳細がやや不足している印象だが、開発者向けの実用的なソリューションとしての価値は明確。NVIDIAの開発者エンゲージメント戦略の一環として位置づけられる内容。
リアルタイムのビジョンAI（Vision AI）アプリケーションの開発は開発者にとって大きな課題であり、しばしば複雑なデータパイプライン（Data Pipelines）、膨大な数のコード行、そして長期にわたる開発サイクルを要求します。
NVIDIA DeepStream 9は、Claude CodeやCursorなどのコーディングエージェント（Coding Agents）を活用することで、これらの開発上の障壁を取り除き、デプロイ可能で最適化されたコードを簡単に作成するのを支援し、ビジョンAIアプリケーションの立ち上げをより迅速に行えるようにします。
この新しいアプローチは、大量のリアルタイム動画、音声、センサーデータを取得し、処理、分析する複雑なマルチカメラパイプライン（Multi-Camera Pipelines）の構築プロセスを簡素化します。GStreamerを基盤とし、NVIDIA MetropolisビジョンAI開発プラットフォームの一部であるDeepStreamは、業界全体を通じて、開発者のコンセプトから実行可能なインサイトへの到達を加速します。
動画1：Claude Codeを使用して、自然言語のプロンプトから完全なビジョンAIパイプライン（Vision AI Pipelines）を生成する方法。NVIDIA DeepStreamコーディングエージェントの使用方法。
Claude CodeまたはCursorを使用してDeepStreamビジョンAIパイプラインを構築する様子を示す録画を見るには、こちらをクリックしてください。
NVIDIA Cosmos Reason 2を使用したビデオ分析アプリケーション（Video Analytics App）の構築
物理AI（Physical AI）向けで最も正確かつオープンな推論型ビジョン言語モデル（VLM）であるNVIDIA Cosmos Reason 2を用いることで、数百のカメラストリームを同時に取得し、ビジョン言語モデル（VMA）で分析するビデオ分析アプリケーションを構築することが可能です。
このアプリケーションは動的にスケーリングし、カメラの追加やモデルの交換に伴う再デプロイ時間（Redeployment Time）の無駄や、ボトルネック（Bottlenecks）の推測を不要とします。コーディングエージェントはハードウェアを理解し、それに最適化されたアプリケーションを生成します。
数行のプロンプトを書くだけで、REST APIs、ヘルスモニタリング、デプロイ自動化、Kafka連携（Kafka Integration）を備えた本格的なマイクロサービス（Microservice）を、単一の開発セッションで完全生成できます。
VLM搭載のビジョンAIアプリケーションを生成する方法：
ステップ1：Claude CodeまたはCursor用のDeepStream Coding Agentスキルをインストールします。コード生成はどこでも可能ですが、デプロイにはGitHubに記載されている最小限のハードウェアが必要です。
ステップ2：以下のプロンプトをエージェントに貼り付け、動的なNストリーム取得（Dynamic N Stream Ingestion）とストリームごとのバッチ処理（Per-Stream Batching）を備えたスケーラブルなVLMパイプライン（VLM Pipeline）を生成します。
Pythonアプリケーションを実装し、マルチモーダルVLM（Vision Language Model）を使用して動画フレームを要約し、その要約をKafka経由でリモートサーバーに送信します。構成（Architecture）: 1. DeepStreamパイプライン: DeepStream pyservicemaker APIを使用して、N本のRTSPストリームを受信し、動画をデコードしてフレームをRGB形式に変換します。各ストリームは独立して処理してください——ストリームを結合（mux）しないでください。 2. フレームサンプリングとバッチ処理: MediaExtractorを使用して、設定可能な間隔（例：10秒ごとに1フレーム）でフレームをサンプリングします。VLMがマルチフレーム入力をサポートする場合、モデルに送信する前に設定可能な期間（例：1分）にわたってサンプリングされたフレームをバッチ化します。各バッチには、単一のストリームからのフレームのみを含める必要があります。 3. VLMバックエンド: デコードされた動画フレームのバッチを受信し、マルチモーダルVLMからのテキスト要約を返すモジュールを実装します。 4. Kafka出力: 各テキスト要約をKafkaを使用してリモートサーバーに送信します。制約条件: - 単一ノード内の複数のGPUにわたる数百本のRTSPストリームへスケーラブルであること。利用可能なすべてのGPUに処理負荷を分散してください。 - 単一のバッチ内で異なるRTSPストリームのフレームを絶対に混在させないこと。出力は rtvi_app ディレクトリに保存してください。また、KafkaサーバーとvLLMのセットアップ方法、アプリケーションの実行方法を記載した README.md を生成してください。
フレームサンプリング間隔（例：10秒ごとに1フレームなど）などのパラメータをカスタマイズできます。Cosmos-Reason2-8Bは固定のフレーム制限を課さず、大規模なコンテキストウィンドウ（最大256Kトークン）を使用し、fpsと解像度に基づいてフレームを動的にサンプリングします。
ステップ3：動作するアプリケーションが完成したので、次はデプロイ可能な状態に整えましょう。さらに1つのプロンプトを入力するだけで、ストリームを動的に管理するための表現状態転送（REST）API、オーケストレーション用のヘルスプローブ、可観測性用のメトリクス、コンテナ化用のDockerfile、そして数分で実行を可能にするデプロイメントスクリプトを備えた本格的な生産用マイクロサービスに変換できます：
@rtvi_app ディレクトリ内のアプリケーション用のマイクロサービスを作成する必要があります。以下の手順に従って完了してください。
- 添付画像
@rtvi_vlm_openapi_spec.pngに記載されているエンドポイントを実装するFastAPIベースのサーバーを作成してください。 - 後ほどDockerイメージを生成するために使用できる、すべての要素をパッケージ化する
dockerfileを作成してください。 - マイクロサービスを実行するためのデプロイメントガイドを作成してください。
重要事項
- 本番環境対応のコードを生成する必要があり、いかなるエンドポイントについてもダミー実装を作成しないでください。
- エンドポイントの動作する実装を実現するために必要な場合は、
@rtvi_app内のコードを更新してください。
ステップ4：生成されたコードにはデプロイメントスクリプトが含まれており、http://localhost:8080/docs または curl を介してSwagger UIでAPIにアクセスできます。GitHub上のこのページと似た画面が表示されることを想定してください。
任意のモデルを使用して効率的なリアルタイムCV（Computer Vision）アプリケーションを生成する
さらに一歩踏み出しましょう。YOLOv26のようなオープンソースモデルを使用してリアルタイムアプリケーションを構築したい場合を考えます。任意のモデルをDeepStreamに組み込むには、以下の3つのことを把握しておく必要があります：
入力テンソル — 形状とスケーリング（例：[batch, 3, 640, 640]、ピクセル値の正規化）
出力テンソル — 出力テンソルの名前と形状（例：[batch, 300, 6]、各行は [x1, y1, x2, y2, conf, class_id] を表す）
後処理 — 生のモデル出力から最終的な検出結果を抽出するために必要なすべての操作。例えば、非最大値抑制（Non-Maximum Suppression, NMS）がモデル内に組み込まれているか、あるいはモデルの最終層の後に後処理ステップとして必要かどうかを確認します。
これらの情報はモデルカード（Model card）から取得できますし、Netron、VisualDL、Zetane などのモデル可視化・検査ツールを使用するか、単に onnx.load() を実行してグラフの入出力形状を印刷することもできます。あるいは、それらをすべてスキップしてモデルファイルを直接コーディングエージェントに渡すことも可能です。エージェントがモデルを調査し、モデル検査に必要な適切なライブラリを自動的に取得してくれます。
このように考えてください：カスタムモデルを DeepStream のハードウェア最適化済みビデオ分析パイプラインに持ち込みます。モデルの情報を（入力形状、出力形式など）提供すれば、DeepStream が残りの処理をすべて引き受けます。GPU のデコード、計算処理、ダウンストリーム処理を完全に活用する効率的なバッファ管理（Buffer management）により、ハードウェアが達成可能な最高のレイテンシ（Latency）を実現します。
DeepStream コーディングエージェントを使用して YOLOv26 検出アプリを生成する手順は以下の通りです：
ステップ 1：DeepStream Coding Agent のスキルがインストールされており、デプロイに必要な最小限のハードウェアを準備していることを確認してください。Claude Code または Cursor 用の DeepStream Coding Agent スキルをインストールします。コード生成はどこで行っても構いませんが、デプロイには GitHub に記載されている最小限のハードウェア要件を満たす必要があります。
ステップ 2：以下のプロンプトをエージェントに貼り付けます：
ultralytics ライブラリ（Ultralytics library）を使用して YOLO26s 検出モデルをダウンロードし、Python の仮想環境内で動的バッチ（Dynamic batch）をサポートする ONNX モデルに変換してください。モデル用の DeepStream カスタムパーシングライブラリ（DeepStream Custom Parsing Library）を作成してください。DeepStream SDK の pyservicemaker API を使用して、以下の機能を持つ Python アプリケーションを開発してください。- ファイルから読み込み、ビデオをデコードし、モデルを使用して推論を実行する。- カスタムパーシングライブラリは nvinfer の設定ファイルで使用される。- OSD（画面表示機能）を使用して検出されたオブジェクトの周囲にバウンディングボックスを表示する。生成されたコードは yolo_detection ディレクトリに保存してください。アプリは入力として RTSP ストリーム（RTSP Streams）をサポートする必要があります。
ステップ 3：エージェントは複数のファイルを含む完全なアプリケーションを生成します。モデルダウンロードスクリプト、パイプラインアプリ、推論設定ファイル（Inference config file）などです。
モデル統合において重要なファイル、つまり推論設定ファイルに焦点を当てましょう。ここで知っておくべき 3 つの要素（入力テンソル、出力テンソル、後処理）が推論設定ファイルのどこに現れるかを正確に示します：
入力テンソル（Input tensor）：これは、アップストリームの GPU バッファをどのように前処理するか（640×640 にリサイズし、ピクセル値を 1/255 でスケーリング）を DeepStream に指示し、TensorRT に渡すものです。ONNX ファイルは初回実行時に自動的に TensorRT エンジン（TensorRT engine）に変換され、特定の GPU とバッチサイズに最適化されます。
推論設定ファイルには以下の記述が含まれます：
infer-dims=3;640;640net-scale-factor=1/255onnx-file=yolo26s.onnx
出力テンソル（Output tensor）と後処理（Post-Processing）：エージェントは NvDsInferParseCustomYolo 関数を生成し、yolo26s の output0 という名前の出力ブロブ（output blob）を読み取り、各行が [x1, y1, x2, y2, conf, class_id] である [300, 6] テンソル（tensor）から各検出結果を NvDsInferObjectDetectionInfo 構造体に変換します。
extern "C" bool NvDsInferParseCustomYolo( std::vector const &outputLayersInfo, ... std::vector &objectList) {
...
const float *det = data + i * 6;
obj.classId = static_cast(det[5]);
obj.detectionConfidence = det[4];
obj.left = det[0]; obj.top = det[1];
obj.width = det[2] - det[0]; obj.height = det[3] - det[1];
...
objectList.push_back(obj);
}これが、下流の NvDsBatchMeta 内の ObjectMeta を埋める処理です。推論設定には以下の指定が含まれます：
custom-lib-path=nvdsinfer_custom_impl_yolo/libnvdsinfer_custom_impl_yolo.so parse-bbox-func-name=NvDsInferParseCustomYolo output-blob-names=output0
ステップ4：これを本番用のマイクロサービス（microservice）に変換するには（上記のVLMアプリ例、ステップ3と同様）、ストリーム管理、ヘルスプローブ、メトリクス、Dockerfile、デプロイメントスクリプトを追加するためのFastAPIエンドポイントを作成するよう、同様のプロンプトを使用します。
ステップ5：生成されたスクリプトでデプロイし、http://localhost:8080/docs または curl を介して Swagger UI からAPIにアクセスします。
これら2つのアプリケーションは始まりに過ぎません。同じスキルを用いて、マルチカメラ追跡からオーディオ分析、カスタム推論チェーンに至るまで、あらゆるDeepStreamパイプライン（pipeline）を生成できます。
リポジトリでさらに多くの例示プロンプトをご覧ください。これらを参考にして、想像できるあらゆるビジョンAI（vision AI）アプリケーション用の独自のプロンプトを作成してください：
- 4つのRTSPカメラとタイル表示によるマルチストリーム追跡
- 分析 — ROIフィルタリング、ラインクロッシング、過密検出、方向検出
- 境界ボックス表示付きのビデオファイル推論
- クラスごとのオブジェクトカウント付きのビデオ推論
- カスタムONNXエクスポートとパーサーを備えたYOLOv26s検出
- KafkaによるマルチストリームVLMビデオ要約
- Dockerfileとデプロイメントを備えたFastAPIマイクロサービスラッパー
ビジョンAI開発の再定義
DeepStreamはエージェント型ワークフロー（agentic workflows）によりビジョンAI開発を加速し、コーディング時間を数週間から数時間に短縮します。自然言語によるプロンプトを使用することで、開発者はモデルを即座に組み込み、カメラストリームを設定し、分析アプリケーションを展開できます。NVIDIAハードウェア向けに最適化されたDeepStreamは、汎用パイプラインよりも1ドルあたりのストリーム数と分析処理量が多く、エッジからクラウドまでパフォーマンスを最大化します。
始め方
Jetson、データセンターGPU、またはクラウド向けにNGCで最新のSDKをダウンロードし、DeepStreamの構築を開始してください。
リソース
DeepStreamのダウンロード
ドキュメント
GTC 2026 ラボ オンデマンド
原文を表示
Developing real-time vision AI applications presents a significant challenge for developers, often demanding intricate data pipelines, countless lines of code, and lengthy development cycles.
NVIDIA DeepStream 9 removes these development barriers using coding agents, such as Claude Code or Cursor, to help you easily create deployable, optimized code that brings your vision AI applications to life faster.
This new approach simplifies the process of building complex multi-camera pipelines that ingest, process, and analyze massive volumes of real-time video, audio, and sensor data. Built on GStreamer and part of the NVIDIA Metropolis vision AI development platform, DeepStream accelerates a developer’s journey from concept to actionable insight across industries.
Video 1. How to use the NVIDIA DeepStream coding agents to generate complete vision AI pipelines from natural language prompts with Claude Code.
To watch a recording showing how to build a DeepStream vision AI pipeline using Claude Code or Cursor, click here.
Using NVIDIA Cosmos Reason 2 to build a video analytics app
It is possible to build a video analytics app that concurrently ingests hundreds of camera streams and analyzes the streams with a vision language model (VMA) using NVIDIA Cosmos Reason 2, the most accurate, open, reasoning VLM for physical AI.
The application scales dynamically with no wasted redeployment time to add cameras or swap models and no guessing at bottlenecks. The coding agent understands your hardware and generates an application optimized for it.
With just a few lines, a prompt can generate a complete production-grade microservice with REST APIs, health monitoring, deployment automation, and Kafka integration — all in one development session.
How to generate a VLM-powered vision AI application:
Step 1: Install the DeepStream Coding Agent skill for Claude Code or Cursor. You can generate code anywhere, but deployment requires the minimum hardware, listed on GitHub.
Step 2: Paste the prompt below into your agent to generate a scalable VLM pipeline with dynamic N stream ingestion and per-stream batching.
Implement a Python application that uses a multi-modal VLM to summarize video frames and sends summaries to a remote server via Kafka.Architecture: 1. DeepStream Pipeline: Use DeepStream pyservicemaker APIs to receive N RTSP streams, decode video, and convert frames to RGB format. Process each stream independently — do not mux streams together. 2. Frame Sampling & Batching: Use MediaExtractor to sample frames at a configurable interval (e.g. 1 frame every 10 seconds). When the VLM supports multi-frame input, batch sampled frames over a configurable duration (e.g. 1 minute) before sending to the model. Each batch must contain frames from a single stream only. 3. VLM Backend: Implement a module that receives a batch of decoded video frames and returns a text summary from the multi-modal VLM. 4. Kafka Output: Send each text summary to a remote server using Kafka. Constraints: - Scalable to hundreds of RTSP streams across multiple GPUs on a single node. Distribute processing load across all available GPUs. - Never mix frames from different RTSP streams in a single batch. Store output in the rtvi_app directory. Also generate a README.md with instructions to setup kafka server, vLLM, and how to run the application.
You can customize parameters such as the frame sampling interval (for example,, 1 frame every 10 seconds; Cosmos-Reason2-8B doesn’t impose a fixed frame limit, it uses a large context window (up to 256K tokens) and samples frames dynamically based on fps and resolution.
Step 3: Now that you have a working application, let’s make it deployment-ready.With one more prompt, you can convert it into a full production microservice, complete with representational state transfer (REST) APIs to dynamically manage streams, health probes for orchestration, metrics for observability, a Dockerfile for containerization, and deployment scripts to get it running in minutes:
Need to create microservice for the app in @rtvi_app directory. Follow the steps below to complete that. - Create FastAPI based server and implement the endpoints mentioned in the attached image @rtvi_vlm_openapi_spec.png. - Create dockerfile to package the everything together which can later be used to generate docker image. - Create deployment guide to run the microservice. IMPORTANT - Need to generate production ready code and don't create dummy implementation for any of the endpoint. - Update the code in @rtvi_app if it is required for having the working implementation of the endpoints.
Step 4: The generated code will have the deployment scripts and access APIs via Swagger UI at http://localhost:8080/docs or curl. You can expect a page similar to this page on GitHub.
Generating an efficient realtime CV application using any model
Now let’s take it further. Say you want to build a real-time application using an open-source model like YOLOv26. To plug any model into DeepStream, you need to know three things:
Input tensor — shape and scaling (e.g., [batch, 3, 640, 640], normalize pixels)
Output tensor — name and shape of the output tensor(e.g., [batch, 300, 6] where each row is [x1, y1, x2, y2, conf, class_id])
Postprocessing — any operations needed to extract the final detections from raw model output, for example, is the non-maximum suppression (NMS) built within the model, or it’s needed as a postprocessing step after the final layer of the model.
You can get these from a model card, or use any model visualization/inspection tool such as Netron, VisualDL, Zetane, or simply run onnx.load() and print the graph’s input/output shapes. Or skip all of that and feed the model file directly to the coding agent — it will inspect the model for you and will pull the right libs needed for model inspection.
Think of it this way: You bring a custom model to DeepStream’s hardware-optimized video analytics pipeline. You introduce the model — its input shape, output format — and DeepStream takes care of the rest; efficient buffer management that fully utilizes GPU decode, compute, and downstream processing to deliver the best latency your hardware can achieve.
The steps to generate a YOLOv26 detection app with the DeepStream coding agent are:
Step 1: Make sure you have the DeepStream Coding Agent skill installed and the minimum hardware for deployment. Install the DeepStream Coding Agent skill for Claude Code or Cursor. You can generate code anywhere, but deployment requires the minimum hardware, listed on GitHub.
Step 2: Paste this prompt into your agent:
Download the YOLO26s detection model using the ultralytics library, then convert the model to ONNX model that supports dynamic batch, in a Python virtual environment. Write a DeepStream custom parsing library for the model. Use DeepStream SDK pyservicemaker APIs to develop the python application that can do the following. - Read from file, decode the video and infer using the model. - The custom parsing library is used in nvinfer's configuration file. - Display the bounding box around detected objects using OSD. Save the generated code in yolo_detection directory. The app should support RTSP streams as input.
Step 3: The agent generates a complete application with multiple files — model download scripts, the pipeline app, inference config file, and more.
Let’s focus on the files that matter for model integration: the inference config file. Here’s exactly where the three things you need to know (input tensor, output tensor, and postprocessing) show up in the inference config file:
Input tensor: This tells DeepStream how to preprocess the upstream GPU buffer — resize to 640×640 and scale pixel values by 1/255 — and feed it to TensorRT. The ONNX file is automatically converted to a TensorRT engine on first run, optimized for your exact GPU and batch size.
The inference config will have:
infer-dims=3;640;640net-scale-factor=1/255onnx-file=yolo26s.onnx
Output tensor and Post-Processing: The agent generates an NvDsInferParseCustomYolo function that reads the output blob named example: output0 in yolo26s — a [300, 6] tensor where each row is [x1, y1, x2, y2, conf, class_id] — and converts each detection into an NvDsInferObjectDetectionInfo struct.
extern "C" bool NvDsInferParseCustomYolo( std::vector<NvDsInferLayerInfo> const &outputLayersInfo, ... std::vector<NvDsInferObjectDetectionInfo> &objectList) { ... const float *det = data + i * 6; obj.classId = static_cast<unsigned int>(det[5]); obj.detectionConfidence = det[4]; obj.left = det[0]; obj.top = det[1]; obj.width = det[2] - det[0]; obj.height = det[3] - det[1]; ... objectList.push_back(obj); }
This is what populates the ObjectMeta in the downstream NvDsBatchMeta. The inference config will have:
custom-lib-path=nvdsinfer_custom_impl_yolo/libnvdsinfer_custom_impl_yolo.soparse-bbox-func-name=NvDsInferParseCustomYolooutput-blob-names=output0
Step 4: To convert this into a production microservice — just like the VLM app example above (step 3) — use a similar prompt to add FastAPI endpoints for stream management, health probes, metrics, a Dockerfile, and deployment scripts
Step 5: Deploy with the generated scripts and access APIs via Swagger UI at http://localhost:8080/docs or curl.
These two applications are just the beginning. The same skills can generate any DeepStream pipeline — from multi-camera tracking to audio analytics to custom inference chains.
Check out more example prompts in the repository. Use these as a reference to write your own prompts for any vision AI application you can imagine:
Multi-stream tracking with 4 RTSP cameras and tiled display
Analytics — ROI filtering, line-crossing, overcrowding, and direction detection
Video file inference with bounding box display
Video inference with per-class object counting
YOLOv26s detection with custom ONNX export and parser
Multi-stream VLM video summarization with Kafka
FastAPI microservice wrapper with Dockerfile and deployment
Redefining vision AI development
DeepStream accelerates vision AI development with agentic workflows, reducing coding time to hours from weeks. Using natural language prompts, developers can instantly plug in models, configure camera streams, and deploy analytics applications. Optimized for NVIDIA hardware, DeepStream delivers more streams and analytics per dollar than generic pipelines, maximizing performance from edge to cloud.
Getting started
Download the latest SDK on NGC for Jetson, data center GPUs, or the cloud to get started with DeepStream.
Resources
Download DeepStream
Documentation
GTC 2026 lab on-demand
関連記事
NVIDIA、チップソフトウェアメーカーと提携しシミュレーションと現実のギャップを縮める
NVIDIAはCadenceとの提携を拡大し、ロボットトレーニングデータの精度向上とエンジニア向けAIサービスの構築を目指す。
NVIDIA、ロボットシミュレーション訓練を拡張するLyra 2.0を発表
NVIDIAの研究者が、単一写真から大規模で一貫性のある3D環境を生成するシステム「Lyra 2.0」を発表した。生成されたシーンはリアルタイムで探索可能で、ロボットシミュレーションに直接使用できる。
AI物理学でクリーンでモジュール式の原子炉設計を加速
NVIDIAは、安全でクリーンな原子炉開発のためにAI物理学を活用し、設計プロセスを加速する取り組みを進めている。