{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-nvidia-nemo--nemo","slug":"nvidia-nemo--nemo","name":"NeMo","type":"framework","url":"https://docs.nvidia.com/nemo/speech/nightly/index.html","page_url":"https://unfragile.ai/nvidia-nemo--nemo","categories":["frameworks-sdks"],"tags":["asr","deeplearning","generative-ai","machine-translation","neural-networks","speaker-diariazation","speaker-recognition","speech-synthesis","speech-translation","tts"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-nvidia-nemo--nemo__cap_0","uri":"capability://automation.workflow.pytorch.lightning.based.distributed.model.training.with.automatic.parallelism","name":"pytorch lightning-based distributed model training with automatic parallelism","description":"NeMo abstracts distributed training through PyTorch Lightning's Trainer API, automatically handling data parallelism, tensor parallelism, and pipeline parallelism across multi-GPU and multi-node clusters. The framework manages distributed state through a custom Application State system that coordinates optimizer steps, gradient accumulation, and checkpoint synchronization across ranks without requiring manual distributed communication code.","intents":["Train large language models across multiple GPUs without writing distributed communication code","Scale ASR or TTS models from single-GPU prototypes to multi-node production training","Automatically switch between data parallelism and tensor parallelism based on model size"],"best_for":["ML researchers training models on NVIDIA GPU clusters","Teams building production speech AI systems requiring multi-node scaling","Developers migrating from manual DistributedDataParallel to managed parallelism"],"limitations":["Requires PyTorch Lightning 1.5+ and NVIDIA APEX for mixed precision","Tensor parallelism requires careful model architecture design to avoid communication bottlenecks","Distributed checkpointing adds ~5-10% training overhead for synchronization across ranks"],"requires":["Python 3.9+","PyTorch 1.13+","NVIDIA CUDA 11.8+ for multi-GPU training","PyTorch Lightning 1.5+","NVIDIA Apex for automatic mixed precision"],"input_types":["PyTorch model (nn.Module subclass)","Training configuration (YAML or OmegaConf)","Dataset (DataLoader or Lhotse-compatible format)"],"output_types":["Trained model checkpoint (.nemo artifact)","Distributed training logs and metrics","Tensorboard event files"],"categories":["automation-workflow","distributed-training"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_1","uri":"capability://code.generation.editing.neural.types.system.for.compile.time.tensor.shape.and.dtype.validation","name":"neural types system for compile-time tensor shape and dtype validation","description":"NeMo implements a custom Neural Types system that annotates module inputs/outputs with semantic type information (e.g., 'audio_signal', 'logits', 'embeddings') and validates tensor shapes, dtypes, and semantic compatibility at module connection time. This catches shape mismatches and type errors before training begins, preventing silent failures from incompatible layer connections.","intents":["Catch tensor shape mismatches between model layers at initialization time rather than runtime","Validate that audio preprocessing outputs match ASR encoder input expectations","Ensure TTS decoder outputs are compatible with downstream vocoder inputs"],"best_for":["Researchers building complex multi-module architectures (ASR + language model stacks)","Teams debugging shape mismatches in custom model implementations","Developers creating reusable NeMo-compatible model components"],"limitations":["Type annotations are optional; models without them bypass validation","Runtime shape changes (e.g., variable sequence lengths) are not validated","Custom Neural Types require manual definition and registration"],"requires":["Python 3.9+","NeMo core module","Understanding of NeMo's Neural Types API"],"input_types":["Module class definitions with Neural Types annotations","Tensor metadata (shape, dtype, semantic type)"],"output_types":["Validation errors at module initialization","Type compatibility reports"],"categories":["code-generation-editing","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_10","uri":"capability://code.generation.editing.natural.language.processing.nlp.model.training.for.token.classification.and.machine.translation","name":"natural language processing (nlp) model training for token classification and machine translation","description":"NeMo provides NLP training pipelines supporting token classification (NER, POS tagging), machine translation, question answering, and text classification through transformer-based architectures. The NLP module integrates with HuggingFace tokenizers, supports multi-lingual training, and includes task-specific loss functions and evaluation metrics.","intents":["Train a named entity recognition (NER) model on domain-specific text without implementing tokenization and loss functions","Fine-tune a pre-trained machine translation model on new language pairs","Evaluate NLP models with standard metrics (F1, BLEU, ROUGE) and export to inference formats"],"best_for":["NLP teams building custom models for specific languages or domains","Researchers experimenting with transformer architectures for NLP tasks","Developers deploying NLP models to production with NVIDIA inference servers"],"limitations":["NLP training requires large labeled text datasets (10K+ examples); small datasets lead to poor generalization","Multi-lingual training requires balanced representation across languages; imbalanced data causes language confusion","Tokenizer selection significantly impacts model performance; custom tokenizers require careful tuning"],"requires":["Python 3.9+","NeMo NLP module","Text dataset in supported format (JSON, CSV, plain text)","NVIDIA GPU with 8GB+ VRAM for training","HuggingFace tokenizer or custom tokenizer"],"input_types":["Text files (JSON, CSV, plain text)","Manifest files (JSON lines with text and labels)","Pre-trained NLP checkpoint (.nemo)"],"output_types":["Trained NLP model (.nemo artifact)","Task-specific metrics (F1, BLEU, ROUGE)","Exported model for inference (ONNX, TorchScript)"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_11","uri":"capability://code.generation.editing.speech.language.model.slm.training.with.audio.text.alignment","name":"speech language model (slm) training with audio-text alignment","description":"NeMo provides training pipelines for speech language models that process raw audio and text jointly, supporting architectures like Canary (multilingual speech-to-text and speech-to-speech translation). The SLM module handles audio-text alignment, multi-task training (ASR, translation, speech-to-speech), and supports both supervised and self-supervised pre-training.","intents":["Train a multilingual speech-to-text model that handles ASR and translation in a single model","Fine-tune a pre-trained speech language model on domain-specific audio-text pairs","Build speech-to-speech translation systems without separate ASR and TTS components"],"best_for":["Speech AI teams building multilingual speech understanding systems","Researchers experimenting with joint audio-text modeling","Developers deploying end-to-end speech translation systems"],"limitations":["SLM training requires large aligned audio-text datasets (1000+ hours); small datasets lead to poor alignment","Multi-task training (ASR + translation) requires careful loss weighting; poor weighting causes task interference","Audio-text alignment is computationally expensive; training requires 40GB+ GPU memory"],"requires":["Python 3.9+","NeMo SLM module","Aligned audio-text dataset (1000+ hours)","NVIDIA GPU with 40GB+ VRAM for training","Pre-trained ASR or speech encoder for initialization"],"input_types":["Audio files (WAV, FLAC)","Text transcriptions and translations","Manifest files with audio-text alignment","Pre-trained speech encoder checkpoint"],"output_types":["Trained SLM model (.nemo artifact)","Multi-task evaluation metrics (WER, BLEU)","Exported model for inference"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_12","uri":"capability://data.processing.analysis.model.card.generation.and.metadata.management.for.reproducibility","name":"model card generation and metadata management for reproducibility","description":"NeMo automatically generates model cards (YAML/JSON) containing training configuration, performance metrics, dataset information, and usage guidelines. The model card system integrates with the .nemo artifact format, enabling automatic documentation generation and integration with model hubs (Hugging Face, NVIDIA NGC).","intents":["Automatically generate model documentation from training configuration and metrics","Share models with complete metadata (training data, hyperparameters, performance) for reproducibility","Publish models to Hugging Face Model Hub with complete documentation"],"best_for":["Researchers publishing models with reproducible training information","Teams sharing models internally with complete documentation","Developers integrating models with model hubs and registries"],"limitations":["Model cards are generated from training config; manual updates required for post-training analysis","Metadata completeness depends on training script implementation; incomplete configs lead to incomplete cards","Model hub integration requires manual upload; no automatic publishing"],"requires":["Python 3.9+","NeMo core module","Training configuration (YAML)","Evaluation metrics (optional)"],"input_types":["Training configuration (OmegaConf DictConfig)","Evaluation metrics (dict)","Model metadata (name, description, license)"],"output_types":["Model card (YAML or JSON)","Markdown documentation","Metadata embedded in .nemo artifact"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_2","uri":"capability://automation.workflow.omegaconf.based.hierarchical.configuration.management.with.experiment.tracking","name":"omegaconf-based hierarchical configuration management with experiment tracking","description":"NeMo uses OmegaConf for declarative model and training configuration, supporting nested YAML files, environment variable interpolation, and dynamic config composition. The ExperimentManager integrates with this config system to automatically log hyperparameters, create experiment directories, and manage checkpoints, enabling reproducible training runs with minimal code.","intents":["Define model architecture and training hyperparameters in YAML without hardcoding in Python","Reproduce training runs by version-controlling config files","Automatically organize experiment outputs (logs, checkpoints, tensorboard) by run ID"],"best_for":["ML teams running hyperparameter sweeps across multiple configs","Researchers publishing models with reproducible config files","Developers managing complex multi-stage training pipelines (pretraining → fine-tuning)"],"limitations":["OmegaConf validation is schema-optional; typos in config keys may not be caught until runtime","Large config hierarchies can be difficult to debug due to nested interpolation","ExperimentManager creates local directories; requires external tools for cloud storage integration"],"requires":["Python 3.9+","OmegaConf 2.1+","NeMo core module"],"input_types":["YAML configuration files","Python dict or OmegaConf DictConfig objects","Environment variables for interpolation"],"output_types":["Resolved OmegaConf DictConfig","Experiment directory structure with logs and checkpoints","Tensorboard event files"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_3","uri":"capability://data.processing.analysis.unified.nemo.artifact.format.for.model.serialization.with.metadata.and.tokenizers","name":"unified .nemo artifact format for model serialization with metadata and tokenizers","description":"NeMo packages trained models as .nemo files (TAR archives) containing model weights, config, tokenizers, and metadata via a SaveRestoreConnector abstraction. This enables single-file model distribution with all dependencies, supporting both local and cloud storage backends (S3, GCS) and automatic model card generation for reproducibility.","intents":["Package a trained ASR model with its tokenizer and config into a single distributable file","Load pre-trained NeMo models from Hugging Face Model Hub or local paths without manual dependency management","Share models with metadata (training config, performance metrics) for reproducibility"],"best_for":["Researchers publishing models to model hubs","Teams deploying models to production inference servers","Developers fine-tuning pre-trained NeMo models"],"limitations":[".nemo files can be large (1-50GB for LLMs); requires sufficient disk space for download and extraction","Tokenizer serialization is format-specific; custom tokenizers require custom serialization code","Cloud storage integration requires explicit credential configuration"],"requires":["Python 3.9+","NeMo core module","Sufficient disk space for model artifacts","Optional: S3/GCS credentials for cloud storage"],"input_types":["Trained PyTorch model (nn.Module)","OmegaConf configuration","Tokenizer object","Metadata dict"],"output_types":[".nemo artifact file (TAR archive)","Model card (YAML or JSON)","Extracted model weights and config"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_4","uri":"capability://code.generation.editing.automatic.speech.recognition.asr.model.training.with.multi.architecture.support","name":"automatic speech recognition (asr) model training with multi-architecture support","description":"NeMo provides end-to-end ASR training pipelines supporting Conformer, Squeezeformer, and Citrinet architectures with integrated data augmentation (SpecAugment, time-stretching), language model integration, and CTC/RNN-T decoding. The ASR module handles audio preprocessing (MFCC, mel-spectrogram), feature normalization, and multi-lingual training through a modular encoder-decoder design.","intents":["Train a production-quality ASR model from raw audio datasets without implementing audio processing pipelines","Fine-tune pre-trained ASR models on domain-specific data (medical, legal, accented speech)","Evaluate ASR models with standard metrics (WER, CER) and export to inference formats"],"best_for":["Speech AI teams building custom ASR systems for specific languages or domains","Researchers experimenting with ASR architectures and training techniques","Developers deploying ASR to production with NVIDIA inference servers"],"limitations":["ASR training requires large labeled audio datasets (100+ hours); small datasets lead to poor generalization","Language model integration requires pre-trained LM artifacts; custom LMs need external training","RNN-T decoding is slower than CTC for real-time inference due to autoregressive decoding"],"requires":["Python 3.9+","NeMo ASR module","Audio dataset in supported format (WAV, FLAC, MP3)","NVIDIA GPU with 16GB+ VRAM for training","Optional: Pre-trained language model for shallow fusion"],"input_types":["Audio files (WAV, FLAC, MP3)","Manifest files (JSON lines with audio paths and transcriptions)","Pre-trained ASR checkpoint (.nemo)"],"output_types":["Trained ASR model (.nemo artifact)","WER/CER metrics on validation set","Exported model for inference (ONNX, TorchScript)"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_5","uri":"capability://code.generation.editing.text.to.speech.tts.model.training.with.vocoder.integration","name":"text-to-speech (tts) model training with vocoder integration","description":"NeMo provides TTS training pipelines supporting Glow-TTS, FastPitch, and Tacotron2 acoustic models paired with neural vocoders (HiFi-GAN, UnivNet). The TTS module handles text preprocessing, phoneme alignment, mel-spectrogram generation, and multi-speaker training through a modular acoustic-model + vocoder architecture with automatic data augmentation.","intents":["Train a multi-speaker TTS system from audio and text transcriptions without implementing mel-spectrogram generation","Fine-tune pre-trained acoustic models on new speakers or languages","Generate high-quality speech from text with controllable prosody and speaker identity"],"best_for":["Speech synthesis teams building custom TTS systems for specific languages or voices","Researchers experimenting with acoustic models and vocoder architectures","Developers deploying TTS to production with real-time latency requirements"],"limitations":["TTS quality depends heavily on audio preprocessing and phoneme alignment; poor data leads to artifacts","Multi-speaker training requires balanced speaker representation; imbalanced data causes speaker confusion","Vocoder inference is computationally expensive; real-time synthesis requires GPU acceleration"],"requires":["Python 3.9+","NeMo TTS module","Audio dataset with text transcriptions (100+ hours for good quality)","NVIDIA GPU with 16GB+ VRAM for training","Text-to-phoneme converter (g2p_en, gruut, or custom)"],"input_types":["Audio files (WAV, FLAC)","Manifest files (JSON lines with audio paths and text)","Pre-trained acoustic model or vocoder (.nemo)"],"output_types":["Trained TTS model (.nemo artifact)","Generated speech audio (WAV)","Mel-spectrogram visualizations","Exported model for inference (ONNX, TorchScript)"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_6","uri":"capability://data.processing.analysis.lhotse.based.audio.data.pipeline.with.manifest.driven.training","name":"lhotse-based audio data pipeline with manifest-driven training","description":"NeMo integrates Lhotse for declarative audio data loading, supporting manifest files (JSON lines) that specify audio paths, transcriptions, speaker IDs, and metadata. The data pipeline handles on-the-fly audio loading, resampling, augmentation, and batching through a composable DataLoader abstraction, enabling efficient training on large datasets without pre-processing.","intents":["Load audio datasets from manifest files without writing custom data loaders","Apply audio augmentation (noise, pitch shift, time-stretch) during training without pre-processing","Efficiently batch variable-length audio sequences with automatic padding"],"best_for":["Speech AI teams managing large audio datasets across multiple storage backends","Researchers experimenting with data augmentation strategies","Developers training models on streaming or distributed datasets"],"limitations":["Manifest files must be manually created or generated from dataset metadata; no automatic discovery","On-the-fly augmentation adds ~10-20% training overhead compared to pre-processed data","Variable-length batching requires careful padding strategy to avoid excessive memory usage"],"requires":["Python 3.9+","NeMo data module","Lhotse 1.0+","Audio files in supported format (WAV, FLAC, MP3)","Manifest files (JSON lines format)"],"input_types":["Manifest files (JSON lines with audio metadata)","Audio files (WAV, FLAC, MP3)","Augmentation configuration (YAML)"],"output_types":["Batched audio tensors","Metadata tensors (speaker IDs, transcriptions)","Augmented audio samples"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_7","uri":"capability://code.generation.editing.adapter.based.parameter.efficient.fine.tuning.for.llms.and.speech.models","name":"adapter-based parameter-efficient fine-tuning for llms and speech models","description":"NeMo implements adapter modules (LoRA, prefix-tuning, adapter layers) that enable fine-tuning large pre-trained models with <5% of original parameters. Adapters are inserted into model layers via a declarative configuration system and can be trained separately from frozen base weights, enabling efficient multi-task fine-tuning and model composition.","intents":["Fine-tune a 7B parameter LLM on domain-specific data using only 300M trainable parameters","Train multiple task-specific adapters on the same base model for multi-task inference","Reduce fine-tuning memory requirements from 40GB to 8GB for large models"],"best_for":["Teams fine-tuning large pre-trained models with limited GPU memory","Researchers building multi-task models with shared base weights","Developers deploying multiple task-specific models with minimal storage overhead"],"limitations":["Adapter fine-tuning is slower than full fine-tuning due to additional forward/backward passes through adapter layers","Adapter composition (combining multiple adapters) can degrade performance if adapters conflict","Adapter weights are not compatible across different base model architectures"],"requires":["Python 3.9+","NeMo core module with adapter support","Pre-trained base model (.nemo artifact)","Adapter configuration (YAML)"],"input_types":["Pre-trained model checkpoint","Adapter configuration (adapter type, insertion points, rank)","Fine-tuning dataset"],"output_types":["Trained adapter weights (.nemo artifact)","Fine-tuned model with adapters merged (optional)","Adapter composition configuration"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_8","uri":"capability://automation.workflow.distributed.checkpointing.with.rank.aware.state.management","name":"distributed checkpointing with rank-aware state management","description":"NeMo's SaveRestoreConnector implements distributed checkpointing that handles rank-aware state serialization across multi-GPU training, supporting both sharded and replicated state patterns. Checkpoints can be saved asynchronously without blocking training, and the system automatically handles optimizer state, model weights, and training metadata across distributed ranks.","intents":["Save model checkpoints during distributed training without synchronization overhead","Resume training from checkpoints with automatic rank-aware state restoration","Convert between sharded checkpoints (for distributed training) and consolidated checkpoints (for inference)"],"best_for":["Teams training large models on multi-node clusters requiring frequent checkpointing","Researchers implementing custom distributed training loops with checkpoint management","Developers deploying models trained with tensor parallelism to single-GPU inference"],"limitations":["Distributed checkpointing adds ~5-10% training overhead for synchronization","Sharded checkpoints cannot be loaded on different numbers of GPUs without resharding","Asynchronous checkpointing requires careful handling of training state to avoid stale checkpoints"],"requires":["Python 3.9+","NeMo core module","PyTorch Lightning Trainer with distributed backend","Sufficient disk space for checkpoint storage"],"input_types":["Distributed model state (weights, optimizer state)","Training metadata (step, epoch, metrics)","Checkpoint configuration (save frequency, format)"],"output_types":["Distributed checkpoint files (sharded or consolidated)","Checkpoint metadata (training step, model config)","Restored model and optimizer state"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia-nemo--nemo__cap_9","uri":"capability://automation.workflow.learning.rate.scheduling.with.warmup.and.decay.strategies","name":"learning rate scheduling with warmup and decay strategies","description":"NeMo provides a comprehensive learning rate scheduler system supporting warmup (linear, exponential), decay (cosine, polynomial, exponential), and composite schedules through a declarative configuration interface. Schedulers integrate with distributed optimizers and support per-parameter-group scheduling for fine-grained control over learning rates across model components.","intents":["Apply learning rate warmup and cosine annealing decay without manual scheduler implementation","Use different learning rates for different model components (encoder vs. decoder, base vs. adapter)","Reproduce training runs with exact learning rate schedules via configuration files"],"best_for":["ML teams tuning learning rate schedules for stable training","Researchers experimenting with warmup and decay strategies","Developers reproducing published training recipes with exact hyperparameters"],"limitations":["Complex composite schedules can be difficult to debug due to nested configuration","Per-parameter-group scheduling requires careful setup to avoid unintended learning rate mismatches","Scheduler state must be saved and restored with checkpoints; missing scheduler state causes training divergence"],"requires":["Python 3.9+","NeMo core module","PyTorch optimizer (SGD, Adam, AdamW)","Scheduler configuration (YAML)"],"input_types":["Optimizer instance","Scheduler configuration (warmup type, decay type, parameters)","Training step counter"],"output_types":["Learning rate schedule (per-step)","Scheduler state (for checkpointing)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":56,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","PyTorch 1.13+","NVIDIA CUDA 11.8+ for multi-GPU training","PyTorch Lightning 1.5+","NVIDIA Apex for automatic mixed precision","NeMo core module","Understanding of NeMo's Neural Types API","NeMo NLP module","Text dataset in supported format (JSON, CSV, plain text)","NVIDIA GPU with 8GB+ VRAM for training"],"failure_modes":["Requires PyTorch Lightning 1.5+ and NVIDIA APEX for mixed precision","Tensor parallelism requires careful model architecture design to avoid communication bottlenecks","Distributed checkpointing adds ~5-10% training overhead for synchronization across ranks","Type annotations are optional; models without them bypass validation","Runtime shape changes (e.g., variable sequence lengths) are not validated","Custom Neural Types require manual definition and registration","NLP training requires large labeled text datasets (10K+ examples); small datasets lead to poor generalization","Multi-lingual training requires balanced representation across languages; imbalanced data causes language confusion","Tokenizer selection significantly impacts model performance; custom tokenizers require careful tuning","SLM training requires large aligned audio-text datasets (1000+ hours); small datasets lead to poor alignment","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7389011439357054,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.063Z","last_scraped_at":"2026-05-03T13:58:21.998Z","last_commit":"2026-05-02T01:29:56Z"},"community":{"stars":17165,"forks":3402,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=nvidia-nemo--nemo","compare_url":"https://unfragile.ai/compare?artifact=nvidia-nemo--nemo"}},"signature":"eUoZznrv8zfuGJciuOMnpYsyt4E88htp5acOwR1dW3VpPZaF+Eq7DkZv0RsxyYve6pJdGMdXgcwFU3bx0PUPCw==","signedAt":"2026-06-21T11:44:03.544Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/nvidia-nemo--nemo","artifact":"https://unfragile.ai/nvidia-nemo--nemo","verify":"https://unfragile.ai/api/v1/verify?slug=nvidia-nemo--nemo","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}