AWS Certified Generative AI Developer - Professional (AIP-C01) (AIP-C01) (AIP-C01) — Questions 76–150

Amazon Comprehend provides real-time PII detection and redaction through its ContainsPiiEntities and DetectPiiEntities APIs. By calling these APIs in the application pipeline before sending prompts to Bedrock and after receiving completions, the team can redact sensitive entities such as SSNs and account numbers without altering the foundation model itself. This satisfies the inline redaction requirement.

Bedrock Model Evaluation jobs run automatic and human evaluations against candidate foundation models using your own dataset, producing metrics on accuracy, robustness and latency. This lets the developer compare reasoning capability against latency for the chatbot.

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.

Amazon Bedrock Guardrails lets you define content filters, denied topics, and word filters that are applied to every invocation of a model. By attaching a guardrail to the model or to the application's inference calls, the company can centrally enforce restrictions against defamatory or explicit content across all applications. This meets the requirement for a centralized, reusable policy.

Encryption of data at rest is the customer's duty under the Shared Responsibility Model, because AWS secures the underlying infrastructure, not the customer's objects. Configuring it satisfies the stem's compliance scenario by protecting stored data and meeting regulatory encryption mandates.

Auditors need evidence that AI activity is continuously recorded and reviewed. Documenting logging and monitoring policies shows how prompt, response and access events are captured, retained and alerted on, satisfying the audit requirement for demonstrable operational oversight.

Metadata filters restrict retrieval to documents whose tags match the caller's authorisation attributes, so restricted chunks never enter the context window. This satisfies document security by enforcing access control at query time within the vector search itself.

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.

InvokeModel sends a direct inference request to a foundation model, accepting a prompt and returning generated text. It requires no knowledge base retrieval step, satisfying the stem's constraint of text generation without a Knowledge Base. This contrasts with RetrieveAndGenerate, which queries a configured knowledge base before invoking the model.

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.

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.

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.

Granting only the specific Bedrock actions and resources each workload needs limits blast radius if credentials leak. Least-privilege IAM policies constrain model invocation, agent, and knowledge base access, satisfying the recommended security practise for Bedrock API usage.

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.

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.

Action Group invocations run in Lambda, so CloudWatch Logs capture the request payloads, errors and timeouts that surface as agent failures. Reviewing these logs isolates whether the fault lies in the Lambda function rather than the agent's orchestration or prompt configuration.

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.

Model invocation logging in Amazon Bedrock records the input prompts, output text, and associated metadata for each invocation. This creates an audit trail that supports traceability and post-hoc analysis of model behavior. Storing logs in CloudWatch Logs and S3 enables compliance teams to review what the model generated and when, which directly addresses the traceability requirement for patient record summaries.

Answer Relevance scores how directly the generated response addresses the user's original question, independent of factual grounding. In a RAG test suite it catches responses that are faithful to retrieved context yet drift off-topic, satisfying the need to evaluate end-to-end answer quality.

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.

SCPs are AWS Organizations guardrails that deny actions or regions across member accounts, evaluated before IAM policies. Attaching a region-restriction SCP to the relevant OUs enforces data residency at the account boundary, blocking Generative AI workloads from invoking services outside approved regions.

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.

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.

Amazon Bedrock Guardrails applies configurable policies, including sensitive-information filters that detect and block PII, to model inputs and outputs. This enforces the healthcare compliance requirement by filtering generative AI responses before they reach the end user.

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.

Amazon Bedrock Prompt Management stores prompt templates as versioned, shareable resources, allowing controlled cross-account or cross-team access through IAM rather than manual copying. This satisfies the secure-sharing constraint while preserving version history and centralised updates.

Metadata filtering restricts vector search to documents matching attributes such as date, source or tenant, removing semantically similar but irrelevant chunks before ranking. This directly satisfies the stem's goal of improving retrieved document relevance in a RAG pipeline.

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.

Storage volume in the vector database directly drives cost, since Amazon Bedrock Knowledge Bases bill for the underlying vector store's capacity and consumed storage. Larger embedded datasets, particularly with high-dimensional vectors, increase the provisioned or on-demand storage charges, making stored data volume a genuine cost factor.

The Retrieve API returns the chunks and relevance scores without invoking the generation model. By examining whether the top-ranked chunks actually contain the answer, you can determine if retrieval is failing. If relevant chunks are present but the answer is wrong, the fault lies in generation; if not, retrieval needs tuning.

Exceeding the model-specific tokens-per-minute quota in that Region triggers throttling independently of account-level limits, so 429s appear despite unused account capacity. Bedrock enforces per-model, per-Region TPM and RPM quotas separately, meaning a single high-volume Lambda workload can saturate the model's throughput ceiling while aggregate account usage remains low.

Access policies enforce least-privilege and role-based controls so only authorised identities can view PII within generative AI workflows, satisfying the stem's requirement for handling personal data responsibly. This limits exposure during prompt processing and output generation, reducing regulatory breach risk under regimes such as UK GDPR.

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.

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.

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.

Amazon CloudWatch collects Bedrock runtime metrics such as invocation latency, throttling and token counts, plus custom metrics your application publishes. This satisfies the stem's requirement to monitor both application performance and the latency of Bedrock calls, since CloudWatch is the native AWS observability service for these metrics.

Amazon Bedrock model invocation logging can capture full request and response data and deliver it to CloudWatch Logs. Setting a retention period of 90 days on the log group meets the retention requirement. This is a managed feature that requires minimal operational overhead, as it is configured directly in Bedrock.

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.

CloudTrail records Bedrock API activity, including InvokeModel calls, capturing who sent each prompt, when, and from where. This satisfies the auditing requirement by providing an immutable, queryable event history of prompt submissions, unlike CloudWatch metrics, which only expose aggregate performance data.

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.

To meet data residency, the vector store must be in the same region as the documents. Creating the OpenSearch Serverless collection in eu-west-1 ensures that embeddings and queries remain within that region. Bedrock Knowledge Bases support OpenSearch Serverless as a vector store, and configuring it in the same region satisfies the requirement.

RetrieveAndGenerate returns generated answers alongside citations referencing the source chunks retrieved from the knowledge base, so users can verify claims. The API handles retrieval, generation and attribution in one call, unlike Retrieve, which returns documents without a generated, cited response.

SCPs define the maximum available permissions for all accounts in an AWS Organization, restricting which services and actions member accounts can use regardless of their IAM policies, thereby enforcing organisational compliance across the AI governance framework.

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.

AWS IAM governs authentication and authorisation for Amazon Bedrock, controlling which principals may invoke specific models and actions through identity-based and resource-based policies. It is the native access management service for Bedrock, satisfying the requirement to manage user access to models.

Metadata filtering narrows the vector search to documents matching structured attributes before similarity ranking, so irrelevant files never enter the candidate set. This satisfies the constraint of millions of documents by cutting the searchable corpus to a relevant subset, improving both precision and latency.

Prompt caching in Amazon Bedrock allows you to cache the static portions of a prompt, such as a long system instruction, so that repeated invocations reuse the cached context instead of reprocessing it. This reduces both input token costs and latency for subsequent requests that share the same prefix. The scenario explicitly requires no change to the model or instructions, making this the correct choice.

Amazon Bedrock Knowledge Bases performs retrieval-augmented generation by querying your ingested document store, then passing retrieved passages to the foundation model as context. This grounds responses in trusted company documents, directly addressing the hallucination concern. It satisfies the grounding constraint through managed vector ingestion and citation-backed retrieval, without custom pipeline code.

Amazon Q Business honours access control lists retrieved by the connector, so per-user and per-group permissions defined at the source are enforced during retrieval. Configuring ACLs in the connector therefore satisfies the stem's requirement to restrict data source access for different user groups.

Some Bedrock models support a seed parameter that, when combined with temperature 0 or low temperature, helps produce repeatable outputs. Supplying a fixed seed reduces variability across identical requests. This is a valid additional step to improve determinism when the chosen model exposes seed support.

SageMaker Model Monitor continuously captures endpoint inference data and compares it against a baseline, detecting data drift, model quality degradation and bias shifts. This directly satisfies the requirement to observe model performance drifts over time, unlike one-off evaluation tools that provide only point-in-time metrics.

AWS Cost Explorer provides visibility into cost and usage, and AWS Budgets allows you to set custom budgets and receive alerts when costs exceed thresholds. Together, they can track Amazon Bedrock spending and notify you. This is the standard AWS approach for cost monitoring and alerting across services.

Bedrock Guardrails provide a managed sensitive information filter that can detect and block or mask PII in both input prompts and model responses. Configuring the filter with PII entities addresses the requirement directly. It integrates with model invocation so that policy is enforced consistently without custom code.

Sanitising user input strips or neutralises injected instructions, delimiters and control tokens before they reach the model, directly reducing the attack surface for prompt injection. This input-layer defence satisfies the mitigation requirement by preventing adversarial payloads from being interpreted as trusted system-level commands.

Guardrails filter model outputs, but leakage often originates upstream: the system prompt may instruct the model to reveal internal context, and Knowledge Base retrieval filters may return documents the user should not see. Reviewing both closes the actual data-exposure path.

Atlassian Confluence is a supported native connector for Amazon Bedrock Knowledge Bases, letting the service crawl and synchronise spaces, pages and attachments directly into the vector store. This satisfies the stem's requirement for supported source data without custom ingestion pipelines, unlike unsupported sources such as generic SQL databases.

Amazon CloudWatch is the primary telemetry service receiving Bedrock metrics such as ModelInvocationLatency, letting you graph, alarm and analyse them. It satisfies the monitoring requirement without additional agents, since Bedrock publishes these metrics natively to CloudWatch.

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.

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.

SageMaker inference containers stream stdout and stderr to Amazon CloudWatch Logs, so endpoint container logs are retrieved there. CloudTrail records API activity, not container output, making CloudWatch Logs the correct source for troubleshooting the endpoint.

AWS Cost Explorer centralises and visualises spend across SageMaker projects by filtering and grouping costs using cost allocation tags, satisfying the requirement to aggregate project-level expenditure in one place. Unlike AWS Budgets, which only alerts against thresholds, Cost Explorer provides interactive charts and granular breakdowns for analysis.

AWS IAM supplies the roles, policies and temporary credentials that govern which principals may invoke Bedrock models, giving least-privilege access control. It satisfies the requirement for secure identity and access management for an application calling Bedrock.

Amazon Bedrock Model Evaluation provides built-in and custom evaluation jobs that score model or RAG outputs against metrics such as correctness, faithfulness and relevance. It directly measures response quality for retrieval-augmented generation applications without requiring separate tooling.

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.

Prompt Management stores, versions and shares prompts with approval workflows, giving teams traceability over what was deployed. This versioning and lifecycle control delivers the governance capability the question requires, distinct from runtime safety filtering or model hosting features.

Provisioned Throughput reserves model units at a fixed hourly rate, which becomes cheaper than on-demand per-token pricing once usage is steady and predictable. It satisfies the cost-optimisation goal by removing the premium charged for bursty, unpredictable inference consumption.

A reranking model rescores the initial candidate set from vector search, applying a cross-encoder that evaluates query-document pairs jointly rather than comparing independent embeddings. This directly improves semantic relevance by promoting contextually accurate passages, satisfying the stem's requirement for higher-quality retrieval in the RAG pipeline.

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.

Because the document only changes on legal revision, the summary is deterministic for a given revision. Generating once, writing the result to S3 with a key that includes the revision identifier, and returning the stored text on subsequent requests eliminates nearly all repeat token spend while guaranteeing byte-identical summaries. This is the classic materialization pattern for stable generative outputs.

Multi-Model Endpoints host many models behind one endpoint, loading them on demand into shared containers. This satisfies operational efficiency by reducing the number of instances required, since models no longer each need a dedicated endpoint and its hosting fleet.

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.

A post-processing Lambda receives Bedrock's generated output and injects watermark metadata before the document is returned, satisfying the traceability requirement. Because Bedrock offers no native watermarking feature, this custom step is the only mechanism that guarantees every AI-generated document carries the required marker.

AWS CloudTrail records API activity across the account, capturing the identity, source IP and timestamp of each Bedrock InvokeModel call. That event history answers who accessed a model and when, satisfying the audit-log requirement in the stem.

Amazon Bedrock Guardrails enforce content filtering, denied topics and PII redaction on model inputs and outputs, forming the policy-enforcement layer of an AI governance framework. It directly satisfies the requirement by operationalising responsible-AI controls within AWS.

Bedrock batch inference accepts a JSONL file in Amazon S3, runs the same foundation model asynchronously across the batch, and writes results back to S3 with a job ARN you can poll. Because it parallelizes internally and is designed for large offline workloads, it collapses the nine-hour sequential pattern into a single managed job that comfortably fits the six-hour window without changing model quality.