---
title: Nemotron-3.5-Transcribe
canonical_url: "https://www.modelscope.ai/studios/nv-community/Nemotron-3.5-Transcribe"
md_url: "https://www.modelscope.ai/studios/nv-community/Nemotron-3.5-Transcribe.md"
repository: nv-community/Nemotron-3.5-Transcribe
chinese_name: "Nemotron 3.5 Transcribe"
last_updated: 2026-10-28
sdk_type: docker
sdk_version: 6.29.1
downloads: 0
stars: 0
---

# Nemotron-3.5-Transcribe

> Nemotron-3.5-Transcribe - An interactive demo by nv-community on ModelScope. Private speech intelligence demo with cached Karaoke, podcast, movie and audio search samples. Live inference requires your own service endpoints and API keys.

nv-community/Nemotron-3.5-Transcribe is an interactive demo (Studio) on ModelScope. built with docker 6.29.1. also known as 「Nemotron 3.5 Transcribe」.

- **Repository**: nv-community/Nemotron-3.5-Transcribe
- **SDK**: docker
- **SDK version**: 6.29.1
- **Downloads**: 0
- **Stars**: 0
- **Last updated**: 2026-10-28

Source: https://www.modelscope.ai/studios/nv-community/Nemotron-3.5-Transcribe

---

# NVIDIA Nemotron Transcribe

Interactive speech intelligence demos backed by NVIDIA Nemotron 3.5 Transcribe on NVCF. Legacy Brev and custom backends remain available for rollback.

## Private deployment on ModelScope.ai

This private deployment targets the `nv-community` organization on ModelScope's international site, `modelscope.ai`, using the free CPU tier (2v16G: 2 vCPU, 16 GB RAM) for the web app only. Nemotron inference requires an external service. Without an endpoint or required API key, pages and restored cached demos remain available, while live inference routes return an explicit setup message. `/api/livez` checks only application liveness; `/api/health` checks transcription readiness. These are not interchangeable.

To enable live inference, configure the Studio's Settings. Native NIM uses `TRANSCRIBE_BACKEND=nim`, `NVCF_ENDPOINT`, `MODEL_NAME=nvidia-nemotron-3p5-transcribe`, and the secret `NVCF_API_KEY`, with `BREV_RELAY_ENABLED=false`; see [native Reprocess configuration](ops/reprocess-nvcf.md). Legacy custom-vLLM NVCF remains available as `TRANSCRIBE_BACKEND=nvcf`; it is not interchangeable with `nim`. Self-hosted compatible services use `custom`, `VLLM_URL`, and optional `VLLM_API_KEY`; Brev uses `brev`, `BREV_ENDPOINT`, and optional `BREV_API_KEY`. Supply base URLs without `/v1` or `/v1/chat/completions` and use the model identifier served by the backend. Karaoke and Podcast use native NIM when `TIMESTAMP_NIM_ENDPOINT` and `TIMESTAMP_NIM_MODEL` are configured, with `TIMESTAMP_NIM_API_KEY` or `NVCF_API_KEY`; see [timestamp configuration](ops/nvcf-timestamps.md). With no dedicated timestamp endpoint, a configured shared `nim` backend supplies native timestamps. Legacy shared providers instead require `mm_processor_kwargs.capture_ctc_timestamps=true` and `ctc_timestamps.words`. A generic text-only endpoint is not sufficient.

Multi-turn Ask Audio has separate settings: `ASK_AUDIO_ENDPOINT`, `ASK_AUDIO_API_KEY` (falling back to `NVCF_API_KEY`), and `ASK_AUDIO_MODEL`. YouTube import and karaoke separation additionally require `KARAOKE_YOUTUBE_ENDPOINT` and `KARAOKE_YOUTUBE_API_KEY`; `YOUTUBE_SPEECH_ENDPOINT` and `YOUTUBE_SPEECH_API_KEY` may be set separately or derived from the Karaoke configuration. All keys are left blank; no credentials from the original deployment are included, and third-party service URLs are not inferred automatically.

Redeploy after changing variables. See `.env.example` for the template with blank endpoints and keys; it is not loaded automatically. Enter real values only in platform settings, never in Git. The Brev relay is disabled by default: the original HF relay authentication cannot be reused directly in a private ModelScope Studio, so verify connectivity separately before enabling it. Automatic full-movie downloads are also disabled by default. Application data uses `/mnt/workspace/nemotron-transcribe`, with no assumption that NVIDIA's HF storage bucket is attached. Do not use a private Studio URL as a public media URL for external inference services.

This is a private deployment copy of the source demo and grants no additional rights to the code or media. Original attribution and content-rights confirmation remain in place; verify the relevant permissions before making it public. The upstream feature description is retained below; references to an HF bucket or the full media catalog do not mean that everything has been synchronized to this deployment.

## Upstream demo description

The karaoke workspace separates source recordings
with Demucs, sends the isolated vocal stems to Nemotron for CTC word
timestamps, and plays the time-aligned instrumentals while highlighting the
lyrics. The catalog includes Italian, French, German, English, Hebrew, Hindi / Urdu,
Spanish, Polish, Portuguese, and Farsi tracks. Karaoke is the default landing page.

The MP3 upload form is temporarily hidden from the Karaoke UI. Its existing
backend still accepts MP3 recordings up to 50 MB and 10 minutes long. Uploads
are separated on CPU, then transcribed without reference lyrics or wording
corrections. One upload is processed at a time; progress is streamed to the UI.
Uploaded recordings are not added to the shared catalog. Playback uses temporary,
unguessable media URLs, available until the server restarts or for up to 24 hours.
The Docker image includes Demucs and its model weights. For local development,
set `DEMUCS_PYTHON` to a Python executable with Demucs 4.0.1 and compatible
PyTorch/torchaudio installed; FFmpeg and FFprobe must be on PATH.

Karaoke also accepts a public YouTube song link up to 10 minutes long. The backend
calls the GPU service at `/v1/karaoke` and receives the original MP3, instrumental,
vocals, and a 16 kHz mono FLAC for transcription. Local Demucs is skipped for
YouTube songs. The bundle is checked for allowed filenames, sizes, hashes, audio
formats, full decoding, and matching timelines before Nemotron transcribes the
isolated vocals without wording corrections. The new song is selected in the
current session; it is not added to the shared catalog. Busy responses retain the
URL and enable a manual retry after the service's delay; requests are never retried
automatically. Only Karaoke uses this service.

The remote service uses HTTP/2 keepalives, a 960-second deadline, and bounded
ZIP downloads (100 MiB). Storage redirects never receive the service API key.
The UI displays the current stage and elapsed time while the GPU service works;
it does not invent separation percentages. GPU timings are recorded in server logs.

For the retained MP3 backend, vocal separation streams Demucs segment percentages to the UI. Two CPU workers
each use one math thread to avoid oversubscription in the CPU-limited Space.
A separator that makes no progress for three minutes is stopped with a retryable
message; the overall separation limit remains 20 minutes. Stage transitions and
separation milestones are logged with elapsed times for troubleshooting.

Podcasts retain Apple Podcasts episode URLs. Load an episode to preview its
name and details before starting transcription.

The movie workspace uses the first 30 minutes of each film. Each excerpt is
transcribed and aligned in one pass to keep word timestamps and speaker IDs in
one diarization timeline. Export SRT downloads all subtitle cues for the selected
excerpt, regardless of transcript search or speaker filters.

The Docker application serves on port `7860`. The upstream HF Space mounts runtime media and demo data from its attached bucket at `/data`; this Studio instead uses `/mnt/workspace/nemotron-transcribe` through `start.sh`, without that bucket.

## Runtime configuration

The upstream HF configuration below is reference only. For this private ModelScope.ai Studio, use the deployment instructions above: inference requires an explicitly configured endpoint, and the Brev relay is disabled by default.

### Select the transcription backend

Karaoke and Podcast use the timestamp-capable native NIM on NVCF when
`TIMESTAMP_NIM_ENDPOINT` is set. See [configuration and ModelScope deployment](ops/nvcf-timestamps.md).
Ask Audio has its own `ASK_AUDIO_ENDPOINT`. Movie subtitles are pre-generated.

`TRANSCRIBE_BACKEND` selects the Reprocess/shared backend, and is the fallback
for Karaoke and Podcast when `TIMESTAMP_NIM_ENDPOINT` is absent. There is no
automatic failover or inference retry between providers.

| `TRANSCRIBE_BACKEND` | Endpoint variable | Credential secret |
| --- | --- | --- |
| `nim` | `NVCF_ENDPOINT` | `NVCF_API_KEY` (native NIM contract) |
| `brev` | `BREV_ENDPOINT` | Optional `BREV_API_KEY`; omit only if your service allows unauthenticated requests |
| `nvcf` | `NVCF_ENDPOINT` | `NVCF_API_KEY` (legacy fallback: `VLLM_API_KEY`) |
| `custom` | `VLLM_URL` | Optional `VLLM_API_KEY` |
| `auto` (default) | `VLLM_URL`, then `NVCF_ENDPOINT`; upstream core falls back to localhost:8000, but this Studio disables inference when both are blank | Determined by endpoint hostname |

For the current native NIM service:

```text
TRANSCRIBE_BACKEND=nim
NVCF_ENDPOINT=https://d9c47484-ee3b-400f-92d2-a4272bd97131.invocation.api.nvcf.nvidia.com
MODEL_NAME=nvidia-nemotron-3p5-transcribe
BREV_RELAY_ENABLED=false
```

See [Reprocess integration, one-recording contract, and rollback](ops/reprocess-nvcf.md).
With this configuration the app connects directly to NVCF and the Brev relay is disabled.
`nim` and legacy `nvcf` use different request formats and are not interchangeable.
`/api/health` checks the selected backend. Endpoint values are base URLs without
`/v1` or `/v1/chat/completions`. Credentials remain in platform settings, not Git.
Historical [relay operations](ops/brev-relay.md) remain available for rollback;
verify ModelScope.ai connectivity and authentication separately before enabling the relay.

The YouTube download and GPU separation service remains independently configured
by `KARAOKE_YOUTUBE_ENDPOINT`. Switching transcription does not recover that
service if its NVCF deployment is unavailable. Existing catalog audio and cached
timelines remain usable.

Secrets:

- `NVCF_API_KEY`
- `BREV_RELAY_TOKEN`: required when the outbound relay is enabled.
- `BREV_API_KEY` (optional)
- `VLLM_API_KEY` (optional, for custom endpoints)
- `KARAOKE_YOUTUBE_API_KEY`: credential authorized to invoke the YouTube audio function.

Variables:

- `TRANSCRIBE_BACKEND`: `nim`, `brev`, legacy `nvcf`, `custom`, or backwards-compatible `auto`.
- `BREV_ENDPOINT`
- `BREV_RELAY_ENABLED`: `true` starts the relay; default disabled.
- `BREV_RELAY_PORT`: loopback HTTP port, default `18000`.
- `KARAOKE_YOUTUBE_ENDPOINT`: full GPU karaoke bundle endpoint; upstream example: `https://cdaf93aa-c0eb-459c-b092-b8b4a604bd38.invocation.api.nvcf.nvidia.com/v1/karaoke`. Left blank in this Studio.
- `NVCF_ENDPOINT`
- `VLLM_URL`
- `MODEL_NAME`
- `MAX_TOKENS`
- `MAX_AUDIO_ITEMS`
- `VLLM_MAX_AUDIO_DECODE_DURATION_S`
- `PODCAST_AUDIO_TRANSPORT`: `auto` (default), `url`, `staged`, or `inline`. With public media storage configured, `auto` stages a capped FLAC and sends its URL to NVCF. Otherwise it tries the publisher URL for known episodes up to one hour and retains inline FLAC as a compatibility fallback.
- `PODCAST_PUBLIC_MEDIA_DIR` and `PODCAST_PUBLIC_MEDIA_BASE_URL`: writable local mount plus its public HTTPS prefix for temporary NVCF media delivery.
- `KARAOKE_CACHE_DIR`: persistent cache for generated word-level karaoke timelines; upstream default `/data/cache/karaoke`, this Studio's default `/mnt/workspace/nemotron-transcribe/cache/karaoke`.
- `YOUTUBE_CACHE_DIR`: shared persistent YouTube audio cache; upstream default `/data/cache/youtube` on the attached bucket, this Studio's default `/mnt/workspace/nemotron-transcribe/cache/youtube`.

## YouTube in Ask Audio and Reprocess

Both tabs import YouTube audio through the dedicated service's `/v1/speech`
route. Videos longer than 55 minutes are clipped to the first 55 minutes; the
UI explicitly reports truncation. Karaoke keeps its separate ten-minute limit
and GPU separation flow. Speech imports use 16 kHz mono FLAC and do not run
separation. The download service allows one request at a time across routes;
users receive a busy message and retry manually.

Validated YouTube audio is cached for seven days (in the upstream shared bucket,
or this Studio's `YOUTUBE_CACHE_DIR`), with background retention cleanup targeting
at most 128 prepared variants and 10 GiB. The cache groups entries by canonical video ID: Ask Audio and Reprocess
share one speech FLAC; Karaoke stores a separate set of original audio, music,
vocals, and transcription FLAC. Short/watch links and playlist parameters resolve
to the same video. The 55-minute speech and ten-minute Karaoke limits remain
separate. Cached imports skip the YouTube service and, for Karaoke, Demucs;
transcription and word alignment still run live. Response `audioCached` reports
audio reuse independently of the existing timeline `cached` field.

The UI requests `audioTransport: "reference"` when importing speech audio. It
receives a small, opaque attachment reference and a same-origin playback URL,
instead of downloading base64 audio and uploading it again on Send. `/api/chat`
resolves the reference on the server before sending audio to the selected model.
Playback supports byte ranges and the audio download button remains available.
Session references last up to 24 hours, are bounded to 32 attachments/2 GiB, and
expire on a Space restart; reimporting then restores audio from the persistent
cache. API clients that omit `audioTransport` retain the original base64 response.

The upstream bucket survives Space restarts and rebuilds; this Studio instead
relies on ModelScope's `/mnt/workspace` storage lifecycle. Preload demo links by importing
each once in Ask Audio or Reprocess and once in Karaoke when it is within the
song limit. Repeating an import should return `audioCached: true`. Hashes and
sizes are verified when copying cached files; missing, expired, or corrupt
entries are downloaded and validated again. A cache-storage failure does not
discard a successful import. Duplicate in-flight requests for the same video
and profile receive 429 with a retry delay; they are not queued. To invalidate a
video, remove its directory under `<YOUTUBE_CACHE_DIR>/<video-id>` while no
request is using it (`/data/cache/youtube` upstream; `/mnt/workspace/nemotron-transcribe/cache/youtube` in this Studio).
This cache belongs to the demo; direct NVCF consumers still call the uncached download service.

- `YOUTUBE_SPEECH_ENDPOINT`: optional full `/v1/speech` URL. By default, derived
  from `KARAOKE_YOUTUBE_ENDPOINT` by replacing its `/v1/karaoke` suffix.
- `YOUTUBE_SPEECH_API_KEY`: optional secret; defaults to the Karaoke service key.
- `/api/youtube-stream`: UI import route with SSE keepalives during preparation.
- `/api/youtube`: equivalent JSON response for existing clients.

The adapter validates bundle members, source identity, duration, format, and
fully decoded sample count before returning audio. NVCF storage redirects are
handled without forwarding the service key. Browser attachments retain FLAC
format when submitted to the existing chat handler. No transcription endpoint
or model wording changes are required. Long inputs still share the model's
context/output budget; dense speech or large outputs may require shorter clips.
Deploy service 0.4.0 or newer before publishing this UI change.

## Demo load protection

The Space queues and limits live processing in the application container. Cached
examples stay available. See [limits and API admission protocol](ops/demo-load-protection.md).
Direct consumers of processing routes must obtain an admission ticket first.