NVIDIA NCP-AAI Cheat Sheet: Complete Agentic AI Reference [2026]

Print-friendly | Download PDF | Save for Exam Day

This comprehensive cheat sheet covers all 10 exam domains with architecture patterns, comparison tables, and code snippets. Based on the official NVIDIA NCP-AAI exam guide (15/15/13/13/10/10/7/5/5/5 weighting).

Domain 1: Agent Architecture and Design (15%)

Agent Architecture Patterns

When to use which:

Task is dynamic with unknown steps? → ReAct
Task is well-defined and sequential? → Plan-and-Execute
Accuracy is critical, latency flexible? → Reflexion
Multiple valid solution paths exist? → LATS
Simple tool routing, no reasoning? → Tool-Only

Single-Agent vs Multi-Agent

Multi-Agent Orchestration Patterns:

Sequential:    Agent A → Agent B → Agent C  (pipeline)
Parallel:      Agent A ↗ Agent B ↗ Agent C  (fan-out, merge)
Hierarchical:  Orchestrator → [Worker A, Worker B, Worker C]
Collaborative: Agents negotiate and share state

Agent Communication

Domain 2: Agent Development (15%)

Tool/Function Calling

# OpenAI-compatible function calling format
tools = [{
    "type": "function",
    "function": {
        "name": "search_database",
        "description": "Search product database by query",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"},
                "limit": {"type": "integer", "default": 5}
            },
            "required": ["query"]
        }
    }
}]

# Always validate tool parameters before execution
def safe_tool_call(tool_name, params):
    validated = validate_params(tool_name, params)
    try:
        result = execute_tool(tool_name, validated)
        return result
    except ToolError as e:
        return fallback_response(tool_name, e)

Error Handling Patterns

# Circuit breaker pattern
class CircuitBreaker:
    def __init__(self, failure_threshold=3, reset_timeout=30):
        self.failures = 0
        self.threshold = failure_threshold
        self.state = "closed"  # closed → open → half-open

    def call(self, func, *args):
        if self.state == "open":
            if time_since_open > self.reset_timeout:
                self.state = "half-open"
            else:
                return fallback()

        try:
            result = func(*args)
            self.failures = 0
            self.state = "closed"
            return result
        except Exception:
            self.failures += 1
            if self.failures >= self.threshold:
                self.state = "open"
            raise

Agent Frameworks Comparison

Domain 3: Evaluation and Tuning (13%)

Agent Evaluation Metrics

A/B Testing for Agents

1. Define hypothesis: "ReAct with CoT outperforms vanilla ReAct"
2. Split traffic: 50/50 random assignment
3. Measure: Task completion, latency, cost, user satisfaction
4. Duration: Minimum 1000 interactions per variant
5. Statistical significance: p < 0.05
6. Decision: Roll out winner, document learnings

Fine-Tuning Decision Guide

Domain 4: Deployment and Scaling (13%)

Containerized Agent Deployment

# docker-compose.yml for agent system
services:
  agent-api:
    image: agent-service:latest
    deploy:
      replicas: 3
      resources:
        reservations:
          devices:
            - capabilities: [gpu]
    environment:
      - MODEL_ENDPOINT=http://nim-server:8000
      - VECTOR_DB_URL=http://chromadb:8000

  nim-server:
    image: nvcr.io/nim/meta/llama-3-8b-instruct:latest
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]
    ports:
      - "8000:8000"

Scaling Strategies

Deployment Strategies

Domain 5: Cognition, Planning, and Memory (10%)

Reasoning Frameworks

CoT:  Think → Think → Think → Answer (linear)
ToT:  Think → Branch → Evaluate → Select → Think (tree)
ReAct: Think → Act → Observe → Think → Act (loop)
MCTS: Simulate → Evaluate → Backprop → Select (search)

Memory Systems

Memory Architecture Pattern:

User Input → Short-term Memory (context window)
           → Retrieve from Long-term Memory (vector DB)
           → Check Episodic Memory (similar past scenarios)
           → Agent Processes with Working Memory
           → Store important results to Long-term Memory

Context Window Management

# Token budget allocation
total_tokens = 8192  # Model context window

system_prompt = 500     # ~6% - Agent instructions
retrieved_docs = 3000   # ~37% - RAG context
conversation = 2000     # ~24% - Chat history
working_memory = 1000   # ~12% - Scratchpad
output_reserve = 1692   # ~21% - Generation space

# Compression strategies when exceeding budget:
# 1. Summarize older conversation turns
# 2. Reduce retrieved docs (top-3 → top-2)
# 3. Compress working memory

Domain 6: Knowledge Integration and Data Handling (10%)

RAG Pipeline

Documents → Chunk → Embed → Store (Vector DB)
                                    ↓
Query → Embed → Search → Retrieve Top-K → Rerank → Augment Prompt → LLM → Response

Chunking Strategies

Best practices:

• Preserve sentence boundaries
• Include metadata (source, page, date)
• Test with your domain data
• Smaller chunks = more precise, less context
• Larger chunks = more context, less precise

Vector Database Comparison

Retrieval Optimization

# Hybrid search: BM25 (keyword) + Semantic (vector)
from langchain.retrievers import EnsembleRetriever

ensemble = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.3, 0.7]  # Weight semantic higher
)

# Reranking: Cross-encoder for precision
from sentence_transformers import CrossEncoder
reranker = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")

# Pipeline: Retrieve 20 → Rerank → Return top 3-5
candidates = ensemble.get_relevant_documents(query, k=20)
reranked = reranker.rank(query, [doc.page_content for doc in candidates])
final_docs = reranked[:5]

Similarity Metrics

Domain 7: NVIDIA Platform Implementation (7%)

NVIDIA NIM (Inference Microservices)

# Deploy optimized LLM inference with NIM
docker run -it --gpus all \
  -e NGC_API_KEY=$NGC_API_KEY \
  -p 8000:8000 \
  nvcr.io/nim/meta/llama-3.1-8b-instruct:latest

# OpenAI-compatible API
curl -X POST http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "meta/llama-3.1-8b-instruct",
       "messages": [{"role": "user", "content": "Hello"}],
       "max_tokens": 100}'

Key NIM Features:

• TensorRT-LLM optimizations (3-5x speedup)
• Multi-GPU support with tensor parallelism
• OpenAI API compatibility
• Built-in health checks and metrics

Triton Inference Server

# config.pbtxt for model serving
name: "agent-llm"
platform: "tensorrt_llm"
max_batch_size: 8

dynamic_batching {
  preferred_batch_size: [4, 8]
  max_queue_delay_microseconds: 100
}

instance_group [
  { count: 1, kind: KIND_GPU }
]

Triton Use Cases:

• Multi-model serving (host embedding + LLM + reranker)
• Dynamic batching (combine requests for efficiency)
• Model ensembles (chain retriever → LLM)

NeMo Guardrails

# Example: Prevent off-topic conversations
define user ask off topic
  "What's the weather?"
  "Tell me a joke"
  "Who won the game?"

define flow off topic
  user ask off topic
  bot refuse off topic
  "I'm focused on helping with [your domain]. Let me know
   how I can assist with that."

# Example: Require human approval for actions
define flow high stakes action
  user request financial transaction
  bot confirm with human
  "This action requires human approval. Routing to a reviewer."

NVIDIA Platform Quick Reference

Domain 8: Run, Monitor, and Maintain (5%)

Production Monitoring

Distributed Tracing for Agents

Trace: user_query_123
├── Agent Orchestrator (50ms)
│   ├── Retrieve from Vector DB (120ms)
│   ├── LLM Reasoning Step 1 (800ms)
│   ├── Tool Call: search_api (350ms)
│   ├── LLM Reasoning Step 2 (750ms)
│   └── Format Response (30ms)
└── Total: 2100ms

Tools: OpenTelemetry, LangSmith, Datadog, Grafana

Domain 9: Safety, Ethics, and Compliance (5%)

Agent Safety Guardrails

Compliance Quick Reference

Domain 10: Human-AI Interaction and Oversight (5%)

HITL Escalation Framework

# Confidence-based escalation
def should_escalate(agent_response):
    if agent_response.confidence < 0.7:
        return "low_confidence"
    if agent_response.involves_financial_action:
        return "high_stakes"
    if agent_response.sentiment == "frustrated":
        return "user_sentiment"
    return None  # No escalation needed

# Escalation tiers
ESCALATION_TIERS = {
    "low_confidence": "queue_for_review",     # Async review
    "high_stakes": "immediate_handoff",       # Real-time human
    "user_sentiment": "offer_human_option",   # User choice
}

Transparency Best Practices

Exam Strategy Quick Tips

Time Management

• 60-70 questions in 120 minutes = ~1.7-2 min per question
• Flag uncertain questions, return at end
• Aim to finish with 10-minute buffer for review

Domain Weight Summary

Architecture + Development:  30%  (~21 questions) ← FOCUS HERE
Evaluation + Deployment:     26%  (~18 questions)
Cognition + Knowledge:       20%  (~14 questions)
Monitor + Safety + Human-AI: 15%  (~11 questions) ← Easiest points
NVIDIA Platform:              7%  (~5 questions)  ← Small but specific

Common Wrong Answer Patterns

Domain Coverage Checklist

• Agent Architecture (15%): Patterns, single vs multi-agent, orchestration
• Agent Development (15%): Tool calling, error handling, frameworks
• Evaluation & Tuning (13%): Metrics, A/B testing, fine-tuning decisions
• Deployment & Scaling (13%): Containers, Kubernetes, scaling strategies
• Cognition & Memory (10%): Reasoning frameworks, memory types, context management
• Knowledge Integration (10%): RAG, chunking, vector DBs, hybrid search
• NVIDIA Platform (7%): NIM, Triton, NeMo Guardrails, TensorRT-LLM
• Run & Monitor (5%): Observability, tracing, alerting, drift detection
• Safety & Ethics (5%): Guardrails, compliance (GDPR, AI Act), red-teaming
• Human-AI Interaction (5%): HITL, confidence thresholds, transparency

Additional Resources

Official NVIDIA:

• NCP-AAI Certification Page
• NVIDIA DLI Courses (free with registration)

Technical References:

• LangChain Documentation
• LlamaIndex Documentation
• NVIDIA NIM Documentation
• NVIDIA NeMo Guardrails

Practice:

• Preporato NCP-AAI Practice Exams - 7 full-length tests (420+ questions)

Print Instructions: This cheat sheet is optimized for 3-page printing. Use landscape orientation for best results.

Last Updated: March 8, 2026

Based on official NVIDIA NCP-AAI exam guide. All domain weights and topics verified against official sources.

Sources:

• NVIDIA NCP-AAI Official Certification
• NVIDIA NeMo Guardrails Documentation
• LangChain Agent Documentation
• NVIDIA NIM Documentation