Free NVIDIA-Certified Professional: Agentic AI (NCP-AAI) Practice Questions

Sample NCP-AAI Practice Questions

Browse all 10 free NVIDIA-Certified Professional: Agentic AI practice questions below.

1. Your team is choosing between rolling a custom multi-agent loop and adopting the NVIDIA NeMo Agent Toolkit alongside an existing LangChain-based agent. Select TWO capabilities the NeMo Agent Toolkit provides out-of-the-box that justify adoption.

   • Compilation of your Python agent control flow into native CUDA kernels at startup so multi-step reasoning runs entirely on the GPU.
   • Framework-agnostic instrumentation that runs alongside agents built on LangChain, LlamaIndex, CrewAI, Semantic Kernel, or custom Python, with integrations for Phoenix, Weave, Langfuse, and OpenTelemetry.
   • On-device fine-tuning of the underlying LLM weights using runtime feedback signals collected from agent interactions.
   • Built-in real-time multimodal video reasoning that scores user facial cues and audio sentiment during agent calls.
   • Workflow-level and token-level profiling that tracks latency and token usage across every tool call, retrieval, and LLM invocation in the agent.

2. You’re tasked with selecting the better agent between two candidates based on performance across multiple tasks, including classification, question answering, and summarization. What is the best strategy to compare their performance?

   • Select the model with the fastest average response time across tasks, since latency dominates user-perceived quality in interactive agents.
   • Use task-specific evaluation metrics and compare per-task performance.
   • Count the number of tokens each agent consumes across all tasks.
   • Choose the model with the highest accuracy on any single task as a strong general-purpose proxy for overall performance.

3. You operate a NeMo-based agent that performs RAG over a large vector store and then queries an LLM accelerated with TensorRT-LLM behind Triton. Costs are rising and throughput is capped. Which configuration change best improves throughput per dollar while keeping response quality stable?

   • Turn off NeMo Guardrails to remove an extra processing step and save cost, since policy enforcement and content checks add per-token overhead in the response path.
   • Always force the agent to call tools after generation so the LLM "thinks" first.
   • Cache the final generated answers for each user session and return the cache on any query whose embedding is approximately similar, even when the underlying knowledge base has been updated.
   • Batch embedding creation and retrieval calls where possible, and enable response streaming from the LLM to overlap server compute with client consumption.

4. Your RAG-augmented agent retrieves relevant chunks but its final answers still drop facts and occasionally invent citations. You want to improve retrieval quality and answer grounding without retraining the LLM. Select TWO interventions most likely to help.

   • Disable retrieval on borderline queries and let the LLM answer from its parametric knowledge alone, which is more recent than the indexed corpus.
   • Add a re-ranking stage (e.g., a cross-encoder or LLM-based reranker) after the initial vector recall step so the top-k documents passed to the LLM prioritize relevance over surface similarity.
   • Constrain the LLM with citation-aware prompting (e.g., "every claim must cite source X by id") and post-validate that every cited id appears in the retrieval context, rejecting outputs that fabricate sources.
   • Increase the chunk size to the maximum allowed by the retriever so each retrieved chunk contains as much context as possible, even if relevance per token drops.
   • Switch from BGE-style retrieval embeddings to the LLM's own input embedding layer so retrieval and generation use exactly the same vector space.

5. You are developing an agentic AI system that must process enterprise data from multiple client databases (SQL, NoSQL) and transform it into a uniform structure for reasoning. What is the most appropriate design pattern to implement this?

   • Rely on few-shot prompting with a handful of representative rows from each source so the agent infers the schema at runtime.
   • Directly embed raw database queries and their unstructured results into the agent's prompt at inference time.
   • Use a single SQL script to copy all data into in-memory tables that the agent can query through a SQL tool whenever needed.
   • Build a modular ETL pipeline to extract, clean, and normalize data from all sources.

6. You are designing a pipeline for a conversational agent that answers questions about IT incidents using real-time logs (unstructured) and CMDB (structured) data. What design best supports low-latency reasoning across both sources?

   • Periodically generate plain-text summaries of recent logs and store them in a CSV file that the agent reads on each query.
   • Rely only on CMDB data to avoid inconsistencies in log formats and time.
   • Use regex-based pattern matching on logs and ignore CMDB data, since structured asset metadata is rarely needed for incident triage.
   • Index both logs and CMDB in a unified vector database for hybrid semantic search.

7. A product team is enhancing a code-generation agent and wants to incorporate structured user feedback. Which method most effectively ensures that the feedback leads to meaningful, iterative agent improvements?

   • Limiting user inputs to a fixed allowlist of templated questions to reduce parser error rates.
   • Analyzing average token counts in user-agent interactions and using the trend as a proxy for engagement.
   • Gathering unstructured user comments from social media and review forums and treating raw sentiment as the primary signal.
   • Assigning numeric scores to generated outputs using expert reviewers.

8. Multiple specialized agents in your distributed system must coordinate asynchronously without tight coupling. Communication patterns must survive agent restarts, scale to bursty traffic, and let agents come online or go offline independently. Select TWO communication patterns that satisfy these constraints.

   • A shared in-memory dictionary held by a single coordinator process that all agents read from and write to via direct method calls.
   • A publish/subscribe topic model where agents subscribe to event types they care about and don't need direct knowledge of which other agents emit those events.
   • A durable message queue or event bus (e.g., RabbitMQ, NATS, Kafka) where producers and consumers are decoupled and messages persist until acknowledged.
   • Synchronous HTTP request/response calls between every pair of agents that share data, with retry-on-failure logic at the application layer.
   • Polling each agent's REST endpoint on a fixed interval to detect new state changes and propagating them through the orchestrator.

9. An organization is deploying an agentic AI system that automates sensitive decision-making tasks. Which of the following is the most appropriate practice to ensure both security and accountability in the system's operations?

   • Store all system logs in local memory for faster access
   • Allow all engineers unrestricted access to logs for faster debugging
   • Anonymize user inputs before storing them in the audit log
   • Implement role-based access control and immutable audit trails

10. Your agent must complete multi-step tasks with external tools (database lookups, API calls, email). The team is debating between a ReAct-style loop (think → act → observe per step) and a Plan-and-Execute pattern (plan all steps upfront, then execute). Select TWO statements that correctly characterize when each pattern is appropriate.

    • ReAct fits well when each step's action depends on the previous step's observation, because the model re-plans on the fly with the latest evidence in context.
    • Plan-and-Execute is the safer default because the upfront plan can be statically verified by a separate LLM before any tool is invoked.
    • ReAct should be avoided in production because it cannot be combined with structured tool-calling APIs offered by modern LLMs.
    • Plan-and-Execute fits well when the task is largely deterministic, parallelizable, and benefits from a single up-front plan that downstream steps can run without re-prompting the LLM.
    • ReAct is strictly faster than Plan-and-Execute because it issues one fused thought-and-action token sequence per step instead of separate planning and execution calls.