NVIDIA AI Models and Application Development

Models are only as good as their data. You see how raw data becomes clean, governed data through ETL, quality checks and protection of personal information, in terms a new developer can follow.

• Data sources and formats for AI
• Extract, transform and load in plain terms
• Data quality checks
• Finding and protecting personal information
• Governance and data lineage
• Preparing text for model use

You build A data-cleaning script and a short note on how it protects personal data.

Production use produces the best training data. You see how a flywheel collects feedback and outputs, filters them, and feeds them back into evaluation and customization, and where the loop can go wrong.

• Collecting usage and feedback data
• Filtering and curating production data
• Feeding data back into evaluation
• Feeding data back into customization
• Risks: bias, leakage and feedback loops
• Measuring whether the flywheel helps

You build A flywheel diagram for one application, with the checks at each step.

There are three ways to adapt a model, and each costs something different. You learn when prompting is enough, when retrieval helps and when fine-tuning is worth it, then meet LoRA, supervised tuning, distillation and preference optimization.

• Prompting, RAG and fine-tuning compared
• How retrieval-augmented generation works
• Supervised fine-tuning and LoRA
• Distillation into smaller models
• Preference optimization at a glance
• Risks of tuning and testing before deployment

You build A decision guide that matches three scenarios to the right customization method.

An agent decides what to do next and uses tools to do it. You learn the ReAct pattern, how tools are exposed through MCP, how agents remember, and how several agents are orchestrated.

• From model to agent
• The ReAct reasoning pattern
• Tool use and the Model Context Protocol
• Short-term and long-term memory
• Orchestrating several agents
• Planning and task decomposition

You build A simple agent with one tool, and a trace showing each reasoning step.

An agent that acts needs limits and checks. You see how guardrails, human oversight and permissions control behavior, and how to measure whether an agent actually does its job.

• Guardrails on inputs, outputs and actions
• Human oversight and approval points
• Permissions and tool limits
• Measuring task success
• Evaluating agents on realistic tasks
• Common failure patterns

You build A guardrail and oversight plan for an agent that can edit customer records.

Serving a model has its own vocabulary. You learn prefill and decode, why latency and throughput pull against each other, and how quantization, KV caching, batching and parallelism change the cost of an answer.

• Prefill and decode phases
• Latency and throughput
• Quantization and precision
• KV caching and batching
• Parallelism across GPUs
• TensorRT-LLM and optimized runtimes
• Reading cost per request

You build A worked estimate of latency, throughput and cost for one model under two settings.

NVIDIA packages AI for production. You learn what NVIDIA AI Enterprise includes, how NIM microservices deliver models behind standard APIs, how Blueprints give a starting design, and where Kubernetes and the AI factory fit.

• NVIDIA AI Enterprise overview
• NIM microservices and their APIs
• Blueprints as reference applications
• Running on Kubernetes
• The AI factory idea
• From prototype to production

You build A diagram of how a prototype app moves onto NIM, Kubernetes and a Blueprint.

Some AI acts in the physical world. You learn what physical AI is, why robots and vehicles train in simulation, how digital twins are built, and which NVIDIA tools and model families serve this field.

• What physical AI is
• Simulation and synthetic data
• Digital twins and Omniverse
• Isaac Sim for robotics
• Cosmos world models
• Closing the sim-to-real gap

You build A one-page plan that trains and validates a robot task in simulation before real use.

A deployed model needs capacity and care. You learn to size GPU memory for a model, set up monitoring and observability, watch for drift, and manage versions and GPU sharing, with Run:ai as one example.

• The model lifecycle from development to retirement
• Estimating GPU memory for a model
• Choosing compute for a workload
• Monitoring and observability basics
• Detecting drift
• Sharing GPUs between teams with Run:ai

You build A sizing and monitoring plan for one deployed model.

Plan one application from start to finish. You pick the model, prepare the data, decide how to customize it, add an agent where it helps, and size, serve and monitor the result.

• Choosing the model and data
• Choosing the customization method
• Adding an agent and its safeguards
• Choosing the serving setup
• Sizing and monitoring the result

You build A written plan for an AI application covering model, data, customization, serving and monitoring.