Courseiva

CCNA Implementation And Integration Questions

44 questions · Implementation And Integration · All types, answers revealed

Practice these questionsDomain overviewAll questions
1
MCQmedium

In SageMaker JumpStart, what is the primary advantage of selecting a 'Provisioned Throughput' option for a deployed model?

A.It automates the model fine-tuning process
B.It reduces the size of the model weights
C.It allows the model to access the internet
D.It ensures dedicated capacity for the endpoint
AnswerD

Provisioned Throughput reserves dedicated inference capacity for the endpoint, guaranteeing consistent performance regardless of other customers' traffic. This directly satisfies the stem's requirement for a primary advantage over on-demand hosting, where capacity is shared and throughput can be throttled under load.

Why this answer

Provisioned Throughput on a SageMaker JumpStart endpoint reserves dedicated inference capacity measured in Model Units, guaranteeing consistent latency and throughput regardless of other customers' traffic. It decouples your workload from shared on-demand capacity, which is critical for production workloads with steady or predictable traffic. This is the primary advantage over the default on-demand endpoint mode.

Exam trap

The trap here is conflating 'provisioned' with model-level optimizations like fine-tuning or quantization — the exam wants you to recognize it is purely an endpoint capacity guarantee.

How to eliminate wrong answers

Option A is wrong because fine-tuning is a separate SageMaker workflow (JumpStart fine-tuning or custom training jobs) and is not triggered by choosing Provisioned Throughput. Option B is wrong because provisioning affects compute allocation, not model artifact size — weights are unchanged. Option C is wrong because internet access is governed by VPC configuration and network isolation settings, not by the throughput mode of the endpoint.

Practice this question →
2
MCQeasy

Which AWS tool enables you to test different models side-by-side using the same prompt?

A.Amazon SageMaker Studio
B.Bedrock Playground
C.AWS Cloud9
D.AWS Lambda Console
AnswerB

Bedrock Playground provides a console interface where a single prompt can be submitted to multiple foundation models simultaneously, returning their outputs side-by-side for direct comparison. This satisfies the requirement to evaluate different models against identical input without writing orchestration code.

Why this answer

Amazon Bedrock Playground provides a dedicated interface where you can select multiple foundation models (e.g., Anthropic Claude, AI21 Labs Jurassic, Amazon Titan) and run the same prompt against them simultaneously, comparing outputs side-by-side. This is a built-in feature of the Bedrock console designed specifically for model evaluation and prompt experimentation. It eliminates the need to write code or manage infrastructure, allowing quick assessment of model performance, latency, and response quality.

Exam trap

AIP-C01 often tests the distinction between model evaluation tools and general ML development environments, so candidates might confuse SageMaker Studio's capabilities with Bedrock Playground's specialized side-by-side comparison feature.

How to eliminate wrong answers

Option A is wrong because Amazon SageMaker Studio is an integrated development environment (IDE) for machine learning that allows you to build, train, and deploy models, but it does not provide a native side-by-side comparison tool for foundation models using the same prompt without custom coding. Option C is wrong because AWS Cloud9 is a cloud-based IDE for writing and debugging code, not a tool for testing AI models side-by-side. Option D is wrong because AWS Lambda Console is for creating and managing serverless functions, and while you could invoke models programmatically, it lacks a built-in interface for side-by-side prompt testing.

Practice this question →
3
MCQeasy

When invoking models in Bedrock, what does the 'streaming' feature provide?

A.Support for larger context windows
B.Reduced latency until the first token appears
C.Higher model accuracy
D.Lower cost per invocation
AnswerB

Streaming returns tokens incrementally as the model generates them, so the first chunk reaches the caller almost immediately rather than after full completion. This directly satisfies the stem's latency constraint: time-to-first-token drops sharply, even though total generation time is unchanged.

Why this answer

Streaming in Amazon Bedrock returns the model's output incrementally as tokens are generated, rather than waiting for the full response. The primary benefit is reduced latency until the first token appears, improving perceived responsiveness for interactive applications. It does not change the model's accuracy, context window, or cost.

Exam trap

AIP-C01 often tests the misconception that streaming improves model accuracy or reduces cost, when its only real benefit is lower time-to-first-token and better perceived latency.

How to eliminate wrong answers

Option A is wrong because streaming does not increase the context window; the maximum input/output tokens are determined by the model's architecture and remain unchanged. Option C is wrong because streaming does not affect model accuracy; the same model weights and decoding process are used. Option D is wrong because streaming does not reduce cost per invocation; pricing is based on input and output tokens, which are the same whether streamed or not.

Practice this question →
4
MCQhard

You are using SageMaker JumpStart and need to enable 'Data Capture' for monitoring model inputs and outputs. Where is the captured data stored?

A.Amazon RDS
B.Amazon CloudWatch Logs
C.Amazon ElastiCache
D.Amazon S3
AnswerD

SageMaker Data Capture writes JSON Lines records to an Amazon S3 location you specify when enabling the endpoint's data capture configuration, satisfying the requirement to monitor model inputs and outputs. Captured requests and responses land under that prefix, so S3 is the storage destination rather than CloudWatch Logs.

Why this answer

When you enable Data Capture for a SageMaker endpoint (including JumpStart models), the captured data (inputs and outputs) is stored in an Amazon S3 bucket that you specify. This allows you to later analyze the data for monitoring, debugging, or retraining. CloudWatch Logs is used for logging but not for storing the captured data itself; the data capture feature writes to S3.

Exam trap

AIP-C01 often tests the confusion between CloudWatch Logs and S3 for data capture, but the exam expects candidates to know that SageMaker Data Capture stores data in S3, not CloudWatch.

How to eliminate wrong answers

Option A is wrong because Amazon RDS is a relational database service, not used for storing data capture output from SageMaker; it is not integrated with SageMaker Data Capture. Option B is wrong because Amazon CloudWatch Logs is for log storage and monitoring, but SageMaker Data Capture specifically writes to S3, not CloudWatch Logs. Option C is wrong because Amazon ElastiCache is an in-memory caching service, not a storage service for captured data; it is unrelated to SageMaker Data Capture.

Practice this question →
5
MCQhard

You are integrating a SageMaker JumpStart model via the InvokeEndpoint API. The model is failing to process images due to a schema mismatch. Which format does the JumpStart image input expect by default for standard vision models?

A.Base64 encoded string in the JSON input field
B.A URL pointing to an S3 object
C.Multi-part form data
D.Raw binary stream in the request body
AnswerA

SageMaker JumpStart vision models expect image bytes serialised as a Base64 encoded string within the JSON input field, not raw binary or a URL. Supplying the image in that encoding resolves the schema mismatch at InvokeEndpoint.

Why this answer

SageMaker JumpStart vision models (e.g., image classification, object detection) expect the input image to be Base64-encoded and placed in the JSON payload under the appropriate input field (commonly 'image' or 'data'). The InvokeEndpoint API sends JSON, so raw binary cannot be transmitted directly. The model's inference container decodes the Base64 string back to bytes before preprocessing.

Exam trap

AIP-C01 often tests the assumption that JumpStart endpoints accept S3 URLs or raw binary; the default schema requires Base64-encoded JSON, and candidates who assume otherwise pick the wrong format.

How to eliminate wrong answers

Option B is wrong because JumpStart vision endpoints do not accept an S3 URL as input; the caller must fetch the object and encode it. Option C is wrong because InvokeEndpoint uses a JSON body, not multipart/form-data, for standard JumpStart models. Option D is wrong because raw binary streams are not supported by the default JumpStart inference container — the payload must be JSON with a Base64-encoded image field.

Practice this question →
6
MCQhard

You notice your SageMaker endpoint is underperforming. You identify that the model is CPU-bound during inference. Which action should you take?

A.Reduce the batch size
B.Increase memory limit in the container
C.Increase the number of instances (horizontal scaling)
D.Change to an instance type optimized for compute
AnswerD

Switching to a compute-optimised instance type directly addresses the CPU-bound constraint by providing a higher ratio of vCPU to memory, such as the C-family. This supplies the processing capacity the model needs during inference, relieving the bottleneck that general-purpose instances impose.

Why this answer

If the model is CPU-bound during inference, the bottleneck is compute, not memory or instance count. Moving to a compute-optimized instance family (e.g., C-series) provides more vCPU per dollar and higher clock speeds, directly relieving the CPU saturation. This is the targeted fix for a CPU-bound workload.

Exam trap

AIP-C01 often tests whether candidates default to horizontal scaling for any performance issue — the trap is missing that a CPU-bound single-instance bottleneck calls for a compute-optimized instance type, not more instances.

How to eliminate wrong answers

Option A is wrong because reducing batch size lowers throughput and does not address the underlying CPU saturation — it may even worsen per-request efficiency. Option B is wrong because adding memory does not help a CPU-bound workload; memory helps memory-bound workloads (e.g., large model weights, KV cache pressure). Option C is wrong because horizontal scaling adds more instances but each instance is still CPU-starved — it multiplies cost without fixing the per-instance bottleneck, and is the wrong first move when a vertical instance-type change is available.

Practice this question →
7
MCQmedium

Which prompt engineering technique involves providing the model with a few examples of desired input-output pairs to guide the generation?

A.Chain-of-thought
B.Few-shot prompting
C.System priming
D.Zero-shot prompting
AnswerB

Few-shot prompting embeds a small set of exemplar input-output pairs directly in the prompt, letting the model infer the task pattern through in-context learning without weight updates. This satisfies the stem's requirement for guiding generation via demonstrated examples rather than instructions alone.

Why this answer

Few-shot prompting is the technique of including a small number of example input-output pairs in the prompt to demonstrate the desired task and format, guiding the model to generalize to the new input. This contrasts with zero-shot, where no examples are given. The examples act as in-context learning signals.

Exam trap

AIP-C01 often tests the confusion between few-shot prompting (providing examples) and chain-of-thought (eliciting reasoning steps), or between few-shot and zero-shot, by describing example-based guidance.

How to eliminate wrong answers

Option A is wrong because Chain-of-thought prompting encourages the model to produce intermediate reasoning steps (often with 'Let's think step by step') rather than providing input-output examples. Option C is wrong because 'System priming' is not a standard prompt engineering term; system prompts set persona/instructions but are not defined by providing example pairs. Option D is wrong because Zero-shot prompting provides no examples at all, relying solely on the instruction.

Practice this question →
8
MCQmedium

What is the primary benefit of deploying a JumpStart model on a Multi-Model Endpoint (MME)?

A.It improves inference latency for a single model
B.It simplifies the model training process
C.It optimizes resource utilization by hosting multiple models
D.It provides higher availability than single-model endpoints
AnswerC

A Multi-Model Endpoint hosts several models behind shared inference containers, loading them on demand from Amazon S3. Deploying a JumpStart model this way avoids provisioning a dedicated endpoint per model, satisfying the resource utilisation constraint by sharing compute across hosted models.

Why this answer

A Multi-Model Endpoint hosts multiple models behind a single endpoint and dynamically loads/unloads them into shared container memory on demand. The primary benefit is resource utilization: you avoid provisioning a separate endpoint per model, so many low-traffic models share one instance's CPU/GPU and memory. This is the defining advantage of MME over single-model endpoints.

Exam trap

AIP-C01 often tests whether candidates attribute latency or availability benefits to MME — the trap is picking a plausible operational benefit instead of the actual cost/resource-utilization advantage of sharing one endpoint across many models.

How to eliminate wrong answers

Option A is wrong because MME does not improve single-model latency — in fact, model load time on first invocation can add latency (cold start) compared to an always-loaded single-model endpoint. Option B is wrong because MME is a hosting/deployment feature and has nothing to do with training. Option D is wrong because MME does not inherently provide higher availability than a single-model endpoint; availability depends on instance count, multi-AZ deployment, and autoscaling, not on the multi-model packaging.

Practice this question →
9
Multi-Selectmedium

Which THREE features are provided by Amazon Bedrock Guardrails?

Select 3 answers
A.Automatic Model Fine-tuning
B.Real-time cost optimization
C.Content Filtering
D.Denied Topic Management
E.Sensitive Information Filtering
AnswersC, D, E

Content filtering evaluates prompts and responses against configurable harmful-category thresholds, such as hate, violence and sexual content, and blocks them when exceeded. This satisfies the question's requirement for a guardrail capability that screens model input and output for harmful material.

Why this answer

Amazon Bedrock Guardrails provides Content Filtering (C), which lets you configure thresholds to block harmful categories such as hate, violence, sexual, insults, and misconduct in both prompts and responses. It also supports Denied Topic Management (D), allowing you to define custom topics with natural-language descriptions that the guardrail blocks when detected in inputs or outputs. Additionally, it offers Sensitive Information Filtering (E), which detects and masks or blocks PII and custom regex-defined sensitive data using the sensitive information policy.

Automatic Model Fine-tuning (A) is not a Guardrails feature; fine-tuning in Bedrock is a separate model customization capability. Real-time cost optimization (B) is also not provided by Guardrails, as Guardrails focuses on safety and content controls rather than cost management.

Exam trap

The trap is that 'automatic model fine-tuning' and 'cost optimization' sound like platform-level governance features, so candidates who do not know the exact Guardrails scope pick them instead of the three content/topic/PII controls.

Practice this question →
10
Multi-Selectmedium

You are designing an Agentic AI solution using Bedrock Agents. Which THREE components must you configure to enable the agent to interact with an external API?

Select 3 answers
A.Knowledge Base
B.Action Group
C.OpenAPI Schema
D.Lambda Function
E.Guardrail
AnswersB, C, D

An action group defines the API operations the agent may invoke, including the OpenAPI schema describing parameters and the Lambda function that fulfils each call. It is the required binding that lets Bedrock Agents interact with the external API.

Why this answer

Option B (Action Group) is correct because an action group is the Bedrock Agents construct that defines the set of tasks the agent can invoke against external APIs, binding the agent's reasoning to concrete operations. Option C (OpenAPI Schema) is correct because the action group requires an OpenAPI schema (API schema) that describes the external API's endpoints, parameters, and request/response structures so the agent knows how to call it. Option D (Lambda Function) is correct because the action group must be backed by an executor — typically an AWS Lambda function — that receives the agent's invocation and performs the actual API call to the external service.

Option A (Knowledge Base) is not required here because knowledge bases are for retrieval-augmented generation over documents/data, not for invoking external APIs. Option E (Guardrail) is not required because guardrails enforce content safety and policy filtering, which is unrelated to enabling API interaction.

Exam trap

AIP-C01 often tests whether candidates confuse Knowledge Bases (RAG/document retrieval) with Action Groups (API/tool invocation), causing them to select Knowledge Base as a required component for external API interaction.

Practice this question →
11
MCQeasy

A developer is using Amazon Bedrock to generate product descriptions. The application calls the InvokeModel API with the Anthropic Claude model. The developer needs to ensure that the model's responses are deterministic and do not vary between identical prompts. Which parameter should be adjusted in the request body?

A.Increase the max_tokens parameter.
B.Set the temperature parameter to 0.
C.Set the top_p parameter to 1.
D.Set the stop_sequences parameter to an empty list.
AnswerB

Setting temperature to 0 makes the model's output more deterministic by reducing randomness in token selection. While not perfectly deterministic due to floating-point operations, it is the primary parameter to control variability. This is the correct adjustment for consistent responses across identical prompts.

Why this answer

Temperature controls the randomness of the model's output. A temperature of 0 makes the model select the most likely next token at each step, leading to more consistent and repeatable responses. While other parameters like top_p also affect sampling, temperature is the primary and most direct control for determinism in Amazon Bedrock's InvokeModel API.

Exam trap

The trap here is confusing top_p with temperature, or thinking that top_p=1 reduces randomness when it actually allows all tokens and increases variability.

Practice this question →
12
Multi-Selectmedium

When designing a prompt for a coding assistant, which THREE pieces of information should be included to get the best results?

Select 3 answers
A.Frameworks or libraries to be used
B.The programming language
C.The AWS account ID
D.Specific formatting requirements
E.The model's internal parameter count
AnswersA, B, D

Naming the frameworks or libraries constrains the assistant to idiomatic APIs and imports rather than generic standard-library substitutes, so generated code integrates with the project's existing dependencies — one of the three prompt elements the stem requires for best results.

Why this answer

Option A (frameworks or libraries to be used) is correct because specifying the exact frameworks or libraries (e.g., React, Django, Spring Boot) constrains the assistant to generate idiomatic code and APIs that match the intended stack, avoiding incompatible or generic solutions. Option B (the programming language) is correct because the language (e.g., Python, TypeScript, Go) determines syntax, standard library usage, and runtime behavior, so naming it prevents the assistant from guessing and producing code in the wrong language. Option D (specific formatting requirements) is correct because stating formatting constraints such as PEP 8, ESLint rules, indentation style, or output structure ensures the generated code conforms to project standards and is directly usable.

Option C (the AWS account ID) is not relevant to prompt design for a coding assistant, since it is an environment-specific identifier that does not influence code generation. Option E (the model's internal parameter count) is not something a prompt author controls or needs to specify, as it describes the underlying model architecture rather than the task requirements.

Exam trap

AIP-C01 often tests the temptation to include irrelevant technical details like account IDs or model size; the exam expects you to recognize that language, frameworks, and formatting are the key prompt components for coding tasks.

Practice this question →
13
MCQhard

You are deploying a model from SageMaker JumpStart. You need to ensure that the model inference container has access to private VPC resources. What must you configure?

A.Configure Subnets and Security Groups in the Model creation
B.Set the IAM role to 'AdministratorAccess'
C.Update the JumpStart model Dockerfile
D.Enable AWS PrivateLink on the S3 bucket
AnswerA

Specifying subnets and security groups during model creation places the inference container's network interfaces inside the VPC, giving it private connectivity and the correct security group rules. Without this configuration, the endpoint cannot reach private VPC resources.

Why this answer

You must configure the VPC settings (Subnets and Security Groups) in the SageMaker Model configuration to allow network access.

Practice this question →
14
MCQeasy

When using the Amazon Bedrock Converse API, which parameter enables the model to perform tool use by providing a definition of available functions?

A.inferenceConfig
B.toolConfig
C.system
D.additionalModelRequestFields
AnswerB

toolConfig is the correct parameter to define tools.

Why this answer

The tools parameter in the Converse API allows you to define a list of tools for the model to use.

Practice this question →
15
MCQeasy

Which Bedrock API parameter allows you to define a system-level role or persona for the model?

A.system
B.messages
C.top_p
D.temperature
AnswerA

The system parameter supplies a system-level instruction that establishes the model's role or persona before user turns are processed. It satisfies the requirement to define persona at the API level, distinct from user messages and other inference configuration parameters.

Why this answer

The 'system' parameter in the Bedrock Converse API (and related APIs) allows you to define a system-level instruction or persona for the model, such as 'You are a helpful customer service agent.' This system prompt is processed separately from user messages and sets the model's behavior, tone, and constraints for the entire conversation. It is the correct parameter for defining a system-level role or persona.

Exam trap

The trap is confusing inference configuration parameters (temperature, top_p) with structural parameters (system, messages) — candidates must know that persona definition is a system-level instruction, not a sampling setting.

How to eliminate wrong answers

Option B is wrong because 'messages' is the parameter that contains the conversation history (user and assistant turns), not the system-level persona definition — system instructions are passed separately in the 'system' field. Option C is wrong because 'top_p' is a sampling parameter (nucleus sampling) that controls the diversity of the model's output by limiting token selection to a cumulative probability threshold, unrelated to persona definition. Option D is wrong because 'temperature' is a sampling parameter that controls randomness in generation, not the model's role or system-level instructions.

Practice this question →
16
MCQhard

A company is deploying a generative AI application on AWS that uses Amazon Bedrock to generate product descriptions. The application must ensure that the generated text does not contain any personally identifiable information (PII) or offensive content. The security team requires that all generated content be automatically scanned and filtered before being stored in Amazon S3. Which AWS service or feature should be integrated into the application pipeline to meet these requirements?

A.Amazon Macie
B.Amazon Comprehend
C.Amazon Bedrock Guardrails
D.AWS Lambda with custom regex patterns
AnswerC

Amazon Bedrock Guardrails is a feature that allows you to define policies to filter and moderate content generated by Bedrock models. It can detect and block PII, hate speech, violence, and other unwanted content. It integrates directly with Bedrock APIs, making it the appropriate choice to automatically scan and filter generated text before storage.

Why this answer

Amazon Bedrock Guardrails is purpose-built to apply safeguards to generative AI outputs, including PII redaction and content filtering. It integrates seamlessly with Bedrock, allowing automatic scanning and blocking of undesired content before it is stored or returned. Other services like Comprehend, Lambda, or Macie are not designed for this real-time, integrated filtering within the Bedrock workflow.

Exam trap

The trap here is confusing data-at-rest scanning services like Macie or general NLP services like Comprehend with the specialized, integrated content filtering provided by Bedrock Guardrails.

Practice this question →
17
Multi-Selecthard

Which THREE factors influence the choice of embedding model for a RAG solution?

Select 3 answers
A.Model's popularity
B.Supported languages
C.Maximum input token length
D.Model training cost
E.Embedding dimensionality
AnswersB, C, E

Supported languages matter because the corpus and queries may not be English; a model trained only on English produces poor vectors for other languages, degrading retrieval accuracy. Multilingual coverage must match the content being indexed.

Why this answer

Language support, embedding dimensions, and maximum input token length are key factors.

Practice this question →
18
Multi-Selecthard

Which THREE of these are valid methods for monitoring a Bedrock-based application?

Select 3 answers
A.Direct access to model training logs
B.AWS CloudTrail for API calls
C.Application-level logging of requests
D.Manual binary inspection
E.Amazon CloudWatch Metrics
AnswersB, C, E

CloudTrail records Bedrock API invocations such as InvokeModel, capturing caller identity, timestamp and request parameters. This satisfies the monitoring requirement by providing an audit trail of who called which model and when, supporting security investigation and compliance.

Why this answer

Option B is correct because AWS CloudTrail captures Bedrock API activity (e.g., InvokeModel, Converse calls) as management and data events, enabling auditing of who called which model and when. Option C is correct because application-level logging lets you record request/response metadata, latency, token usage, and errors from your own code, which is essential for monitoring Bedrock-based applications. Option E is correct because Amazon CloudWatch Metrics provides runtime metrics such as invocation counts, latency, and error rates for Bedrock, and can drive alarms and dashboards.

Option A is not valid because Bedrock does not expose model training logs to customers; it is a managed service and training data/logs are not directly accessible. Option D is not valid because manual binary inspection is not a monitoring method for a Bedrock application and provides no operational telemetry.

Exam trap

AIP-C01 often tests whether candidates confuse managed-service observability with self-hosted ML tooling — assuming you can reach training logs or model internals on Bedrock, which you cannot.

Practice this question →
19
MCQeasy

A developer is using Amazon Bedrock to build a chatbot that can answer questions about a company's internal documents. The developer needs to implement a retrieval-augmented generation (RAG) workflow. Which AWS service should be used to store document embeddings and perform similarity search?

A.Amazon DynamoDB
B.Amazon OpenSearch Serverless with vector engine
C.Amazon RDS for PostgreSQL
D.Amazon S3 with Glacier Deep Archive
AnswerB

Amazon OpenSearch Serverless supports vector search through its vector engine, which is designed to store and query embeddings for similarity search. It integrates with Bedrock Knowledge Bases, making it a suitable choice for RAG workflows. It provides scalable, low-latency vector search without managing infrastructure.

Why this answer

Amazon OpenSearch Serverless includes a vector engine specifically designed for storing and querying embeddings, making it ideal for RAG applications. It integrates with Amazon Bedrock Knowledge Bases to provide managed retrieval. Other options like RDS, DynamoDB, or S3 lack native vector search capabilities or are not optimized for this purpose.

Exam trap

The trap here is assuming that any database can store vectors or that S3 can be used directly for similarity search, overlooking the need for a specialized vector store.

Practice this question →
20
MCQmedium

When using Bedrock Knowledge Bases, which vector database is integrated natively to support managed RAG workflows?

A.Amazon OpenSearch Serverless
B.Amazon DynamoDB
C.Amazon ElastiCache
D.Amazon RDS for PostgreSQL
AnswerA

Amazon OpenSearch Serverless is the vector store natively integrated with Bedrock Knowledge Bases, providing managed vector indexing and similarity search without separate provisioning. This satisfies the managed RAG requirement by removing manual database administration from the retrieval pipeline.

Why this answer

Amazon Bedrock Knowledge Bases natively integrates with Amazon OpenSearch Serverless as its managed vector store, allowing RAG workflows to be set up without provisioning or managing vector database infrastructure. OpenSearch Serverless provides the vector search collection type that Bedrock uses to store and retrieve embeddings during retrieval-augmented generation. This native integration means customers can point Bedrock at an OpenSearch Serverless vector index and have chunking, embedding, and retrieval handled automatically.

Exam trap

AIP-C01 often tests whether candidates confuse general-purpose AWS data stores (DynamoDB, RDS, ElastiCache) with the specific managed vector store that Bedrock Knowledge Bases integrates natively, which is Amazon OpenSearch Serverless.

How to eliminate wrong answers

Option B is wrong because DynamoDB is a key-value/document NoSQL database and, while it supports vector search in preview via some integrations, it is not the natively integrated managed vector store for Bedrock Knowledge Bases. Option C is wrong because ElastiCache is an in-memory caching service (Redis/Memcached) used for low-latency caching, not a persistent vector database for RAG embeddings. Option D is wrong because RDS for PostgreSQL can host pgvector, but it is not the natively integrated managed vector database that Bedrock Knowledge Bases provisions and manages out of the box.

Practice this question →
21
Multi-Selecthard

Which THREE tasks are performed by a Bedrock Agent when an Action Group is invoked?

Select 3 answers
A.Mapping intent to an API definition
B.Interpreting user natural language intent
C.Automatically scaling the API endpoint
D.Invoking the defined Lambda function
E.Retraining the model on new data
AnswersA, B, D

The agent uses the Action Group's OpenAPI schema to map the user's interpreted intent onto a specific API operation, selecting the correct path and parameters before orchestration. This schema-driven mapping is the step that converts understood intent into a concrete, invocable API definition.

Why this answer

When a Bedrock Agent invokes an Action Group, it first interprets the user's natural language intent (B) to understand what the user is asking for, using the foundation model's reasoning over the conversation and the action group's description. It then maps that intent to an API definition (A), matching the identified intent to the specific operation, path, and parameters declared in the OpenAPI schema of the action group. Finally, the agent invokes the defined Lambda function (D) that backs the action group, passing the extracted parameters so the business logic can execute and return a result to the agent.

Options C and E are incorrect because automatic scaling of the API endpoint is handled by the underlying compute service (e.g., Lambda or API Gateway), not by the Bedrock Agent, and the agent does not retrain the foundation model on new data as part of action group invocation.

Exam trap

AIP-C01 often tests whether candidates conflate the agent's reasoning/action-invocation responsibilities with unrelated operational tasks like endpoint scaling or model retraining, which are not part of Action Group invocation.

Practice this question →
22
Multi-Selecthard

Which THREE configurations must be set correctly within a Knowledge Base 'Data Source' for Bedrock to ingest documents from Amazon S3?

Select 3 answers
A.IAM Role with S3 read permissions
B.Model ID of the generative model
C.Database write timeout
D.Chunking Strategy
E.S3 Bucket Path
AnswersA, D, E

Bedrock assumes an IAM role to read objects from the S3 bucket. The role's trust policy must allow Bedrock, and its permissions policy must grant s3:GetObject and s3:ListBucket. Without these S3 read permissions, ingestion fails authorisation and no documents are indexed.

Why this answer

Option A is correct because the Knowledge Base data source requires an IAM service role that grants Amazon Bedrock permission to read the source objects from Amazon S3 (e.g., s3:GetObject and s3:ListBucket), without which ingestion fails. Option D is correct because the chunking strategy (default, fixed-size, hierarchical, semantic, or no chunking) is a required data source configuration that determines how documents are split before embedding. Option E is correct because the S3 bucket path (the s3:// URI prefix) tells the data source exactly which bucket and prefix to crawl for documents.

Option B is not part of the data source configuration—the model ID is selected when creating or querying the Knowledge Base, not when defining the S3 data source. Option C is irrelevant; there is no 'database write timeout' setting in a Bedrock S3 data source configuration.

Exam trap

The trap is that candidates see 'Model ID' and assume the embedding or generation model must be specified on the data source, when in fact the model is chosen at the Knowledge Base level and the data source only needs path, role, and chunking.

Practice this question →
23
MCQmedium

In the context of Bedrock Agents, what is the purpose of the 'Instruction' field in the agent configuration?

A.It defines the Knowledge Base search parameters
B.It serves as the system prompt to define the agent's behavior
C.It stores user credentials for the API
D.It contains the list of API definitions
AnswerB

The Instruction field supplies the agent's system prompt, directly shaping how the foundation model interprets requests and selects actions across orchestration steps. This satisfies the stem's requirement to define agent behaviour, since it establishes the persistent role, tone and task boundaries that govern every subsequent reasoning cycle.

Why this answer

The instruction field serves as the system prompt that defines the agent's persona and objective.

Practice this question →
24
MCQhard

You are monitoring your Bedrock usage costs. You notice a spike in costs despite the number of requests remaining steady. What is the most likely cause?

A.The number of users has increased
B.The model has been upgraded to a newer version
C.The token count per request has increased
D.The regional data transfer cost has increased
AnswerC

Bedrock charges per input and output token, so a steady request count with rising cost indicates larger prompts or responses. The increased token count per request is the mechanism driving the spike, satisfying the observation that request volume stayed constant.

Why this answer

The most likely cause of increased Bedrock costs with steady request volume is an increase in the token count per request. Bedrock pricing is based on the number of input and output tokens processed, so if each request now uses more tokens (e.g., longer prompts or responses), costs will rise even if the number of requests remains constant.

Exam trap

AIP-C01 often tests cost factors for AI services, and candidates may overlook token count as a primary cost driver, instead attributing cost spikes to user count or model changes.

How to eliminate wrong answers

Option A is wrong because an increase in users would typically increase the number of requests, but the scenario states requests are steady. Option B is wrong because upgrading to a newer model might change pricing, but it is not the most likely cause given steady requests; token count is a more direct factor. Option D is wrong because regional data transfer costs are typically separate and not the primary driver of Bedrock usage costs; Bedrock charges are based on tokens, not data transfer.

Practice this question →
25
MCQeasy

Which parameter in Bedrock inference controls the deterministic nature of the output?

A.Temperature
B.Top_p
C.Max_tokens
D.Stop_sequences
AnswerA

Temperature scales the probability distribution over tokens before sampling; lower values sharpen it toward the highest-probability token, producing near-deterministic output. It is the parameter that directly governs randomness, unlike top-p or token limits, which affect breadth or length rather than determinism.

Why this answer

Temperature is the Bedrock inference parameter that directly controls the randomness or determinism of the model's output. Setting temperature to 0 makes the model select the highest-probability token at each step, producing near-deterministic and repeatable responses. Higher values (up to 1) flatten the probability distribution, increasing creativity and variability.

Exam trap

AIP-C01 often tests the confusion between temperature and top_p as if they were interchangeable randomness controls, when only temperature directly governs determinism.

How to eliminate wrong answers

Option B is wrong because Top_p (nucleus sampling) limits the token pool to a cumulative probability threshold, but it still samples randomly within that pool, so it does not by itself guarantee determinism. Option C is wrong because Max_tokens only caps the number of tokens generated, not the randomness of token selection. Option D is wrong because Stop_sequences merely define strings that terminate generation; they have no effect on the probability distribution used to pick tokens.

Practice this question →
26
MCQmedium

You are designing a RAG pipeline. Which step in the ingestion process is responsible for converting unstructured text into a numerical representation?

A.Chunking
B.Embedding
C.Indexing
D.Parsing
AnswerB

Embedding converts unstructured text into dense numerical vectors, which is exactly the transformation the ingestion pipeline needs before storing them in a vector database for retrieval. Chunking, parsing and enrichment preserve or structure text but do not produce the numerical representation required.

Why this answer

Embedding is the step that converts text chunks into dense numerical vectors (embeddings) that capture semantic meaning. These vectors are then stored in a vector database so that similarity search can retrieve relevant chunks at query time. Without embedding, the RAG pipeline cannot perform semantic retrieval.

Exam trap

AIP-C01 often tests whether candidates confuse the ingestion pipeline stages — specifically conflating embedding (vector creation) with indexing (vector storage) or chunking (text splitting).

How to eliminate wrong answers

Option A is wrong because chunking splits large documents into smaller text segments — it operates on text, not numerical representations, and produces text chunks that are then passed to the embedding model. Option C is wrong because indexing stores the already-generated embeddings (and optionally metadata) into a vector store for efficient nearest-neighbor search; it does not create the numerical representation itself. Option D is wrong because parsing extracts raw text from source formats (PDF, HTML, DOCX) and converts them into plain text — it is a preprocessing step that occurs before chunking and embedding.

Practice this question →
27
MCQmedium

An application uses Amazon Bedrock InvokeModel to generate text. You notice that the output length is consistently truncated. Which parameter should you adjust to ensure the full response is captured?

A.Increase the max_tokens parameter
B.Increase the temperature parameter
C.Increase the top_p parameter
D.Decrease the stop_sequences parameter
AnswerA

max_tokens caps the number of tokens generated in the response; raising it allows longer output before the model stops. Truncation occurs because generation halts at that limit, so increasing the value directly satisfies the requirement to capture the full response.

Why this answer

In Amazon Bedrock InvokeModel, the max_tokens parameter (or its model-specific equivalent like max_gen_len) controls the maximum number of tokens the model can generate in the response. If output is consistently truncated, increasing max_tokens allows the model to produce a longer completion. The other parameters affect randomness or stopping criteria, not the length cap.

Exam trap

AIP-C01 often tests the confusion between parameters that control length (max_tokens) and those that control randomness (temperature, top_p) — candidates may pick temperature thinking it affects output size.

How to eliminate wrong answers

Option B is wrong because temperature controls randomness/creativity, not output length; increasing it makes output more varied but does not prevent truncation. Option C is wrong because top_p (nucleus sampling) also controls randomness by limiting the token pool, not the maximum length. Option D is wrong because decreasing stop_sequences would actually make truncation worse or have no effect — stop_sequences define strings that halt generation, and reducing them would not increase length.

Practice this question →
28
MCQeasy

When invoking a Bedrock model via the API, which HTTP status code indicates that the request was processed, but the model has reached its rate limit?

A.500 Internal Server Error
B.400 Bad Request
C.429 Too Many Requests
D.200 OK
AnswerC

HTTP 429 signals that the request was received and understood but rejected because the caller exceeded the model's rate limit. Other 4xx codes indicate malformed or unauthorised requests, not throttling, so 429 is the throttling response.

Why this answer

The 429 Too Many Requests status code is the standard HTTP response for rate limiting, indicating the request was valid but the model's throughput quota has been exceeded. In Amazon Bedrock, this occurs when you surpass the provisioned throughput or the default quota for a model, and the service throttles the request. The API returns 429 to signal that the client should back off and retry later, often with a Retry-After header.

This is distinct from client errors (4xx) or server errors (5xx) because the request itself is well-formed and could succeed if not for the rate limit.

Exam trap

AIP-C01 often tests the distinction between client errors (4xx) and server errors (5xx), and candidates may confuse 429 with 500 or 400 because they think 'rate limit' is a server issue or a bad request.

How to eliminate wrong answers

Option A is wrong because 500 Internal Server Error indicates an unexpected condition on the server side, not a rate limit; it suggests a service failure rather than throttling. Option B is wrong because 400 Bad Request means the request is malformed or invalid (e.g., missing parameters, invalid JSON), not that the model is rate-limited. Option D is wrong because 200 OK indicates successful processing and a normal response, which would not occur if the rate limit was reached; a 200 would mean the request was served, not throttled.

Practice this question →
29
MCQmedium

What is the primary role of an 'Embeddings Model' in a RAG-based Generative AI application?

A.To generate the final natural language answer
B.To convert input text into high-dimensional numerical vectors
C.To store document chunks for long-term retrieval
D.To parse PDF files into plain text
AnswerB

An embeddings model maps text into dense high-dimensional vectors so semantically similar content sits close together in vector space. This enables the retriever to find relevant passages by similarity search, grounding the generative model's response in retrieved context rather than parametric memory alone.

Why this answer

An embeddings model in a RAG application converts input text (queries and document chunks) into high-dimensional numerical vectors that capture semantic meaning. These vectors are stored in a vector database and used for similarity search to retrieve relevant context for the LLM.

Exam trap

AIP-C01 often tests the confusion between the embeddings model (vectorization) and the LLM (generation) — candidates may incorrectly assign answer generation to the embeddings model.

How to eliminate wrong answers

Option A is wrong because generating the final answer is the job of the large language model (LLM), not the embeddings model. Option C is wrong because storing document chunks is the role of a vector database or document store, not the embeddings model itself. Option D is wrong because parsing PDFs into text is a preprocessing step typically handled by document loaders or OCR tools, not by an embeddings model.

Practice this question →
30
MCQhard

You are attempting to use a Bedrock Agent to query an internal database, but the agent constantly fails to understand the schema. What is the best way to improve the agent's performance?

A.Improve the OpenAPI schema documentation
B.Increase the agent's timeout
C.Use a Knowledge Base to store the schema
D.Upgrade the agent model
AnswerA

The OpenAPI schema is the contract the agent reads to map natural-language requests onto database operations. Clearer descriptions, parameter definitions and examples let the agent interpret the schema correctly, resolving the persistent misunderstanding of the internal database structure.

Why this answer

Bedrock Agents rely on the OpenAPI schema to understand the available actions and their parameters. If the schema is poorly documented—missing descriptions, ambiguous parameter names, or incorrect types—the agent cannot correctly map user intent to API calls. Improving the schema documentation (e.g., adding clear descriptions, examples, and proper types) directly enhances the agent's ability to interpret and invoke the API, leading to better performance.

Exam trap

AIP-C01 often tests the misconception that increasing timeout or upgrading the model can compensate for poor API definitions, but the exam expects candidates to recognize that the OpenAPI schema is the foundation for agent action groups.

How to eliminate wrong answers

Option B is wrong because increasing the agent's timeout only affects how long the agent waits for a response, not its understanding of the schema; it does not address the root cause of misinterpretation. Option C is wrong because a Knowledge Base stores unstructured data for retrieval, not API schemas; while it can provide context, it does not replace the need for a well-defined OpenAPI schema for action groups. Option D is wrong because upgrading the model may improve general language understanding but will not fix a poorly defined schema; the agent still needs accurate API specifications to function correctly.

Practice this question →
31
MCQhard

A generative AI application uses Amazon Bedrock Agents to automate customer support tasks. The agent must query an internal knowledge base and also call a proprietary REST API to check order status. The order status API requires an API key that must be rotated every 30 days without redeploying the agent. Which solution allows the agent to securely authenticate to the API while meeting the rotation requirement?

A.Store the API key in an AWS Lambda environment variable and update the environment variable when rotating the key. The agent's action group invokes the Lambda function, which reads the key from the environment variable.
B.Embed the API key directly in the OpenAPI schema of the action group. When the key rotates, update the action group schema in the Bedrock agent.
C.Use AWS Systems Manager Parameter Store with a SecureString parameter to store the API key. Configure the agent to read the parameter directly from Parameter Store at invocation time.
D.Store the API key in AWS Secrets Manager and configure automatic rotation every 30 days. Create a Lambda function that retrieves the secret at runtime and uses it to call the order status API. The agent's action group invokes this Lambda function.
AnswerD

AWS Secrets Manager supports automatic rotation of secrets using a Lambda rotation function. The agent's action group can invoke a Lambda function that retrieves the current secret value at runtime, so the agent always uses the latest key without redeployment. This meets the rotation requirement and keeps the key secure and centralized.

Why this answer

AWS Secrets Manager provides built-in automatic rotation for secrets, including API keys, using a Lambda rotation function. By having the Bedrock agent's action group invoke a Lambda function that retrieves the secret at runtime, the agent always uses the current key without requiring any changes to the agent configuration. This satisfies both security and the 30-day rotation requirement with minimal operational overhead.

Exam trap

The trap here is assuming that Lambda environment variables or Parameter Store can automatically rotate secrets, or that embedding keys in the OpenAPI schema is acceptable for production.

Practice this question →
32
MCQeasy

When using the Bedrock Converse API, which object allows you to maintain context across multiple turns of a conversation?

A.inferenceConfig
B.additionalModelRequestFields
C.messages
D.system
AnswerC

The `messages` array carries the full conversation history, with each turn's user and assistant content, so the model receives prior context on every Converse API call. This directly satisfies the requirement to maintain context across multiple turns, unlike single-shot parameters such as `system` or inference configuration.

Why this answer

The Bedrock Converse API uses the `messages` array to hold the full conversation history, including alternating user and assistant turns. Each turn is represented as a message with a role and content, and by passing the entire array on subsequent calls, the model can see prior context. This is the standard mechanism for multi-turn conversations, as it explicitly maintains state across requests.

Exam trap

AIP-C01 often tests the distinction between configuration parameters and conversation state, so candidates might confuse `inferenceConfig` or `system` with the mechanism for maintaining context, overlooking that `messages` is the only field that carries the dialogue history.

How to eliminate wrong answers

Option A is wrong because `inferenceConfig` controls generation parameters like temperature, topP, and maxTokens, not conversation history. Option B is wrong because `additionalModelRequestFields` is used to pass model-specific parameters that are not part of the standard Converse API, such as top_k or guardrail configurations, and does not store conversation turns. Option D is wrong because `system` provides a system prompt that sets the model's behavior or persona, but it does not maintain context across multiple turns; it is static per request.

Practice this question →
33
Multi-Selectmedium

Which THREE techniques are commonly used to mitigate hallucinations in RAG applications?

Select 3 answers
A.Adding 'I don't know' as a fallback response
B.Using the longest possible output token limit
C.Requiring the model to provide citations
D.Instructing the model to only answer based on provided context
E.Increasing the inference temperature
AnswersA, C, D

A grounded fallback directly satisfies the requirement to mitigate hallucination: when retrieved context lacks sufficient evidence, the model returns "I don't know" instead of fabricating an answer. This constrains generation to the retrieved passages, preventing unsupported claims when retrieval confidence is low.

Why this answer

Option A is correct because explicitly allowing an 'I don't know' fallback gives the model a safe, grounded escape when retrieved context lacks the answer, reducing the incentive to fabricate. Option C is correct because requiring citations forces the model to tie each claim to specific retrieved passages, making unsupported statements detectable and discouraging invented facts. Option D is correct because instructing the model to answer only from the provided context constrains generation to the retrieved evidence, which is the core grounding technique in RAG.

Option B is not appropriate because a longer output token limit only allows more text and does not improve factual grounding, and can even increase drift. Option E is not appropriate because raising the inference temperature increases randomness and creativity, which typically worsens hallucination rather than mitigating it.

Exam trap

AIP-C01 often tests whether candidates conflate generation parameters (temperature, token limits) with grounding techniques — the trap is picking a plausible-sounding sampling knob instead of the three prompt/retrieval-level mitigations.

Practice this question →
34
MCQmedium

What is the recommended approach to handle PII in your RAG Knowledge Base to comply with privacy regulations?

A.Redact PII before ingesting documents into the Knowledge Base
B.Filter it during query time only
C.Encrypt the Knowledge Base with a master key
D.Use a specialized model that doesn't 'read' PII
AnswerA

Redacting PII before ingestion prevents personal data from ever entering the RAG Knowledge Base, so retrieved context and generated responses cannot expose it. This satisfies privacy regulations at the earliest point, rather than relying on downstream filtering that may leak data through embeddings or logs.

Why this answer

You should redact or mask PII at the source before ingestion into the Knowledge Base.

Practice this question →
35
MCQhard

You are implementing a multi-agent system. Which method is most effective for ensuring the agents do not loop infinitely when coordinating tasks?

A.Caching agent responses
B.Increasing the model temperature
C.Using a smaller model
D.Implementing a maximum iteration count
AnswerD

A maximum iteration count caps the number of coordination cycles an agent may execute, forcing termination once the limit is reached. This directly prevents runaway loops, satisfying the requirement to stop infinite coordination between agents.

Why this answer

A maximum iteration count (or recursion/step limit) is the standard guardrail in agent orchestration frameworks like LangChain, LangGraph, and AWS Bedrock Agents to bound execution. When agents can call each other or themselves, a hard cap on turns prevents runaway loops that burn tokens and never terminate. Once the cap is hit, the orchestrator returns the best partial result or raises a controlled error.

Exam trap

AIP-C01 often tests the misconception that performance tuning (caching, temperature, model size) solves coordination problems — the exam wants you to recognize that infinite loops are a control-flow issue requiring a hard iteration/recursion limit.

How to eliminate wrong answers

Option A is wrong because caching responses improves latency and cost but does nothing to stop an agent from re-invoking another agent indefinitely — a cached response can still trigger another loop iteration. Option B is wrong because increasing temperature makes outputs more random, which if anything increases the chance of unpredictable looping behaviour. Option C is wrong because a smaller model does not change the control-flow logic; a small model can loop just as easily as a large one.

Practice this question →
36
MCQhard

You are implementing a Bedrock Guardrail. You need to ensure the model filters out specific PII (Personally Identifiable Information). Which capability should be configured?

A.Content Filter
B.Denied Topics
C.Sensitive Information Filter
D.Word Policy
AnswerC

The Sensitive Information Filter detects and blocks personally identifiable data such as names, addresses and credit card numbers within prompts and completions. It directly satisfies the stem's requirement to filter specific PII, unlike content filters that target hate, violence or prompt-attack categories. Configure it with the PII entity types you need masked or denied.

Why this answer

The Sensitive Information Filter in Bedrock Guardrails is specifically designed to detect and block or mask PII such as names, addresses, phone numbers, and other sensitive data. It uses pattern matching and machine learning to identify entities like SSNs, credit card numbers, and custom regex patterns. This directly addresses the requirement to filter out specific PII, unlike other guardrail components that focus on harmful content or topic restrictions.

Exam trap

AIP-C01 often tests the distinction between Guardrail components, and candidates may confuse 'Sensitive Information Filter' with 'Content Filter' or 'Word Policy' because all involve filtering, but only Sensitive Information Filter is designed for PII detection.

How to eliminate wrong answers

Option A is wrong because Content Filter targets harmful content categories (hate, violence, sexual, insults) and does not detect PII. Option B is wrong because Denied Topics blocks entire subjects or themes, not specific data types like PII. Option D is wrong because Word Policy filters profanity or custom banned words, not structured sensitive information like PII.

Practice this question →
37
MCQmedium

You are using a Bedrock Knowledge Base. You need to ensure that the search results are highly relevant to technical documentation. Which setting should you adjust?

A.Update the S3 bucket policy
B.Change the search type to HYBRID
C.Increase the temperature
D.Change the model ID
AnswerB

HYBRID search combines semantic vector retrieval with keyword matching, so exact technical terms, identifiers and acronyms in documentation are matched alongside meaning. This improves relevance for technical content, satisfying the requirement for highly relevant search results.

Why this answer

Changing the search type to HYBRID in a Bedrock Knowledge Base combines semantic (vector) search with keyword-based (lexical) search, which significantly improves relevance for technical documentation containing specific terms, acronyms, error codes, and product names that pure semantic search may miss. Hybrid search merges results from both retrieval methods, capturing both conceptual similarity and exact keyword matches, making it ideal for technical content where precise terminology matters.

Exam trap

The trap is assuming that model-level parameters (temperature, model ID) or infrastructure settings (S3 policy) affect retrieval relevance, when the question is specifically about search/retrieval configuration — candidates must distinguish retrieval tuning from generation tuning.

How to eliminate wrong answers

Option A is wrong because the S3 bucket policy controls access permissions to the source documents, not the relevance or ranking of search results — changing it has no effect on retrieval quality. Option C is wrong because temperature is a generation parameter controlling randomness in the model's output text, not a retrieval setting; it does not affect which documents are returned from the knowledge base. Option D is wrong because changing the model ID affects the foundation model used for generation or embeddings, but switching models alone does not change the search strategy — the retrieval relevance issue is addressed by the search type configuration.

Practice this question →
38
MCQeasy

What is the primary purpose of the 'max_tokens' parameter in text generation?

A.To increase response accuracy
B.To improve model reasoning
C.To set the maximum output length
D.To filter out offensive language
AnswerC

Setting `max_tokens` caps the number of tokens the model generates in its response, directly bounding output length. This satisfies the stem's constraint on controlling generation size, preventing runaway or truncated completions. It does not affect input length, prompt processing, or the model's context window, which are governed separately.

Why this answer

The max_tokens parameter sets an upper bound on the number of tokens the model may generate in its response. It does not affect the model's reasoning or accuracy; it simply truncates output once the limit is reached, which is essential for controlling latency and cost.

Exam trap

AIP-C01 often tests the misconception that max_tokens influences model quality or safety, when it is purely an output length and cost control.

How to eliminate wrong answers

Option A is wrong because response accuracy is determined by model quality, prompt design, and context, not by the output length cap. Option B is wrong because reasoning ability comes from the model architecture and training, not from max_tokens. Option D is wrong because content filtering is handled by guardrails or moderation APIs, not by a token limit.

Practice this question →
39
MCQmedium

When using the Bedrock Converse API, what is the best way to include dynamic variable values in a prompt?

A.Format the string in your application code
B.Use the 'dynamic' parameter in the API call
C.Use the 'template' field in the model config
D.Pass values as a separate JSON array
AnswerA

The Converse API accepts plain prompt strings, so dynamic values are injected by formatting them into the text within application code before the request. This gives full control over variable substitution, unlike static prompt templates stored server-side.

Why this answer

Use string formatting within your code to insert variables into the message text before sending the payload.

Practice this question →
40
MCQmedium

When using Bedrock Converse API, how do you handle streaming responses?

A.InvokeModelStream
B.Poll the API until finished
C.Request a callback URL
D.ConverseStream
AnswerD

ConverseStream is the Bedrock Converse API operation that returns incremental response chunks over an event stream. Selecting it satisfies the stem's streaming requirement, whereas the non-streaming Converse call returns the complete response only after generation finishes.

Why this answer

The Bedrock Converse API provides a dedicated streaming operation called ConverseStream, which returns a stream of events (e.g., messageStart, contentBlockDelta, messageStop) as the model generates tokens. This is the correct way to handle streaming with the Converse API because it is purpose-built for the unified conversational interface, supporting multi-turn chat and tool use. Unlike InvokeModelWithResponseStream (used with the InvokeModel API), ConverseStream maintains the Converse API's message format and event structure.

Exam trap

AIP-C01 often tests the distinction between the InvokeModel API and the Converse API, tricking candidates into selecting InvokeModelWithResponseStream (or a misspelled variant like InvokeModelStream) when the question specifically asks about the Converse API's streaming operation.

How to eliminate wrong answers

Option A is wrong because InvokeModelStream is not a real Bedrock API operation; the actual streaming operation for the InvokeModel API is InvokeModelWithResponseStream, and it does not use the Converse API's message format. Option B is wrong because polling the API until finished is a non-streaming, synchronous pattern that defeats the purpose of streaming and is not how Bedrock supports real-time token delivery. Option C is wrong because Bedrock does not support callback URLs for streaming responses; streaming is handled via direct HTTP/2 or event stream connections, not webhooks.

Practice this question →
41
Multi-Selectmedium

Which TWO metrics are natively available in Amazon CloudWatch for monitoring Bedrock model invocation performance?

Select 2 answers
A.VectorEmbeddingAccuracy
B.InvocationLatency
C.GPUUtilization
D.InvocationClientErrors
E.ModelTrainingLoss
AnswersB, D

InvocationLatency is emitted natively by Amazon Bedrock to CloudWatch, measuring end-to-end time from request receipt to full response completion. It directly satisfies the stem's requirement for invocation performance monitoring without custom instrumentation, unlike token-level or throttling metrics that address different concerns.

Why this answer

Option B (InvocationLatency) is correct because Amazon Bedrock natively publishes the InvocationLatency metric to CloudWatch, which measures the time taken for a model invocation request to complete, directly reflecting model invocation performance. Option D (InvocationClientErrors) is correct because Bedrock also natively emits the InvocationClientErrors metric to CloudWatch, capturing the count of client-side errors (such as throttling or validation failures) during model invocations, which is essential for monitoring invocation health. Option A (VectorEmbeddingAccuracy) is not a CloudWatch metric provided by Bedrock; accuracy evaluation is handled through Bedrock model evaluation jobs, not runtime CloudWatch metrics.

Option C (GPUUtilization) is not natively exposed by Bedrock in CloudWatch, since Bedrock is a fully managed service and does not surface underlying GPU infrastructure metrics to customers. Option E (ModelTrainingLoss) is not applicable because Bedrock does not expose training loss metrics in CloudWatch; Bedrock focuses on inference of foundation models rather than customer-visible training telemetry.

Practice this question →
42
Multi-Selecthard

When designing an agentic solution, which THREE aspects of security must be considered?

Select 3 answers
A.Making all API endpoints public
B.IAM least privilege
C.Sharing API keys in the prompt
D.Applying Guardrails for input/output
E.Encryption of data at rest and in transit
AnswersB, D, E

IAM least privilege restricts each agent's permissions to only the actions its task requires, limiting blast radius if the agent is compromised or misbehaves. This satisfies the security requirement by constraining agentic autonomy through tightly scoped, auditable role assignments.

Why this answer

Option B (IAM least privilege) is correct because an agentic solution typically assumes roles or service accounts to call tools, models, and data sources, so granting only the minimal permissions needed limits blast radius if the agent is manipulated or compromised. Option D (Applying Guardrails for input/output) is correct because guardrails filter and validate prompts, tool invocations, and model responses, mitigating prompt injection, data leakage, and unsafe or off-policy actions. Option E (Encryption of data at rest and in transit) is correct because agent workflows move sensitive context, credentials, and results across networks and stores, so TLS for transit and KMS-backed encryption for storage protect confidentiality and integrity.

Option A (Making all API endpoints public) is not appropriate because exposing every endpoint without authentication or authorization dramatically expands the attack surface. Option C (Sharing API keys in the prompt) is not appropriate because embedding secrets in prompts risks leakage through logs, model context, or outputs and violates credential-handling best practice.

Exam trap

AIP-C01 often tests the misconception that security in agentic solutions is only about encryption, ignoring identity and access management and runtime guardrails.

Practice this question →
43
MCQeasy

Which AWS service is best used to store and version control your prompt templates for Bedrock?

A.Amazon Bedrock Prompt Management
B.AWS Systems Manager Parameter Store
C.AWS CodeCommit
D.Amazon S3
AnswerA

Amazon Bedrock Prompt Management stores prompt templates as versioned artefacts, letting you create, compare and roll back variants natively. It satisfies the version-control requirement without building custom tooling, unlike generic stores such as S3 or Parameter Store.

Why this answer

Amazon Bedrock Prompt Management is the correct answer because it is a purpose-built feature that lets you create, store, version, and reuse prompt templates natively within Bedrock. It provides versioning, aliases, and variables so you can iterate on prompts and roll back to previous versions without external tooling. This integrates directly with Bedrock's InvokeModel and agent APIs, making it the most operationally efficient choice for prompt lifecycle management.

Exam trap

AIP-C01 often tests the confusion between generic storage/versioning services (S3, CodeCommit, Parameter Store) and the purpose-built Bedrock Prompt Management feature, which is the only option with native prompt versioning and alias support.

How to eliminate wrong answers

Option B is wrong because Systems Manager Parameter Store is designed for configuration data and secrets, not for versioning prompt templates with semantic versioning, aliases, or variable substitution — it lacks prompt-specific features like variant comparison. Option C is wrong because CodeCommit is a Git repository for source code; while you could store prompts as files, it does not integrate with Bedrock's runtime APIs and requires custom CI/CD to deploy prompt changes. Option D is wrong because Amazon S3 is object storage with versioning, but it provides no prompt-specific management, no aliases, no variable rendering, and no direct Bedrock integration — you would have to build all of that yourself.

Practice this question →
44
MCQmedium

When using the Bedrock Converse API, how do you provide multiple documents to the model for consideration?

A.Upload them to S3 and include the URL in the system message
B.Include them in the 'document' field within the messages array
C.They must be indexed in a Knowledge Base first
D.Attach them as multi-part form data in the HTTP request
AnswerB

The Converse API accepts documents as content blocks inside the messages array, letting each document be attached to a user turn for the model to consider. Placing them in the top-level request body or system prompt does not satisfy the stem's requirement for document content blocks.

Why this answer

The Bedrock Converse API allows you to include documents directly in the messages array using the 'document' field. This enables the model to consider multiple documents in a single request without needing a Knowledge Base or S3 URLs.

Exam trap

AIP-C01 often tests the difference between passing documents inline via Converse API versus using a Knowledge Base for RAG — candidates may incorrectly assume a Knowledge Base is always required.

How to eliminate wrong answers

Option A is wrong because while you can reference S3 objects in some Bedrock APIs, the Converse API expects documents inline in the messages array, not as S3 URLs in the system message. Option C is wrong because indexing in a Knowledge Base is for RAG retrieval, not for direct document passing in a Converse API call. Option D is wrong because the Converse API uses a JSON-structured request, not multi-part form data; multi-part is used for other AWS services like S3 uploads.

Practice this question →

Ready to test yourself?

Try a timed practice session using only Implementation And Integration questions.

Start 20-question session