{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-nvidia--generativeaiexamples","slug":"nvidia--generativeaiexamples","name":"GenerativeAIExamples","type":"repo","url":"https://github.com/NVIDIA/GenerativeAIExamples","page_url":"https://unfragile.ai/nvidia--generativeaiexamples","categories":["frameworks-sdks"],"tags":["gpu-acceleration","large-language-models","llm","llm-inference","microservice","nemo","rag","retrieval-augmented-generation","tensorrt","triton-inference-server"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-nvidia--generativeaiexamples__cap_0","uri":"capability://data.processing.analysis.synthetic.dataset.generation.via.llm.based.text.synthesis.with.domain.specific.templates","name":"synthetic dataset generation via llm-based text synthesis with domain-specific templates","description":"NeMo Data Designer generates synthetic training datasets by combining LLM text generation with non-LLM samplers and domain-specific templates. The system uses a microservice architecture that accepts template definitions and sampling parameters, orchestrates LLM calls for content generation, and outputs structured datasets in multiple formats. Templates define the schema and generation logic, while samplers control diversity and distribution of generated examples.","intents":["Generate labeled training data for fine-tuning without manual annotation","Create domain-specific synthetic datasets for specialized tasks like code generation or SQL queries","Rapidly prototype datasets for evaluation before collecting real user data","Scale data generation across multiple domains without rewriting generation logic"],"best_for":["ML engineers building fine-tuning pipelines who need fast iteration on training data","Teams requiring domain-specific synthetic data (code, SQL, medical text) without manual labeling","Enterprises prototyping LLM applications before committing to data collection infrastructure"],"limitations":["Generated data quality depends on LLM capability and template design — no automatic quality filtering","Scaling to millions of examples requires careful cost management with cloud-hosted LLMs","Domain-specific templates must be manually authored; no automatic template inference from examples","Synthetic data may exhibit LLM biases and hallucinations without post-generation validation"],"requires":["Python 3.8+","NVIDIA API key for cloud-hosted LLM inference or self-hosted NIM container with GPU","Docker for containerized deployment of NeMo Data Designer microservice","Template definitions in supported format (JSON or YAML)"],"input_types":["template definitions (JSON/YAML with generation schema)","sampler configurations (distribution parameters)","seed data or examples for few-shot generation"],"output_types":["structured datasets (JSON, JSONL, CSV)","labeled training examples","evaluation benchmarks"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_1","uri":"capability://automation.workflow.continuous.data.flywheel.with.evaluation.driven.refinement","name":"continuous data flywheel with evaluation-driven refinement","description":"NeMo Data Flywheel implements a closed-loop system that generates synthetic data, evaluates model performance on that data, identifies failure modes, and automatically refines generation templates based on evaluation results. The system tracks metrics across iterations and uses evaluation feedback to adjust sampling parameters and template logic, creating a continuous improvement cycle without manual intervention.","intents":["Automatically improve training data quality based on model performance metrics","Identify and fix data generation issues without manual review","Maintain data quality as model requirements evolve","Reduce manual data curation overhead in iterative development"],"best_for":["Teams building production LLM applications with continuous deployment cycles","Organizations needing automated data quality assurance without human-in-the-loop review","Projects where model performance directly drives data generation strategy"],"limitations":["Requires well-defined evaluation metrics — garbage metrics lead to garbage data refinements","Feedback loop latency can be high if evaluation is expensive or slow","Automatic refinement may converge to local optima without human guidance","Requires persistent state management to track flywheel iterations and metrics"],"requires":["NeMo Evaluator integration for automated metric computation","Evaluation dataset with ground truth labels","State persistence layer (database or object storage) for tracking iterations","Defined success metrics and refinement thresholds"],"input_types":["generated synthetic datasets","evaluation metrics (accuracy, F1, custom metrics)","model performance feedback","template refinement rules"],"output_types":["refined templates","updated sampling parameters","iteration history with metrics","data quality reports"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_10","uri":"capability://safety.moderation.safety.and.content.moderation.with.guardrails.and.alignment.evaluation","name":"safety and content moderation with guardrails and alignment evaluation","description":"NeMo Safe Synthesizer provides safety-focused data generation and evaluation by integrating content filtering, toxicity detection, and alignment checks into the data generation and evaluation pipelines. The system can generate synthetic data with safety constraints, evaluate model outputs for harmful content, and track safety metrics across model versions. Supports both rule-based filtering and LLM-based safety evaluation.","intents":["Generate training data that avoids harmful or biased content","Evaluate model safety before production deployment","Track safety metrics across fine-tuning iterations","Ensure generated content meets compliance and ethical standards"],"best_for":["Organizations deploying LLMs in regulated industries (healthcare, finance, government)","Teams building customer-facing AI applications requiring safety guarantees","Enterprises with strict content moderation requirements"],"limitations":["Safety evaluation is heuristic-based; no perfect detection of harmful content","False positives in safety filtering may reject benign content","Safety constraints in data generation may reduce dataset diversity","Alignment evaluation is subjective; requires clear safety guidelines and human review"],"requires":["Python 3.8+","Safety guidelines and policy definitions","Toxicity detection models or APIs","Human review process for borderline cases"],"input_types":["synthetic data generation templates with safety constraints","model outputs for safety evaluation","safety guidelines and policy definitions"],"output_types":["safety-filtered synthetic datasets","safety evaluation reports","safety metrics (toxicity score, alignment score)","flagged content for human review"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_11","uri":"capability://memory.knowledge.framework.agnostic.rag.implementation.with.pluggable.vector.databases.and.embedding.models","name":"framework-agnostic rag implementation with pluggable vector databases and embedding models","description":"Provides RAG reference implementations that abstract vector database and embedding model selection, allowing developers to swap implementations without changing application code. The system uses adapter patterns to support FAISS (in-memory), Milvus, Weaviate, Pinecone, and other vector databases, and supports multiple embedding models (NVIDIA NIM, OpenAI, HuggingFace). Configuration-driven setup enables rapid experimentation with different retrieval strategies.","intents":["Evaluate different vector databases without rewriting application code","Switch embedding models to optimize for quality or latency","Build RAG applications that are portable across deployment environments","Benchmark retrieval performance across different configurations"],"best_for":["Teams evaluating vector database options for production RAG","Developers building portable RAG applications across cloud and on-premises","Organizations optimizing RAG performance through configuration tuning"],"limitations":["Abstraction adds complexity; some vector database-specific features may not be exposed","Performance characteristics vary significantly across vector databases; benchmarking required","Configuration-driven setup may not cover all advanced use cases","Switching vector databases requires data re-indexing; migration overhead"],"requires":["Python 3.8+","Vector database (FAISS, Milvus, Weaviate, Pinecone, etc.)","Embedding model (NVIDIA NIM, OpenAI, HuggingFace)","Configuration file specifying vector database and embedding model"],"input_types":["vector database configuration","embedding model selection","document corpus","query configuration"],"output_types":["retrieved documents","retrieval metrics (latency, throughput)","comparison reports across configurations"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_2","uri":"capability://memory.knowledge.retrieval.augmented.generation.rag.pipeline.orchestration.across.multiple.frameworks","name":"retrieval-augmented generation (rag) pipeline orchestration across multiple frameworks","description":"Provides reference implementations of RAG pipelines supporting LangChain, LlamaIndex, and other frameworks, with pluggable components for embedding generation, vector storage, reranking, and LLM inference. The architecture decouples each RAG stage (retrieval, reranking, generation) as independent microservices, allowing developers to swap implementations (e.g., FAISS vs. Milvus for vector storage) without changing application code. Supports both cloud-hosted (NVIDIA API Catalog) and self-hosted (containerized NIM) inference patterns.","intents":["Build RAG applications that ground LLM responses in custom knowledge bases","Switch between vector databases and embedding models without rewriting application logic","Deploy RAG pipelines on-premises for data privacy or latency requirements","Evaluate different retrieval and reranking strategies without framework lock-in"],"best_for":["Teams building enterprise RAG applications with strict data residency requirements","Developers evaluating multiple RAG frameworks and vector database options","Organizations needing production-grade RAG with monitoring and observability"],"limitations":["Framework-specific examples may not cover all edge cases or advanced features","Vector database performance depends on indexing strategy and query optimization — no automatic tuning","Reranking adds latency to retrieval pipeline; tradeoff between quality and speed must be tuned per use case","No built-in multi-hop reasoning or complex query decomposition — limited to single-turn retrieval"],"requires":["Python 3.8+","LangChain, LlamaIndex, or compatible framework","Vector database (FAISS for in-memory, Milvus/Weaviate/Pinecone for production)","NVIDIA API key or self-hosted NIM container for embedding and LLM inference","Document corpus in supported formats (PDF, TXT, JSON)"],"input_types":["user queries (text)","document corpus (PDF, TXT, JSON, markdown)","vector database configuration","embedding model selection"],"output_types":["retrieved documents with relevance scores","reranked results","LLM-generated responses grounded in retrieved context","retrieval metrics (precision, recall, MRR)"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_3","uri":"capability://memory.knowledge.multimodal.rag.with.image.and.text.retrieval.fusion","name":"multimodal rag with image and text retrieval fusion","description":"Extends RAG pipelines to handle multimodal documents containing both images and text by using separate embedding models for each modality and fusing retrieval results at the ranking stage. Images are embedded using vision models, text using language models, and a reranker scores cross-modal relevance to determine which documents (image or text) best answer the query. The system maintains separate vector indices for each modality and orchestrates cross-modal retrieval.","intents":["Build RAG systems that retrieve relevant images and text for queries","Ground LLM responses in multimodal documents (e.g., technical manuals with diagrams)","Evaluate cross-modal relevance without manual annotation","Support queries that naturally span image and text content"],"best_for":["Teams building document search systems for technical or medical content with diagrams","Organizations with multimodal knowledge bases (e.g., product catalogs with images and descriptions)","Enterprises needing to index and retrieve from scanned documents with OCR"],"limitations":["Requires separate embedding models for each modality, increasing inference latency and memory overhead","Cross-modal reranking is computationally expensive; may require careful optimization for real-time queries","Image quality and OCR accuracy directly impact retrieval quality — no automatic image preprocessing","Limited to image+text; video and audio support not included in reference implementations"],"requires":["Python 3.8+","Vision embedding model (e.g., CLIP) and text embedding model","Separate vector indices for images and text","Reranker model supporting cross-modal scoring","Document corpus with images and text (PDF with embedded images, image+text pairs)"],"input_types":["user queries (text)","multimodal documents (PDF with images, image+text pairs)","image preprocessing configuration (resize, compression)"],"output_types":["ranked list of images and text passages","cross-modal relevance scores","LLM-generated responses with image and text citations"],"categories":["memory-knowledge","image-visual"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_4","uri":"capability://tool.use.integration.tool.calling.workflow.with.schema.based.function.registry.and.multi.provider.support","name":"tool calling workflow with schema-based function registry and multi-provider support","description":"Implements structured tool calling by defining a schema-based function registry that maps tool definitions to LLM function-calling APIs across multiple providers (OpenAI, Anthropic, NVIDIA NIM). The system accepts tool schemas (name, description, parameters), orchestrates LLM calls with tool definitions, parses tool-use responses, and executes registered functions. Supports both native function-calling APIs and fallback parsing for models without native support.","intents":["Enable LLMs to call external tools and APIs in a structured, type-safe manner","Build agents that can invoke multiple tools in sequence based on task requirements","Switch between LLM providers without rewriting tool definitions","Validate tool arguments against schemas before execution"],"best_for":["Developers building LLM agents that need to interact with external systems","Teams evaluating multiple LLM providers and wanting provider-agnostic tool definitions","Organizations building enterprise agents with strict validation and audit requirements"],"limitations":["Tool calling reliability depends on LLM capability — weaker models may fail to invoke tools correctly","No built-in error handling or retry logic for failed tool executions","Schema validation adds latency; complex schemas with many parameters may confuse LLMs","Function execution is synchronous; no built-in support for parallel tool calls or async execution"],"requires":["Python 3.8+","LLM provider API key (OpenAI, Anthropic, or NVIDIA NIM)","Tool function implementations matching schema definitions","JSON schema definitions for tool parameters"],"input_types":["tool schema definitions (JSON schema format)","user queries or agent tasks","tool function implementations (Python callables)"],"output_types":["tool invocation requests with arguments","tool execution results","LLM responses incorporating tool results"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_5","uri":"capability://data.processing.analysis.embedding.fine.tuning.workflow.with.domain.specific.optimization","name":"embedding fine-tuning workflow with domain-specific optimization","description":"Provides end-to-end workflows for fine-tuning embedding models on domain-specific data using contrastive learning objectives. The system accepts training data with query-document pairs or triplets, orchestrates fine-tuning on NVIDIA GPUs using NeMo framework, and evaluates embeddings on domain-specific benchmarks. Supports both supervised fine-tuning (with labeled pairs) and unsupervised approaches (with hard negative mining).","intents":["Improve embedding quality for domain-specific retrieval tasks","Fine-tune embeddings on proprietary data without sharing data with third parties","Evaluate embedding quality on custom benchmarks before deployment","Reduce embedding dimensionality or latency through distillation"],"best_for":["Teams with domain-specific retrieval tasks (e.g., legal, medical, scientific) where general embeddings underperform","Organizations with proprietary data that cannot be shared with cloud embedding providers","ML engineers optimizing embedding quality for production RAG systems"],"limitations":["Requires labeled query-document pairs or triplets; weak labels lead to poor fine-tuning","Fine-tuning is computationally expensive; requires GPU infrastructure and significant training time","Embedding quality improvements are task-specific; fine-tuned embeddings may not generalize to other domains","No automatic hyperparameter tuning; requires manual experimentation with learning rates and batch sizes"],"requires":["Python 3.8+","NVIDIA GPU (A100 or H100 recommended for production-scale fine-tuning)","NeMo framework and dependencies","Training data with query-document pairs or triplets (minimum 1000 examples recommended)","Evaluation benchmark for domain-specific tasks"],"input_types":["training data (query-document pairs or triplets in JSON/CSV)","base embedding model (HuggingFace or NVIDIA NeMo)","hyperparameter configuration (learning rate, batch size, epochs)"],"output_types":["fine-tuned embedding model","evaluation metrics (MRR, NDCG, MAP on benchmark)","training logs and convergence plots"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_6","uri":"capability://data.processing.analysis.automated.model.evaluation.with.domain.specific.metrics.and.benchmarking","name":"automated model evaluation with domain-specific metrics and benchmarking","description":"NeMo Evaluator provides automated evaluation of generative AI models using domain-specific metrics (accuracy, F1, BLEU, ROUGE, custom metrics) and benchmarking frameworks. The system accepts model outputs and ground truth labels, computes metrics in parallel, generates evaluation reports with statistical significance testing, and tracks metrics across model versions. Supports both task-specific metrics (e.g., code correctness for code generation) and general metrics (e.g., semantic similarity).","intents":["Measure model quality improvements from fine-tuning or prompt optimization","Compare model versions objectively before production deployment","Identify failure modes and edge cases through detailed error analysis","Track model performance over time as training data or prompts evolve"],"best_for":["ML teams evaluating fine-tuned models before production deployment","Organizations tracking model quality across continuous deployment cycles","Researchers comparing generative AI approaches on standardized benchmarks"],"limitations":["Metric quality depends on ground truth labels; weak labels lead to misleading evaluations","Some metrics (e.g., human evaluation) cannot be automated and require manual review","Evaluation can be computationally expensive for large datasets; requires careful batching","Statistical significance testing requires sufficient sample size; small datasets may not support reliable conclusions"],"requires":["Python 3.8+","Model outputs (predictions) and ground truth labels","Metric definitions (built-in or custom Python functions)","Evaluation dataset (minimum 100 examples recommended for statistical significance)"],"input_types":["model predictions (text, code, structured data)","ground truth labels or references","metric configuration (metric names, parameters)","evaluation dataset"],"output_types":["metric scores (accuracy, F1, BLEU, ROUGE, custom metrics)","evaluation reports with statistical summaries","error analysis and failure mode identification","comparison reports across model versions"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_7","uri":"capability://tool.use.integration.cloud.hosted.inference.via.nvidia.api.catalog.with.zero.gpu.setup","name":"cloud-hosted inference via nvidia api catalog with zero-gpu setup","description":"Provides quick-start examples using NVIDIA API Catalog for LLM inference, embedding generation, and reranking without requiring local GPU infrastructure. Applications authenticate via API key and make REST calls to cloud-hosted models, enabling rapid prototyping and evaluation without infrastructure setup. Supports both synchronous and asynchronous API calls, with built-in retry logic and rate limiting.","intents":["Prototype RAG and agent applications without GPU infrastructure","Evaluate NVIDIA models before committing to self-hosted deployment","Build applications with minimal operational overhead","Scale inference without managing GPU clusters"],"best_for":["Startups and small teams prototyping LLM applications without infrastructure budget","Developers evaluating NVIDIA models before production deployment","Organizations with variable inference load that prefer pay-per-use pricing"],"limitations":["Per-query API costs can be prohibitive at scale; total cost of ownership exceeds self-hosted deployment above certain volume thresholds","Inference latency includes network round-trip time; not suitable for ultra-low-latency applications","Data is sent to NVIDIA servers; not suitable for applications with strict data residency requirements","Rate limiting and quota management required for high-throughput applications"],"requires":["NVIDIA API key from https://build.nvidia.com","Python 3.8+ with requests or httpx library","Network connectivity to NVIDIA API endpoints","Valid billing account for API usage"],"input_types":["text queries","documents for embedding","API configuration (model selection, parameters)"],"output_types":["LLM-generated text","embeddings (vector representations)","reranking scores"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_8","uri":"capability://automation.workflow.self.hosted.inference.with.containerized.nvidia.nims.and.gpu.orchestration","name":"self-hosted inference with containerized nvidia nims and gpu orchestration","description":"Provides reference implementations for deploying NVIDIA NIM (NVIDIA Inference Microservices) containers on GPU infrastructure for LLM inference, embedding generation, and reranking. The system uses Docker Compose or Kubernetes for orchestration, manages GPU allocation and memory, and exposes OpenAI-compatible REST APIs. Supports multi-GPU inference with tensor parallelism and batching optimization for throughput.","intents":["Deploy LLM inference on-premises for data privacy and compliance","Reduce inference costs by eliminating per-query API fees","Achieve low-latency inference with local GPU infrastructure","Maintain full control over model versions and inference parameters"],"best_for":["Enterprises with strict data residency or compliance requirements","Organizations with high-volume inference workloads where API costs are prohibitive","Teams needing ultra-low-latency inference for real-time applications"],"limitations":["Requires significant upfront GPU infrastructure investment (A100/H100 GPUs are expensive)","Operational overhead includes GPU cluster management, monitoring, and maintenance","GPU memory constraints limit batch size and context length; requires careful tuning","Multi-GPU inference adds complexity; tensor parallelism requires careful orchestration"],"requires":["NVIDIA GPU infrastructure (A100, H100, or equivalent)","Docker and Docker Compose or Kubernetes","NVIDIA CUDA Toolkit 12.0+","NVIDIA Container Runtime","Sufficient GPU memory (40GB+ for large models like Llama 70B)"],"input_types":["model selection (Llama, Mistral, Nemotron, etc.)","inference configuration (batch size, context length, quantization)","text queries or documents"],"output_types":["LLM-generated text","embeddings","reranking scores","inference metrics (latency, throughput)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nvidia--generativeaiexamples__cap_9","uri":"capability://planning.reasoning.industry.specific.solution.templates.for.asset.lifecycle.management.and.sql.integration","name":"industry-specific solution templates for asset lifecycle management and sql integration","description":"Provides pre-built reference implementations for domain-specific applications including asset lifecycle management (tracking equipment, maintenance, depreciation) and SQL Server AI integration (semantic search over databases, natural language queries). These templates combine RAG, tool calling, and fine-tuned embeddings to solve industry problems without starting from scratch. Each template includes data schemas, evaluation benchmarks, and deployment guides.","intents":["Rapidly deploy industry-specific AI applications without building from first principles","Integrate AI with existing enterprise systems (SQL databases, asset management systems)","Evaluate AI effectiveness on domain-specific tasks before full deployment","Reduce time-to-value for enterprise AI projects"],"best_for":["Enterprise teams building industry-specific AI applications (manufacturing, utilities, finance)","Organizations with existing SQL databases wanting to add semantic search capabilities","Teams lacking deep AI expertise but needing to deploy domain-specific solutions"],"limitations":["Templates are reference implementations; customization required for specific business logic","Industry-specific schemas may not match existing systems; data mapping required","Evaluation benchmarks are generic; domain-specific metrics may need to be added","No built-in integration with legacy systems; custom connectors may be required"],"requires":["Python 3.8+","Domain-specific data (asset records, SQL database, documents)","NVIDIA GPU infrastructure or API Catalog access","Understanding of domain-specific requirements and metrics"],"input_types":["asset or entity data (JSON, CSV, database records)","SQL database schema and sample queries","domain-specific documents or knowledge bases"],"output_types":["asset lifecycle predictions or recommendations","natural language query results from SQL databases","domain-specific metrics and reports"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":48,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","NVIDIA API key for cloud-hosted LLM inference or self-hosted NIM container with GPU","Docker for containerized deployment of NeMo Data Designer microservice","Template definitions in supported format (JSON or YAML)","NeMo Evaluator integration for automated metric computation","Evaluation dataset with ground truth labels","State persistence layer (database or object storage) for tracking iterations","Defined success metrics and refinement thresholds","Safety guidelines and policy definitions","Toxicity detection models or APIs"],"failure_modes":["Generated data quality depends on LLM capability and template design — no automatic quality filtering","Scaling to millions of examples requires careful cost management with cloud-hosted LLMs","Domain-specific templates must be manually authored; no automatic template inference from examples","Synthetic data may exhibit LLM biases and hallucinations without post-generation validation","Requires well-defined evaluation metrics — garbage metrics lead to garbage data refinements","Feedback loop latency can be high if evaluation is expensive or slow","Automatic refinement may converge to local optima without human guidance","Requires persistent state management to track flywheel iterations and metrics","Safety evaluation is heuristic-based; no perfect detection of harmful content","False positives in safety filtering may reject benign content","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5972307979331266,"quality":0.49,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"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:29.527Z","last_commit":"2026-03-30T19:47:19Z"},"community":{"stars":3976,"forks":1050,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=nvidia--generativeaiexamples","compare_url":"https://unfragile.ai/compare?artifact=nvidia--generativeaiexamples"}},"signature":"aYM6TZffcWlwHfihDiMe1dhfcX4a5UV4hEE1wkON8tr6JKJLsdoo4xuF9YmjUfJ7mwvSuksONAnUKAavJm4ZCw==","signedAt":"2026-06-20T22:30:22.099Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/nvidia--generativeaiexamples","artifact":"https://unfragile.ai/nvidia--generativeaiexamples","verify":"https://unfragile.ai/api/v1/verify?slug=nvidia--generativeaiexamples","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"}}