Agent: this file is the complete Stage 1 procedure. Do not invoke

find

,

ls

,

rg

, or

grep

looking for an installer or hidden config — there isn't one. The four sections below (outbound-data disclosure, three numbered checks, sibling hand-off) are all required reading; don't skip any. Function IDs, env-var conventions, and the smoke-test gate are inlined further down — answer from what's actually written here rather than from prior Riva/NVCF familiarity.

NVIDIA_API_KEY

/digital-health-clinical-asr-build

install.sh

setup.py

/data-designer

/riva-tts

/riva-asr-custom

grpc.nvcf.nvidia.com

dictionaryapi.com

merriam-webster.com

• Skip Merriam-Webster entirely: leave

  DICTIONARY_API_KEY

  unset and don't run a scraper. Stage 2 falls back to Magpie G2P, which still works but with weaker coverage on long-tail clinical terms.
• Skip NVCF: this is a hard stop. Magpie TTS + Parakeet/Nemotron ASR are the workload; without them this skill family is the wrong tool — a self-hosted ASR/TTS pipeline is what you want instead.

README.md

• "Set up the Clinical ASR Flywheel"
• "Initialize the clinical-asr eval"
• "I want to evaluate ASR on clinical terminology — where do I start?"
• "Bootstrap my environment for the flywheel"
• "What do I need installed before I run the flywheel?"

• The user already has a manifest and wants to score it →

  /digital-health-clinical-asr-eval

• The user already has the env set up and wants to curate terms →

  /digital-health-clinical-asr-build

• The user is asking about Stage 4 fine-tune NGC/Docker setup specifically → that's covered inside

  /digital-health-clinical-asr-finetune

NVIDIA_API_KEY

• The agent harness reads

  $NVIDIA_API_KEY

  from the shell and passes it as an explicit function argument to

  smoke_test(api_key=…)

  .
• Auditors can grep the recipe for every wire crossing — every

  api_key

  use is visible in

  auth_for(...)

  .
• Do not

  echo

  ,

  print

  , or log the key value (including truncated). Length-only checks are fine (see §1a).
• Do not let the recipe read

  os.environ["NVIDIA_API_KEY"]

  itself — the explicit-argument pattern is the auditability guarantee.
• Do not commit the key to any file, including

  .env

  examples or notebook outputs.

NVIDIA_API_KEY

NVIDIA_API_KEY

import wave, tempfile
import riva.client

NVCF_HOST = "grpc.nvcf.nvidia.com:443"
MAGPIE_FUNCTION_ID    = "877104f7-e885-42b9-8de8-f6e4c6303969"   # Magpie TTS
PARAKEET_FUNCTION_ID  = "d3fe9151-442b-4204-a70d-5fcc597fd610"   # Parakeet TDT 0.6B v2 (offline ASR)

def auth_for(function_id: str, api_key: str) -> riva.client.Auth:
    return riva.client.Auth(
        use_ssl=True, uri=NVCF_HOST,
        metadata_args=[
            ["function-id", function_id],
            ["authorization", f"Bearer {api_key}"],
        ],
    )

def smoke_test(api_key: str) -> str:
    """Caller passes api_key (the harness reads $NVIDIA_API_KEY at the shell;
    this code never touches the environment). Returns the ASR transcript."""

    # 1. TTS: "The patient was prescribed cefazolin."
    tts = riva.client.SpeechSynthesisService(auth_for(MAGPIE_FUNCTION_ID, api_key))
    pcm = b"".join(c.audio for c in tts.synthesize_online(
        text="The patient was prescribed cefazolin.",
        voice_name="Magpie-Multilingual.EN-US.Mia",
        language_code="en-US", sample_rate_hz=16000,
    ))
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        with wave.open(f, "wb") as w:
            w.setnchannels(1); w.setsampwidth(2); w.setframerate(16000); w.writeframes(pcm)
        wav_path = f.name

    # 2. ASR: transcribe the WAV we just synthesized.
    asr = riva.client.ASRService(auth_for(PARAKEET_FUNCTION_ID, api_key))
    with open(wav_path, "rb") as f:
        audio_bytes = f.read()
    config = riva.client.RecognitionConfig(
        encoding=riva.client.AudioEncoding.LINEAR_PCM,
        sample_rate_hertz=16000, language_code="en-US",
        max_alternatives=1, enable_automatic_punctuation=True,
    )
    response = asr.offline_recognize(audio_bytes, config)
    transcript = response.results[0].alternatives[0].transcript if response.results else ""
    print(f"TTS:  The patient was prescribed cefazolin.")
    print(f"ASR:  {transcript}")
    return transcript

merriam-webster

• Path A — JSON API + key. Recommended for standalone use of this skill. Check the key is set:
  bash

  test -n "$DICTIONARY_API_KEY" && echo "DICTIONARY_API_KEY len=${#DICTIONARY_API_KEY}" \
    || echo "DICTIONARY_API_KEY not set — Path A is off"

  Free key issues instantly at https://dictionaryapi.com.
• Path B — HTML scraping. No API key needed; reachability is the only prerequisite. Brittle to MW site HTML changes; recipe inlined in the build skill's

  references/pronunciation-pipeline.md

  .
  bash

  curl -fsS -o /dev/null -w "merriam-webster.com reachable, HTTP %{http_code}\n" \
    https://www.merriam-webster.com/medical/cefazolin

  If you don't want to maintain a scraper, use Path A instead.

• NVIDIA_API_KEY

  exported in the user's shell
• An activated virtualenv with

  nvidia-riva-client

  ,

  pandas

  ,

  soundfile

  ,

  requests

• A confirmed TTS→ASR round-trip on a clinical sentence (proof the hosted stack works)

• Length check shows nothing or

  len=0

  →

  NVIDIA_API_KEY

  isn't exported in this shell. Run

  export NVIDIA_API_KEY=nvapi-...

  and re-check.
• Variable is set in one shell but not another → exports don't persist across sessions. Add the

  export

  line to your shell rc (

  ~/.bashrc

  ,

  ~/.zshrc

  ), or use a per-directory loader like

  direnv

  .

• 401 Unauthorized

  on the smoke test → key value is wrong or expired. Re-issue at https://build.nvidia.com.

• grpc.RpcError: function not found

  → the inlined function IDs need updating against the current NVCF catalog. Check https://build.nvidia.com and edit the constants in 1c. The eval skill (

  /digital-health-clinical-asr-eval

  ) provides a catalog of current function IDs in its Step 3a "Other catalog options" list.

• StatusCode.INVALID_ARGUMENT

  with

  CUDA error: an illegal memory access was encountered

  → NVCF-side backend fault on this specific function ID (Triton/PyTorch on NVCF, not your env). Either retry later or temporarily point at a different offline ASR NIM — Whisper Large v3 function-id

  b702f636-f60c-4a3d-a6f4-f3568c13bd7d

  is the closest drop-in (also offline; pass

  language_code="en"

  instead of

  "en-US"

  ). For routine eval cycles, prefer to wait for the Parakeet backend to recover so Stage 3 baseline and Stage 4 SFT base stay aligned.

• TypeError: Auth.__init__() got an unexpected keyword argument 'ssl_cert'

  → you're on

  nvidia-riva-client >= 2.x

  where the kwarg was renamed to

  ssl_root_cert

  (and is no longer needed for hosted NVCF). Drop the

  ssl_cert=None,

  line from your local copy of the recipe.

• ModuleNotFoundError: riva.client

  → step 1b was skipped or the venv isn't activated.

  source .venv/bin/activate && pip install nvidia-riva-client

  .

• Scope is environment readiness only. Whether the user's term list or pronunciation overrides make sense is decided in

  /digital-health-clinical-asr-build

  , not here.
• Magpie en-US assumption. Downstream IPA validation rides on Magpie's English phoneme inventory; other locales require a different phoneme set entirely.
• Hosted NVCF is the assumed deployment. Running self-hosted Riva NIMs is possible but the setup for that lives inside

  /digital-health-clinical-asr-finetune

  Stage 4d.
• Synthetic data only. This skill family is built for benchmarks generated from a curated term list. Real patient transcripts and recorded audio must not flow through any stage.

/digital-health-clinical-asr-build

• Default forward route:

  /digital-health-clinical-asr-build

  — specialty interview, term curation, IPA tagging, NeMo manifest synthesis.
• Direct jump to Stage 3 (only when the user is bringing their own NeMo-format manifest with

  term

  /

  entity_category

  /

  ipa_source

  fields):

  /digital-health-clinical-asr-eval

  .

• references/dependency-ownership.md

  — boundary between skill-owned and companion-owned responsibilities.