NVIDIA Certified Professional - Agentic AI (NCP-AAI) Flashcards¶
65 cards from this guide's fact sheet and notes. Click a question to reveal the answer.
To study with spaced repetition, download flashcards.csv and import it into Anki or Quizlet (comma separated, first row is the header). Back to the study guide.
Exam logistics¶
How long is the NVIDIA Certified Professional - Agentic AI (NCP-AAI) exam?
120 minutes
How many questions are on the NVIDIA Certified Professional - Agentic AI (NCP-AAI) exam?
60-70 questions
What is the passing score for NVIDIA Certified Professional - Agentic AI (NCP-AAI)?
Not officially published
What does the NVIDIA Certified Professional - Agentic AI (NCP-AAI) exam cost?
$200 USD
How long is NVIDIA Certified Professional - Agentic AI (NCP-AAI) valid for?
2 years
Agentic architectures¶
Summarization (agentic architectures)
Compress older messages to save context space
RAG retrieval (agentic architectures)
Fetch relevant long-term memories on demand
Priority retention (agentic architectures)
Keep high-importance information longer
Consolidation (agentic architectures)
Periodically merge and deduplicate memories
Eviction policies (agentic architectures)
Remove stale or low-value entries
Tool use function calling¶
Chain (tool use function calling)
Output of one tool feeds into the next
Map-Reduce (tool use function calling)
Apply tool to multiple items, aggregate results
Fan-out/Fan-in (tool use function calling)
Parallel sub-tasks that merge at a sync point
Conditional (tool use function calling)
Branch execution based on tool results
Multi agent systems¶
Specialization (multi agent systems)
Each agent focuses on a specific domain or skill
Scalability (multi agent systems)
Add agents for new capabilities without modifying existing ones
Robustness (multi agent systems)
Failure of one agent does not necessarily halt the system
Complexity management (multi agent systems)
Break complex tasks into manageable agent responsibilities
Parallel processing (multi agent systems)
Independent agents can work simultaneously
Orchestrator (multi agent systems)
Coordinates other agents, manages task flow
Researcher (multi agent systems)
Gathers and synthesizes information
Coder (multi agent systems)
Writes, reviews, and debugs code
Critic (multi agent systems)
Evaluates outputs and provides feedback
Planner (multi agent systems)
Decomposes tasks and creates execution plans
Executor (multi agent systems)
Carries out specific actions using tools
Validator (multi agent systems)
Checks results against requirements and constraints
Handoff (multi agent systems)
One agent explicitly transfers control to another
Delegation (multi agent systems)
Agent assigns sub-tasks to other agents
Consultation (multi agent systems)
Agent requests input from another without transferring control
Notification (multi agent systems)
Agent informs others of important events or results
Nim microservices¶
Function calling support (nim microservices)
Model must handle tool_choice and function schemas
Strong instruction following (nim microservices)
Agents rely on precise instruction adherence
Reasoning capability (nim microservices)
Complex tasks require multi-step reasoning
Context length (nim microservices)
Longer context supports more tools and conversation history
Low latency (nim microservices)
Interactive agents need fast response times
LLaMA 3.1 (8B, 70B, 405B) (nim microservices)
Strong function calling, various size/quality trade-offs
Mixtral 8x7B (nim microservices)
Good balance of speed and quality via mixture of experts
Nemotron (nim microservices)
NVIDIA's models optimized for enterprise agent workloads
Mistral Large (nim microservices)
High-quality reasoning and function calling
Streaming (nim microservices)
Enable SSE streaming for responsive user experience
KV-cache management (nim microservices)
Paged attention for efficient memory use
Batching (nim microservices)
Continuous batching for concurrent agent sessions
Quantization (nim microservices)
FP8 on H100, INT8/FP16 on A100 for faster inference
Safety guardrails¶
Flows (safety guardrails)
Define allowed conversation patterns
User messages (safety guardrails)
Canonical forms for user intents
Bot messages (safety guardrails)
Define bot response patterns
Actions (safety guardrails)
Custom Python functions invoked by guardrails
Variables (safety guardrails)
Store and reference conversation state
Max iterations (safety guardrails)
Set limits on agent reasoning loops
Timeouts (safety guardrails)
Enforce time limits for individual tool calls and total task time
Circuit breakers (safety guardrails)
Stop calling failing external services
Resource budgets (safety guardrails)
Limit total tokens, tool calls, or cost per session
Graceful degradation (safety guardrails)
Fall back to simpler responses when systems fail
Red teaming (safety guardrails)
Adversarial testing by security experts
Automated probing (safety guardrails)
Run known attack patterns against guardrails
Regression testing (safety guardrails)
Verify safety after model or config updates
Edge case testing (safety guardrails)
Test boundary conditions and unusual inputs
Unit tests (safety guardrails)
Test individual tools and guardrails in isolation
Integration tests (safety guardrails)
Test agent workflows end-to-end
Load tests (safety guardrails)
Verify performance under concurrent agent sessions
Chaos tests (safety guardrails)
Randomly disable tools or services to test resilience
Blue-green deployments (safety guardrails)
Deploy new versions alongside old
Canary releases (safety guardrails)
Gradually shift traffic to new version
Rollback procedures (safety guardrails)
Quickly revert when issues are detected
Incident response (safety guardrails)
Documented procedures for agent misbehavior