Practice Free AIP-C01 AWS Certified Generative AI Developer - Professional Exam Questions Answers With Explanation

Option B provides the strongest match among the listed alternatives because it combines managed speaker identification, multimodal generative analysis, and a native search-oriented datastore without unnecessary custom orchestration.

Amazon Transcribe speaker diarization distinguishes speakers and assigns identifiers such as spk_0 , spk_1 , and so forth. Its output includes speaker labels and timestamps, allowing individual statements to be associated with particular speakers and positions in the meeting timeline.

Anthropic Claude models on Amazon Bedrock support multimodal prompts that combine text and images. The application can therefore supply speaker-attributed transcript segments together with extracted presentation/video frames and instruct the model to generate summaries that associate spoken comments with relevant visual information. AWS ' s Claude Messages API documentation explicitly supports mixed image-and-text input.

Amazon OpenSearch Service is appropriate for storing the enriched meeting records and supporting document indexing and full-text searching. It provides substantially more natural full-text retrieval than attempting to create a custom indexing layer over DynamoDB.

A uses Transcribe and Rekognition effectively, but it states that a Lambda function itself “generates” the summaries without specifying a generative model and requires custom correlation logic. C chains BDA, Transcribe, Rekognition, DynamoDB, and Bedrock, increasing service count and operational complexity; DynamoDB also does not natively satisfy the full-text-search requirement. D similarly depends on DynamoDB plus a custom indexing mechanism.

Current AWS capabilities make Bedrock Data Automation even more capable than the wording of C suggests: BDA can produce video summaries, scene-level summaries, detected video text, full audio transcripts, and speaker identification. However, among the supplied choices , B remains the cleanest architecture satisfying multimodal GenAI analysis, diarization, scalable managed processing, and native searchable storage.

==========

Option B best fulfills all functional, scalability, and collaboration requirements by combining purpose-built AWS services with Amazon Bedrock capabilities. Amazon Bedrock Data Automation is designed to orchestrate large-scale, multimodal data processing pipelines and integrates naturally with foundation models for summarization and concept extraction. Using BDA to process document files ensures consistent preprocessing and model invocation at scale, which is essential for handling more than 10,000 sources per day with high concurrency.

Integrating Amazon Textract for PDFs enables accurate extraction of structured and unstructured text from scanned and digital documents, while Amazon Transcribe is the appropriate service for converting recorded videos into text for downstream semantic analysis. These services are optimized for their respective media types and feed clean, normalized inputs into Bedrock foundation models, improving the quality of contextual summaries.

Storing processed content in Amazon S3 with versioning enabled directly addresses the requirement for version control. S3 versioning provides immutable object history and rollback capabilities without additional complexity. Metadata storage in Amazon DynamoDB supports high-throughput, low-latency access patterns and scales automatically to handle peak upload concurrency.

Real-time collaboration is achieved through AWS AppSync GraphQL subscriptions combined with DynamoDB. AppSync enables real-time updates to connected clients whenever study materials are created or modified, making it well suited for collaborative editing and live synchronization. DynamoDB streams integrate seamlessly with AppSync to propagate changes efficiently.

The other options misuse services or fail to meet key requirements. Amazon SNS does not support collaborative state synchronization, Amazon DocumentDB is not optimized for versioned document storage, Amazon Neptune is unsuitable for document-centric workloads, and Amazon ElastiCache is not designed for durable storage or version control. Option B aligns with AWS best practices for scalable, multimodal generative AI systems built on Amazon Bedrock.

Option A is the only choice that simultaneously addresses all three requirements: (1) higher output consistency for identical inputs, (2) sub-1-second performance, and (3) validated safety controls that block unsafe or hallucinated recommendations.

Provisioned throughput in Amazon Bedrock reserves capacity for the chosen model, which helps stabilize latency and reduces the chance of throttling or variable response times across Regions. This is important for a mobile app with strict latency goals and users distributed across multiple Regions. While provisioned throughput primarily improves performance predictability, it also reduces variability caused by contention during peak demand.

Amazon Bedrock guardrails provide validated safety controls to filter or block unsafe content. Semantic denial rules are appropriate for preventing dangerous brewing guidance (for example, excessively high temperatures) and for reducing hallucinated instructions that violate safety policies. Guardrails can be enforced consistently regardless of prompt-chain complexity, providing a uniform safety layer around the model outputs.

Amazon Bedrock Prompt Management supports controlled prompt versioning and approval workflows. By standardizing prompts, controlling changes, and ensuring the same prompt version is used for identical inputs, the company improves output stability and reduces drift caused by unmanaged prompt edits. Combined with strict configuration control (including fixed inference parameters such as temperature where appropriate), this improves repeatability and increases the likelihood of achieving the 99.5% consistency target.

Option B improves observability and experimentation but does not provide strong safety enforcement or latency stabilization. Option C improves performance through caching and tracing but does not provide validated safety controls and does not directly address cross-Region output consistency. Option D may improve retrieval but does not enforce safety controls or ensure repeatable outputs.

Therefore, Option A best meets the stability, performance, and safety requirements using AWS-native controls.

AWS Glue Data Quality is the correct core service because it directly addresses the distinctive requirements that separate this question from ordinary ETL validation. AWS describes Glue Data Quality as a managed, serverless capability for measuring and monitoring dataset quality. It uses Data Quality Definition Language (DQDL) for rules, can automatically analyze datasets and recommend rules, generates a Data Quality score after rule evaluation, supports machine-learning-based anomaly detection, and integrates with Amazon CloudWatch.

Completeness can be evaluated through DQDL rules such as IsComplete . AWS rule recommendations can automatically generate completeness, uniqueness, value-domain, and column-length rules based on observed data. Anomaly detection learns historical statistics and identifies values outside predicted bounds; AWS can additionally recommend future data-quality rules based on detected anomalies.

Glue Data Quality can publish pass/fail metrics into the Glue Data Quality CloudWatch namespace, making the results usable for monitoring, alarms, and regulatory-quality dashboards.

There is one important technical issue in the wording of option B: AWS Glue Data Quality itself does not remove PII. The complete AWS Glue implementation would pair Glue Data Quality with the AWS Glue Detect PII transform. AWS documents that this transform can identify sensitive entities and then mask, redact, hash, or otherwise process identified PII. Therefore, B is clearly the intended and strongest listed answer, but a production implementation should add the Glue PII transform to fully satisfy the question ' s PII-removal requirement.

A requires extensive custom validation. C does not provide the requested automated rule recommendations and managed quality-score capabilities. D handles PII detection but lacks automated DQDL recommendations, ML anomaly detection, and native data-quality scoring.

==========

This error occurs because SCPs override IAM permissions, and the SCP currently blocks Bedrock inference calls that resolve to eu-west-3, even though the company intends to use cross-Region inference (CRI) from eu-central-1.

Amazon Nova Pro is not hosted in eu-central-1, so when invoked, Amazon Bedrock transparently routes the request to a supporting Region (such as eu-west-3) through CRI inference profiles. However, SCPs that restrict Regions or specific Bedrock resources will block this routing unless explicitly allowed.

Option B is required because the SCP must explicitly allow the eu.amazon.nova-pro-v1:0 inference profile, which is the Bedrock abstraction that enables CRI while preserving data residency guarantees. Without this, Bedrock cannot legally route the request.

Option E is also required to allow EU-scoped inference profiles rather than individual Regions. This preserves precise governance while allowing Bedrock-managed CRI routing within the EU boundary, ensuring no data leaves Europe.

Option A violates least-privilege and does not override SCPs. Option C breaks data residency by enabling direct eu-west-3 access. Option D does not resolve the SCP denial.

Therefore, Options B and E are the only combination that resolves the error while preserving governance and EU-only data residency.

Option B provides the least operational overhead because it keeps the solution primarily inside managed Amazon Bedrock capabilities, minimizing custom orchestration code and infrastructure to operate. The core requirements are domain grounding, reduced semantic dilution for complex questions, and consistent low-latency responses at high request volume. A Bedrock knowledge base is purpose-built for Retrieval Augmented Generation by ingesting domain documents, chunking content, generating embeddings, and retrieving the most relevant passages at runtime. This directly addresses the need to reference domain-specific medical terminology from authoritative documents to reduce ambiguity and improve factual accuracy.

Reducing semantic dilution typically requires improving the retrieval query so that the retriever focuses on the most relevant concepts, especially for long or multi-intent questions. Enabling query decomposition allows the system to break a complex medical query into smaller, more targeted sub-queries. This increases retrieval precision and recall for each sub-question, which helps the model generate a more accurate synthesized response grounded in the retrieved medical context.

Amazon Bedrock Flows provide a managed way to orchestrate multi-step generative AI workflows, such as preprocessing the input, performing retrieval against the knowledge base, invoking a foundation model, and formatting the final response. Because flows are managed, the com pany avoids maintaining custom state machines, multiple Lambda functions, or bespoke routing logic. This reduces operational overhead while still supporting repeatable, observable execution.

Compared with the alternatives, option A introduces an agent plus API Gateway routing and multiple model choices, increasing configuration and runtime complexity. Option C requires hosting and scaling custom models on SageMaker AI, which adds significant operational burden and latency risk. Option D relies on multiple Lambda functions orchestrated by an agent, which adds more moving parts and increases cold-start and integration overhead. Option B most directly meets the requirements with the smallest operational footprint.

Amazon Bedrock Knowledge Bases is designed specifically for managed retrieval-augmented generation. A knowledge base connects source repositories to an embedding model and vector store. During ingestion, source content is transformed into numerical vector embeddings. At retrieval time, the query is similarly represented so the knowledge base can compare semantic similarity and return passages that are conceptually relevant rather than depending exclusively on exact keyword matches.

Amazon Bedrock supports managed data-source connectors for multiple repositories. The AWS documentation lists Amazon S3, Confluence, Microsoft SharePoint, Salesforce, web crawling, and custom data sources among supported connection patterns. These connectors reduce the amount of ingestion, crawling, and synchronization code an organization needs to maintain.

For Atlassian Confluence specifically, Bedrock can crawl supported Confluence content and supports incremental synchronization for added, modified, or deleted material. Current managed Confluence integration also supports crawling pages, blog posts, and attachments, subject to the documented connector limitations.

This architecture supplies the retrieval layer needed to augment an FM with source-grounded context. It centralizes retrieval semantics while letting the application use Bedrock ' s managed ingestion and retrieval capabilities instead of implementing its own embedding pipelines.

B explicitly uses keyword-oriented mappings and therefore does not meet the semantic-search requirement. C could technically implement RAG, but Lambda-based embedding generation, synchronization, and custom retrieval logic create precisely the operational burden the company wants to avoid. D is not an appropriate semantic RAG architecture because ordinary DynamoDB queries do not automatically produce vector-based semantic retrieval from unstructured documentation.

For an internal wiki not covered by a built-in connector, the knowledge-base custom data-source capability can be used while keeping the overall retrieval interface centralized. Therefore, A provides the closest fit to every stated architectural requirement.

==========

Option C is the best answer because the scenario is centered on a foundation-model GenAI application that needs explainability, fairness iteration, and responsible AI controls inside an Amazon Bedrock workflow. Amazon Bedrock Agents support tracing, and AWS documentation states that traces can show the agent’s path from user input to response, including action group inputs and outputs, knowledge base queries, and the reasoning the agent uses to decide which action or query to take. AWS also describes trace data as a way to understand how an agent arrived at a response. This directly addresses clinicians’ need to review diagnostic reasoning and decision flow.

Amazon Bedrock Guardrails are also the right service for policy compliance in GenAI applications. AWS documentation states that Guardrails can implement safeguards aligned with responsible AI policies, configure denied topics, filter harmful content, and remove sensitive information. For healthcare and life sciences GenAI use cases, AWS Prescriptive Guidance recommends evaluating bias, fairness, and hallucinations and implementing guardrails to prevent harmful responses. This supports strict governance and privacy-sensitive clinical workflows.

The prompt testing and A/B testing component supports rapid iteration. AWS guidance for generative AI operations recommends prompt template management, creating and testing prompt variants, using A/B testing workflows for prompt variants, and analyzing performance against metrics. This is relevant for testing fairness behavior across demographic prompt sets and clinical scenarios.

Option A includes SageMaker Clarify, which is useful for bias detection and model explainability, but it is less directly aligned to Bedrock-native real-time tracing and policy enforcement for an FM application. Option B handles medical text extraction and terminology but not reasoning transparency or governance. Option D provides operational metrics and custom reports, but not native Bedrock reasoning traces or guardrails. Therefore, option C best meets the GenAI governance requirements.

==========

AWS Glue Data Catalog and its associated crawlers are the standard AWS tools for automatic discovery and centralized cataloging of datasets. For the generated summaries, storing them in Amazon S3 allows the use of object tags for metadata (like source IDs), making them easily queryable. The critical requirement for " tamper-evident, immutable audit logs " is met by enabling Bedrock model invocation logging to an S3 bucket protected by S3 Object Lock (compliance mode). To further guarantee that logs have not been altered, AWS CloudTrail log file integrity validation uses cryptographic hashes to provide non-repudiation and a verifiable audit trail. This combination covers data management, metadata attribution, and high-standard security compliance.

Option B is the correct solution because it leverages native Amazon Bedrock intelligent prompt routing, which is specifically designed to reduce cost and complexity in multi-model GenAI architectures. Intelligent prompt routing automatically analyzes incoming prompts and selects the most appropriate foundation model based on prompt characteristics and complexity—without requiring custom classification logic or orchestration code.

This approach directly meets the requirement for least implementation effort. The company does not need to deploy additional Lambda functions, maintain routing rules, or manage separate classification stages. Routing decisions are handled by Bedrock, which simplifies architecture and reduces operational risk.

By routing the majority (70%) of simple product inquiries to smaller, lower-cost models, the company minimizes inference cost and latency. More complex return policy inquiries are automatically routed to larger models that provide better reasoning capabilities, preserving response quality and customer satisfaction.

Because routing is handled inline by Bedrock, response latency remains low compared to multi-stage architectures that require an additional classification model call before inference. This is critical for customer service scenarios where responsiveness directly impacts satisfaction.

Option A introduces additional inference steps and custom logic. Option C increases cost by overusing a mid-sized model for all queries. Option D relies on brittle keyword rules and increases operational overhead through endpoint management.

Therefore, Option B delivers the optimal balance of cost efficiency, performance, and simplicity for dynamic model selection in Amazon Bedrock.

Option B is the correct solution because it delivers end-to-end governance, security, and auditability across Amazon Bedrock, Amazon Rekognition, and the underlying data layer while meeting strict privacy and compliance requirements.

Using IAM attribute-based access control (ABAC) allows the company to control access to foundation models and data based on department, role, or workload attributes rather than static permissions. This is critical for controlling FM access patterns at scale. Enforcing specific ModelId and GuardrailIdentifier values with IAM condition keys ensures that only approved models and guardrails are used, which directly supports secure model I/O and governance requirements.

Configuring VPC endpoints for Amazon Bedrock ensures that all model invocations remain on private AWS network paths, reducing data exfiltration risk and supporting privacy standards. AWS CloudTrail captures both management and data events, providing a definitive audit trail of who accessed which resources and when. Sending logs to CloudTrail Lake enables centralized, long-term, queryable auditing across services.

Amazon S3 server access logging adds file-level visibility into video archive access, which is essential for compliance and forensic analysis. Amazon CloudWatch alarms provide near real-time detection of anomalous or unauthorized activity across Amazon Bedrock, Amazon Rekognition, and AWS KMS.

Option A focuses primarily on model-level tracing but lacks comprehensive IAM governance and S3 access auditing. Option C provides partial controls but lacks identity-aware auditing and model governance. Option D focuses on anomaly detection and classification but does not explicitly control FM access patterns.

Therefore, Option B best satisfies all stated requirements in a unified, auditable, and security-first architecture.

The combination of Options C and D delivers comprehensive, real-time observability for Amazon Bedrock workloads with the least operational overhead by relying on native integrations and managed services.

Amazon Bedrock publishes built-in CloudWatch metrics for model invocations and token usage. Option C leverages these native metrics directly, allowing teams to build centralized CloudWatch dashboards without additional data pipelines or custom processing. CloudWatch alarms provide threshold-based alerting for token consumption, enabling proactive cost and usage control across all foundation models. This approach aligns with AWS guidance to use native service metrics whenever possible to reduce operational complexity.

Option D complements CloudWatch by enabling advanced, stakeholder-specific visualizations through Amazon Managed Grafana. The zero-ETL integration allows Bedrock and CloudWatch metrics to be visualized directly in Grafana without building ingestion pipelines or managing storage layers. Grafana dashboards are particularly well suited for serving different audiences, such as engineering, finance, and product teams, each with customized views of token usage and trends.

Option A introduces unnecessary complexity by adding a business intelligence layer that is better suited for historical analytics than real-time operational monitoring. Option B is useful for deep log analysis but requires query maintenance and does not provide efficient real-time dashboards at scale. Option E involves multiple services and custom data flows, significantly increasing operational overhead compared to native metric-based observability.

By combining CloudWatch dashboards and alarms with Managed Grafana’s zero-ETL visualization capabilities, the company achieves real-time visibility, flexible dashboards, and automated alerting across all Amazon Bedrock foundation models with minimal operational effort.

Option C is the correct solution because AWS AppConfig is purpose-built to manage dynamic application configurations with low latency, strong validation, and minimal operational overhead, which directly matches the company’s requirements.

AWS AppConfig enables the company to centrally manage model selection logic, inference parameters, and customer-tier routing rules without redeploying Lambda functions. By using feature flags, the company can easily perform A/B testing of new models or prompt strategies by gradually rolling out changes to a subset of users or customer tiers. This allows experimentation and controlled releases without code changes.

AppConfig also supports JSON schema validation, which is critical for validating parameters such as temperature, maximum token limits, and other model-specific settings before they are applied. This prevents invalid or unsafe configurations from being deployed and reduces the risk of runtime errors or degraded model behavior in production.

Using the AWS AppConfig Agent allows Lambda functions to retrieve configurations efficiently with built-in caching and polling mechanisms, minimizing latency and avoiding excessive calls to configuration services. This approach scales well for high-throughput, low-latency applications such as GenAI APIs behind Amazon API Gateway.

Option A introduces unnecessary redeployment logic and polling complexity. Option B requires building and maintaining custom configuration access patterns in DynamoDB and does not natively support feature flags or schema validation. Option D adds operational overhead by requiring ElastiCache cluster management and custom validation logic.

Therefore, Option C provides the most scalable, flexible, and low-maintenance solution for dynamic model switching, A/B testing, and safe configuration management in a GenAI application.

Amazon SageMaker Serverless Inference is specifically designed for applications that experience intermittent or bursty traffic. It automatically scales compute capacity based on the number of requests and scales down to zero when there is no traffic, satisfying the requirement to optimize resource usage during low demand. To meet the 500 ms latency requirement during peak periods and avoid " cold start " delays, provisioned concurrency keeps a specified number of execution environments warm and ready to respond immediately. This provides a balance between the cost-effectiveness of serverless and the performance predictability of provisioned instances. Multi-model endpoints (Option A) can introduce " noisy neighbor " issues and latency spikes, while asynchronous inference (Option D) is intended for long-running workloads and cannot meet sub-500 ms requirements.

Option B is the correct solution because it directly addresses both throughput bottlenecks and latency requirements using native Amazon Bedrock performance optimization features that are designed for real-time, high-volume generative AI workloads.

Amazon Bedrock supports cross-Region inference profiles, which allow applications to transparently route inference requests across multiple AWS Regions. During peak usage periods, traffic is automatically distributed to Regions with available capacity, reducing throttling, request queuing, and timeout risks. This approach aligns with AWS guidance for building highly available, low-latency GenAI applications that must scale elastically across geographic boundaries.

Token batching further improves efficiency by combining multiple inference requests into a single model invocation where applicable. AWS Generative AI documentation highlights batching as a key optimization technique to reduce per-request overhead, improve throughput, and better utilize model capacity. This is especially effective for lightweight, low-latency models such as Claude 3 Haiku, which are designed for fast responses and high request volumes.

Option A does not meet the requirement because purchasing provisioned throughput in a single Region creates a regional bottleneck and does not address multi-Region availability or traffic spikes beyond reserved capacity. Retries increase load and latency rather than resolving the root cause.

Option C improves application-layer scaling but does not solve model-side throughput limits. Client-side round-robin routing lacks awareness of real-time model capacity and can still send traffic to saturated Regions.

Option D is unsuitable because batch inference with asynchronous retrieval is designed for offline or non-interactive workloads. It cannot meet a strict 2-second response time requirement for an interactive AI assistant.

Therefore, Option B provides the most effective and AWS-aligned solution to achieve low latency, global scalability, and high throughput during peak usage periods.

Option B is the correct solution because AWS AppConfig is specifically designed to support dynamic configuration management with safe rollout, validation, and rollback, which are explicit requirements in the scenario.

By storing the active model provider configuration in AWS AppConfig, the company can switch between Amazon Bedrock model providers in real time without redeploying Lambda code. AppConfig supports deployment strategies such as canary releases, linear rollouts, and immediate deployments, allowing safe and controlled changes. If a configuration causes issues, AppConfig supports automatic rollback, reducing operational risk.

AWS AppConfig also supports schema validation, ensuring that configuration values such as model identifiers, provider names, or inference parameters are valid before being applied. This prevents misconfiguration from impacting production workloads.

Option A uses Parameter Store, which lacks native rollout strategies, validation, and automated rollback, making it unsuitable for safe real-time switching. Option C requires manual routing changes and code coupling, increasing operational overhead and deployment risk. Option D introduces unnecessary complexity by hosting configuration files in Amazon S3 when AppConfig already supports native hosted configurations.

Therefore, Option B provides the most robust, scalable, and low-maintenance solution for dynamic model switching in a serverless Amazon Bedrock inference architecture.

The correct combination is A, B, and D because these three options collectively satisfy the mandatory requirements for structured extraction, PII redaction before inference, regional human review, data residency, auditability, and high-scale availability with managed AWS services.

Option A is essential because Amazon Textract is the AWS-managed service designed to extract structured data from scanned documents such as forms, tables, and financial statements. Textract provides confidence scores, and Amazon Augmented AI (A2I) is purpose-built to route low-confidence extractions to human reviewers. Deploying Textract and A2I within the same Region ensures that the human review loop remains regionally constrained, meeting strict data residency requirements for applicants.

Option B satisfies the requirement to redact PII before inference by using AWS Lambda preprocessing. It also adds Amazon Bedrock guardrails to enforce safety controls on model outputs. Region-specific IAM roles ensure that only authorized principals in the correct Region can access the extracted data and invoke downstream services, strengthening residency enforcement and auditability.

Option D ensures that source documents are stored in Amazon S3 in the same Region as the applicant. Object metadata and tagging provide an auditable trail, supporting compliance reporting and traceability. S3 also provides the durability and availability needed to support 99.9% application availability as part of a well-architected pipeline.

Option C is not the correct approach for structured extraction from scans. Option E adds useful quality validation but is not strictly required to meet the stated requirements compared to A, B, and D. Option F is unrelated to the extraction/redaction/residency workflow requirements.

Therefore, A, B, and D are the best three choices to meet all stated requirements with minimal operational overhead.

Option C is correct because the issue is retrieval quality: responses contain irrelevant information and sometimes miss important surrounding context. Amazon Bedrock Knowledge Bases supports hierarchical chunking with parent and child chunks. In this pattern, smaller child chunks improve precise retrieval, while larger parent chunks provide broader surrounding context when returned for generation. AWS documentation states that hierarchical chunking supports two levels: a parent chunk size and a child chunk size, with configurable overlap. This directly addresses the textbook problem because dense technical materials often need both fine-grained matching and enough context to avoid incomplete or misleading answers.

Hybrid search is also the strongest retrieval option for domain-specific textbooks. AWS documentation for Knowledge Bases explains that HYBRID search uses both vector embeddings and raw text, while SEMANTIC search uses only vector embeddings. For technical content, equations, terms, acronyms, product names, and exact phrases may be missed by pure semantic search. Hybrid search reduces this risk by combining semantic similarity with keyword matching. The Knowledge Base vector search configuration also supports controls such as number of source chunks, metadata filters, search type override, and reranking configuration, all of which help tune retrieval quality.

Adjusting the relevance threshold, or filtering low-confidence retrieval results in the application layer, helps reduce hallucinations because the model should not generate answers from weak or unrelated context. The key GenAI principle is that RAG quality depends on retrieving the right evidence before generation. If irrelevant chunks are passed to the FM, the FM can produce irrelevant or unsupported answers.

Option A uses very small fixed chunks, which can miss context across sections. Option B adds caching and feedback loops but does not fix the underlying retrieval issue. Option D’s semantic chunking can help topic boundaries, but it does not explicitly solve exact-term retrieval or low-confidence filtering. Therefore, hierarchical chunking plus hybrid search and relevance filtering is the best answer.

==========

Option C is the correct solution because it directly addresses both correctness and performance issues by grounding the model’s responses in authoritative product data using Retrieval Augmented Generation. Amazon Bedrock Knowledge Bases are designed to connect foundation models to trusted enterprise data sources, ensuring that generated responses are constrained to known, validated content.

By ingesting the product catalog into a knowledge base, the GenAI application retrieves only products that actually exist in the catalog. This prevents hallucinated or unavailable recommendations, which is a common issue when models rely solely on prompt instructions without retrieval grounding. RAG ensures that the model’s output is based on retrieved facts rather than learned generalizations.

Setting the PerformanceConfigLatency parameter to optimized enables Bedrock to prioritize lower-latency retrieval and inference paths, improving responsiveness for real-time recommendation scenarios. This directly addresses the reported performance issues without requiring provisioned throughput or caching strategies that are ineffective for mostly unique interactions.

Option A improves safety and latency predictability but does not ensure recommendations are limited to valid products. Option B relies on prompt constraints, which are not sufficient to prevent hallucinations. Option D introduces additional validation and caching layers but increases complexity and does not improve generation relevance.

Therefore, Option C best resolves both relevance and latency challenges using AWS-native, low-maintenance GenAI integration patterns.

Option B is the most appropriate solution because it directly aligns with AWS-recommended architectural patterns for building scalable, observable, and resilient generative AI applications on Amazon Bedrock. The requirements clearly distinguish between simple and complex routing decisions, and this option addresses both in an optimal way.

Simple routing based on file extension is latency sensitive. Handling this logic directly in the application code avoids unnecessary orchestration, state transitions, and service calls. This approach ensures that straightforward requests, such as routing images to vision-capable foundation models or text files to language models, are processed with minimal overhead and maximum performance.

For complex routing based on content semantics, AWS Step Functions is specifically designed for multi-step workflows that require analysis, branching logic, and error handling. Semantic routing often requires inspecting meaning, intent, or structure before selecting the appropriate foundation model. Step Functions enables this by orchestrating analysis steps and applying conditional logic to determine the correct model to invoke using the Amazon Bedrock InvokeModel API.

A key requirement is detailed execution history. Step Functions provides built-in execution tracing, including state inputs, outputs, and error details, which is essential for auditing, debugging, and compliance. Additionally, Step Functions supports native retry and catch mechanisms, allowing the workflow to automatically fall back to alternate foundation models if a primary model invocation fails. This directly satisfies the fallback requirement without introducing excessive custom code.

The other options lack one or more critical capabilities. Lambda-only logic lacks deep observability and structured fallback handling, SQS introduces additional latency and limited workflow visibility, and multiple coordinated workflows increase architectural complexity without added benefit.

Option A is the correct answer because Amazon Bedrock Flows is purpose-built to orchestrate generative AI workflows that combine data access, deterministic transformations, and model invocation with minimal operational overhead. The requirements explicitly state that the workflow must retrieve content from Amazon S3, extract a specific portion of a predefined template, send that portion to an Amazon Bedrock model, and store the model’s response back into the same S3 bucket. Amazon Bedrock Flows natively supports all of these steps.

By configuring S3 action nodes at the beginning and end of the flow, the workflow can retrieve the original communications and persist the reviewed output without custom code. The expression step allows deterministic parsing of a specific portion of the template, which is essential when only part of the message should be reviewed. This avoids relying on generative logic for parsing, which would be less predictable and harder to audit. The agent step is then used specifically for the review task, where the foundation model evaluates or modifies the extracted content.

Option B uses AWS Step Functions, which can achieve similar outcomes but requires more explicit orchestration logic and does not provide GenAI-native constructs such as expressions and agent steps in a single managed experience. Options C and D rely on Amazon Bedrock agents and AWS Lambda functions to handle parsing and data movement, which increases complexity, operational overhead, and maintenance burden.

Because Amazon Bedrock Flows directly integrates S3 actions, parsing expressions, and model review steps in a single managed workflow, Option A best meets the requirements with the least development and operational effort.

Option A addresses all three governance layers. Model cards provide documented information about a model’s capabilities, limitations, supported modalities, context constraints, and other characteristics that teams can review before deployment. Amazon Bedrock Guardrails can enforce application-specific safeguards on user inputs and model responses, and IAM policies can require a specific guardrail for inference calls, helping prevent uncontrolled model use. Storing generated outputs in Amazon S3 provides durable audit storage, while S3 Object Lock uses a write-once-read-many model that can prevent retained objects from being overwritten or deleted and is specifically intended to support regulatory retention requirements. Option B lacks formal model-limit documentation and relies on custom postprocessing. Option C does not protect stored audit evidence against tampering. Option D relies primarily on prompts and ordinary database storage rather than enforceable safety and immutable-retention controls. AWS Documentation

================

Option B is the correct solution because Amazon Q Business natively supports access control lists (ACLs) for S3 data sources using a single, centralized JSON file that maps S3 prefixes to IAM Identity Center groups. This approach directly aligns with the company’s data organization model, where each department’s data is stored under a distinct S3 prefix and each employee belongs to exactly one department group.

Using a single acl.json file at the bucket root minimizes operational overhead by centralizing access control logic in one location. Administrators can update department mappings without touching individual folders or changing IAM permissions, which simplifies governance and reduces the risk of configuration drift. Amazon Q Business automatically evaluates the user’s IAM Identity Center group membership at query time and filters accessible documents accordingly.

Option A increases operational complexity by requiring a separate ACL file in every department folder, which becomes difficult to maintain as departments or prefixes change. Option C attempts to enforce access using IAM permissions sets, but Amazon Q Business access control for S3 data sources is not designed to be managed through IAM condition logic and would significantly increase complexity. Option D introduces a custom metadata structure that is not the supported mechanism for Amazon Q Business access enforcement.

Therefore, Option B provides the cleanest, most scalable, and AWS-recommended solution for enforcing department-based access control with the least operational effort.

Option B meets the requirement to combine scalable automated evaluation with targeted human oversight using managed AWS GenAI capabilities. Amazon Bedrock evaluations enable systematic, repeatable quality assessment across large volumes of interactions. Using an LLM-as-a-judge approach with a strong evaluator model such as Anthropic Claude Sonnet allows the company to automatically score outputs for dimensions like factual accuracy, conversational appropriateness, and policy alignment. This directly supports “automated quality evaluations at scale” without building custom scoring models.

However, financial recommendations add higher risk because regulatory compliance requires additional enforcement beyond general quality scoring. Amazon Bedrock guardrails provide a dedicated policy enforcement layer that can block or intervene when responses violate compliance constraints. Guardrails are particularly important for preventing disallowed financial guidance patterns and ensuring consistent behavior across deployments.

The requirement also calls for “targeted human reviews of critical interactions.” Amazon Augmented AI (A2I) is a managed human review service that supports routing specific items to human reviewers based on rules or confidence thresholds. In this design, the system can automatically send only high-risk or policy-flagged interactions to qualified financial experts for review, keeping human effort focused where it matters most while maintaining scale.

Option A is not scalable because it requires manual review of all responses. Option C relies on static rules and end-user feedback, which is insufficient for regulatory compliance and factual accuracy assurance. Option D provides monitoring but not structured quality evaluation or policy enforcement.

Therefore, Option B provides the most complete, AWS-aligned solution for scalable evaluation plus human oversight in a regulated financial context.

Option B is the optimal solution because it maximizes similarity search accuracy and performance for a small, proprietary dataset while maintaining low operational complexity. Amazon MemoryDB is a fully managed, in-memory database that provides microsecond-level latency, making it ideal for real-time RAG workloads that require fast vector similarity searches.

For small datasets with low index counts, the Hierarchical Navigable Small World (HNSW) algorithm is recommended by AWS for its high recall and accuracy. Unlike approximate methods optimized for massive datasets, HNSW excels at returning the most semantically relevant vectors with minimal loss of precision, which directly improves the quality of responses generated by the Amazon Bedrock foundation model.

Vertical scaling in MemoryDB is sufficient for this use case because the dataset size is limited. Scaling up instance size provides increased memory and compute capacity without the complexity of managing distributed indexes or sharding strategies. This simplifies operations while maintaining predictable performance.

Option A’s Flat algorithm is computationally expensive and inefficient at scale, even for moderate query volumes. Option C introduces higher latency and operational overhead by using a relational database not optimized for in-memory vector search. Option D is unsuitable because Amazon DocumentDB is not designed for high-performance vector similarity workloads and introduces unnecessary replica management complexity.

Therefore, Option B best meets the requirements for accuracy, performance, and efficient integration with an Amazon Bedrock–based RAG application.

Option A is the correct solution because it directly addresses all identified failure modes while preserving the existing Step Functions–based orchestration architecture with minimal redesign.

Using Step Functions Map states enables parallel execution of secret resolution workflows, which improves refresh latency for short-lived and expiring secrets. This ensures that secrets are refreshed in time before downstream agents require them. Passing updated secret metadata through Lambda outputs guarantees that subsequent steps always consume the latest resolved values, preventing agents from using stale data even after drift alerts are generated.

Versioning prompt flows in AWS AppConfig is critical to resolving cascading failures caused by outdated templates. AppConfig natively supports version control, validation, staged rollout, and rollback of configuration artifacts. By gating prompt flows through AppConfig, the company can immediately roll back faulty templates and prevent agents from reusing outdated instructions.

This solution maintains clear separation of concerns: Step Functions handle orchestration and parallelism, Lambda handles secret retrieval and metadata propagation, and AppConfig governs prompt lifecycle management. No additional event pipelines or custom retry coordination layers are required.

Option B oversimplifies the architecture and does not address secret lifecycle or drift. Option C introduces event-driven ordering complexity without solving prompt versioning. Option D introduces unnecessary tooling and dynamic prompt generation risk.

Therefore, Option A best resolves performance, correctness, and stability issues while minimizing operational overhead.

Option B is the most appropriate solution because it uses AWS-native, purpose-built data engineering and governance services to address data quality validation, metadata creation, monitoring, and transformation with minimal custom development. AWS Glue is designed specifically for large-scale data preparation and integrates seamlessly with Amazon S3, making it ideal for preprocessing unstructured datasets for downstream GenAI applications.

AWS Glue crawlers automatically infer schemas and populate the AWS Glue Data Catalog, creating auditable, queryable metadata for all datasets. This satisfies the requirement for traceability and governance, which is especially critical in financial services environments. Glue ETL jobs allow teams to implement customizable transformation logic, including text normalization and chunking strategies optimized for foundation model context windows.

AWS Glue Data Quality provides built-in rulesets for validating completeness, accuracy, and consistency. It also publishes quality metrics that can be monitored over time, meeting the requirement for ongoing data quality monitoring without building custom validation frameworks.

Because AWS Glue is fully managed, it eliminates the need to manage infrastructure, scaling, or orchestration. This significantly reduces development and operational effort compared to custom Lambda pipelines or EC2-based processing. The processed and validated data can then be safely ingested into Amazon Bedrock workflows or knowledge bases.

Option A and C require custom logic for validation, monitoring, and chunking, increasing development complexity. Option D introduces unnecessary infrastructure management and services not optimized for data preprocessing.

Therefore, Option B best meets the requirements while minimizing development effort and aligning with AWS Generative AI data preparation best practices.

Option B is the best fit because hierarchical chunking is designed to preserve local detail while keeping broader document context available during retrieval, which directly addresses the problem of questions spanning methodology, results, and discussion. In large scientific papers, a single answer often depends on linked paragraphs across adjacent sections. If the knowledge base retrieves only small, isolated chunks, the RAG system can cite text that is semantically close to a query term but not contextually correct, producing inconsistent answers and irrelevant citations.

With hierarchical chunking, the knowledge base creates child chunks that are small enough for high-precision vector similarity matching, such as 200 tokens, which improves the likelihood that the retrieved text is tightly related to the user’s query. At the same time, each child chunk is associated with a larger parent chunk , such as 1,000 tokens, which retains the surrounding narrative and section-level context. This structure helps the retrieval pipeline return passages that include the relevant subsection plus the explanatory framing that prevents misinterpretation, which is especially important in scientific writing where methods, results, and discussion are interdependent.

The configured overlap further reduces boundary effects where key statements split across chunks. This improves continuity for paragraphs that bridge sections, such as a results paragraph that references the methodological setup or a discussion paragraph interpreting a specific metric.

Option A can improve consistency slightly, but fixed-size chunking still risks separating related paragraphs and does not provide a built-in mechanism to retrieve broader context linked to precise matches. Option C can create more meaningful boundaries, but it does not guarantee the parent-level context that hierarchical chunking provides at retrieval time. Option D increases operational burden and is not practical at the scale of 25 million

Option B is correct because authoritative route and fare calculations must remain outside the language model. AgentCore Gateway can expose backend APIs and Lambda functions as governed tools through a unified interface, allowing the agent to discover and invoke the appropriate service while the deterministic business systems calculate routes, fares, accessibility constraints, and disruptions. Strict tool schemas constrain inputs and outputs, while the model can be limited to interpreting user intent and explaining returned results rather than inventing prices. AgentCore observability provides traces of tool calls and execution paths for regulatory review. New services can be added as Gateway targets without retraining the model. Option A relies on prompt instructions, which cannot guarantee deterministic fares. Option C lets the model synthesize answers from documents. Option D improves orchestration but still does not establish authoritative deterministic tool boundaries. AWS Documentation

================

The combination of Options A and B provides the most scalable and AWS-native architecture for building reasoning agents with persistent memory, session awareness, secure access control, and flexible invocation models.

Amazon Bedrock AgentCore is purpose-built to manage agent memory, session context, and identity-aware reasoning across interactions. It eliminates the need for developers to manually store and retrieve agent state, manage session lifecycles, or implement custom memory layers. AgentCore natively supports both synchronous requests and event-driven execution, making it ideal for support workflow automation.

Option B complements AgentCore by enabling seamless tool invocation. By registering AWS Lambda functions and REST APIs as agent actions through API Gateway and EventBridge, the agent can invoke tools reactively or synchronously without custom orchestration code. EventBridge enables event-driven execution, while API Gateway supports synchronous request-response patterns.

This combination provides built-in security, observability, and scaling, while avoiding the operational burden of managing queues, databases, or custom workflow engines.

Option C introduces unnecessary orchestration complexity. Option D increases infrastructure management and cost. Option E stores agent state in S3, which is not suitable for low-latency, session-based reasoning.

Therefore, A and B together deliver the most scalable, secure, and low-overhead solution for production-grade reasoning agents on AWS.

Option C best satisfies the requirement to change routing decisions without redeploying code while supporting complex, frequently changing business logic at scale. AWS AppConfig is designed for centrally managing dynamic configuration (feature flags, rules, thresholds, and policy parameters) and deploying changes safely. It supports controlled deployments, validation, and rapid propagation of updated configuration values, which aligns with “real-time cost metrics that change hourly” and the need for “immediate propagation across thousands of concurrent requests.”

In this design, the Lambda function becomes the policy decision point. For each request, it evaluates user attributes (tier, transaction value), context (regulatory zone, Region), and live cost/performance thresholds stored in AppConfig to determine which Amazon Bedrock FM to invoke. Because the routing rules and FM identifiers are delivered as configuration, the company can switch models, adjust A/B testing weights, or update compliance routing rules by deploying new AppConfig configuration versions rather than pushing new application code. This reduces operational risk and accelerates iteration.

Exposing a single API Gateway endpoint also minimizes client complexity and keeps routing logic server-side, which is important when rules change frequently. Lambda can cache configuration between invocations (within the execution environment) to reduce repeated fetch overhead while still picking up changes quickly, enabling both low latency and rapid rule rollout under high concurrency.

Option A relies on Lambda environment variables, which are not intended for frequent real-time updates and typically require function configuration updates that are slower and operationally brittle. Option B uses mapping templates and stage variables, which are limited for complex rule evaluation and safe rollout patterns. Option D misuses authorizers for business routing, adds extra latency and complexity, and complicates observability and error handling by splitting decisioning from execution.

Option B best meets the multimodal, ethical, and auditability requirements using managed AWS services designed for research-grade GenAI systems. Multimodal data such as audio, video, sensor telemetry, and tracking data must be curated and summarized before being consumed by a foundation model. Amazon SageMaker Processing and Amazon Transcribe provide scalable, managed preprocessing for audiovisual and textual data.

By ingesting summarized, validated observations into Amazon Bedrock Knowledge Bases, the GenAI assistant can answer natural language queries using grounded, evidence-based context instead of raw sensor signals. This significantly reduces the risk of speculative or anthropomorphic interpretations.

Amazon Bedrock guardrails are critical for preventing speculative behavioral claims, enforcing scientific and ethical constraints at inference time. Guardrails provide a validated, auditable safety layer that custom Lambda-based filters cannot reliably replicate.

AWS AppConfig enables controlled prompt management and change governance, ensuring that research prompts remain consistent and reviewable. AWS CloudTrail captures all access, query, and configuration changes, supporting ethical research audits and regulatory reviews.

Option A lacks grounding and speculative safeguards. Option C focuses on text analytics and does not properly handle multimodal reasoning or safety enforcement. Option D relies heavily on custom logic and introduces unnecessary operational risk.

Therefore, Option B provides the most robust, ethical, and auditable GenAI architecture for wildlife behavior research.

Option B is the correct solution because Amazon Bedrock Prompt Management is purpose-built to manage, govern, and standardize prompt usage at scale across teams and Regions. It provides native version control, allowing teams to track prompt changes over time and ensure that only approved versions are used in production workflows.

Prompt Management supports approval workflows that align with enterprise governance requirements. Approval permissions can be enforced through IAM policies, ensuring that only authorized reviewers can approve or publish prompt versions. This removes the need for custom workflow engines or external storage systems, significantly reducing operational overhead.

Parameterized prompt templates enable consistent prompt structure while allowing controlled variation through defined variables. This ensures consistent quality standards and reduces prompt drift, which is critical when hundreds of prompts are reused across multiple applications and teams.

AWS CloudTrail integrates natively with Amazon Bedrock to provide immutable audit logs for prompt creation, updates, approvals, and usage. These detailed audit trails satisfy compliance requirements and allow security and governance teams to trace prompt activity across Regions and users.

Option A requires significant custom development to coordinate approvals and maintain state. Option C relies on general-purpose workflow services and manual versioning mechanisms that are error-prone and difficult to scale. Option D uses services not designed for large-scale GenAI prompt governance and introduces unnecessary complexity.

Therefore, Option B best meets the requirements for scalable, auditable, and low-overhead governance of AI-generated content using Amazon Bedrock.

Option C cleanly separates rapidly changing routing configuration from application code. AWS AppConfig Agent is the AWS-recommended mechanism for retrieving configuration data and maintains a local cache while asynchronously polling AppConfig for updates. In Lambda environments, the extension periodically refreshes configuration in the background and lets functions retrieve cached values locally with very low latency. The Lambda function can therefore evaluate proprietary rules involving user tier, transaction value, Region, compliance constraints, and current model costs without redeployment. Model identifiers and routing thresholds can change independently through AppConfig while API Gateway exposes one stable application endpoint. Option A requires environment-variable modifications and Lambda configuration updates. Option B makes API Gateway transformation templates responsible for complex business decisions. Option D incorrectly couples model-routing decisions with authorization logic and requires separate model-specific Lambda functions, reducing flexibility. AWS Documentation

================

Option B is correct because the retrieval problem requires filtering before semantic similarity search, not merely returning metadata after retrieval. Amazon Bedrock Knowledge Bases can apply filters to metadata associated with source documents, so timestamp, author, and research-domain attributes can restrict the candidate set before vector results are returned. This prevents old, wrong-domain, or unauthorized-author documents from entering the retrieved context. AWS also documents S3 knowledge-base metadata files and filterable metadata attributes. Option A only returns metadata with already-selected vector results, so irrelevant documents can still be retrieved. Option C introduces DynamoDB and a two-stage custom retrieval path. Option D adds Comprehend and Aurora, increasing operational complexity. The key design principle is to make the required attributes filterable in the vector retrieval layer. AWS Documentation

================

Option C best satisfies the requirements because it combines application-aware observability, metric baselining, anomaly detection, and correlated alerting using fully managed AWS services with minimal operational overhead. Amazon CloudWatch Application Insights is designed to automatically monitor application health by analyzing metrics, logs, and events across EC2-based workloads. This aligns directly with the need to detect intermittent performance issues and deviations from expected behavior.

By publishing custom metrics using the CloudWatch embedded metric format, the application can track generative AI–specific signals such as recommendation quality indicators, token usage, request volume, and response latency from Amazon Bedrock foundation model calls. Adding di mensions such as request type or user segment enables fine-grained visibility into which workloads or customer groups are impacted when recommendation quality degrades.

A critical requirement is detecting degradation compared to established baselines and generating alerts within 10 minutes. CloudWatch anomaly detection automatically builds statistical models of normal behavior for time-series metrics and flags deviations without requiring manually tuned thresholds. This capability is well suited for monitoring foundation model behavior, which can vary subtly over time. When anomalies are detected, CloudWatch alarms can trigger notifications with contextual metric data quickly, meeting the alerting requirement.

CloudWatch Logs Insights complements the metric-based view by enabling log pattern analysis and correlation. Engineers can query application logs and model response logs to identify recurring error patterns or shifts in output behavior that explain why recommendations no longer align with user preferences. Application Insights further correlates metrics and logs to surface probable root causes, reducing mean time to resolution.

The other options lack one or more critical elements. Option A focuses on infrastructure-level metrics without baseline anomaly detection. Option B emphasizes tracing and auditing but does not provide automated performance deviation analysis. Option D offers flexibility but requires significantly more development and operational effort than a native CloudWatch-based solution.

Option C best meets the requirements by aligning with AWS best practices for data isolation, access control, and scalable GenAI retrieval. Implementing a separate Amazon Bedrock knowledge base for each hotel ensures strict separation of data and permissions. This approach naturally enforces hotel-level access control without requiring complex policy logic or post-query filtering.

A multi-account structure further strengthens security and governance by isolating each hotel’s data plane. AWS recommends account-level isolation for workloads with strong tenancy or compliance boundaries. Hotel staff can be granted access only to their hotel’s account and corresponding knowledge base, eliminating the risk of cross-hotel data exposure.

Direct data ingestion into each knowledge base enables near real-time updates for critical data such as room availability. For information that does not change frequently, scheduled synchronization reduces ingestion cost while maintaining accuracy. This hybrid ingestion model balances freshness and operational efficiency.

Because Amazon Bedrock Knowledge Bases are fully managed, performance remains consistent during peak usage periods without the company managing indexing, scaling, or retrieval infrastructure. Each knowledge base scales independently, preventing noisy-neighbor issues that could arise in a centralized design.

Option A and B rely on a centralized knowledge base, which increases policy complexity and introduces risk of misconfigured access controls. Option D adds unnecessary orchestration complexity and does not inherently solve real-time data freshness requirements.

Therefore, Option C provides the most secure, scalable, and operationally efficient solution for enhancing the PMS with Amazon Bedrock Knowledge Bases.

Option D is the correct solution because the Amazon Bedrock Converse API is purpose-built for multi-turn conversational interactions and is designed to work consistently across SDKs and compute environments. The Converse API standardizes how messages, roles, and context are represented, which ensures consistent behavior whether the application is running in AWS Lambda with Python or in Amazon EKS with JavaScript.

By passing previous messages in the messages array, the application explicitly maintains conversational context across turns without relying on external state stores. This approach is recommended by AWS for conversational GenAI workflows because it avoids state synchronization complexity and ensures deterministic model behavior across environments.

Using IAM roles for authentication provides a single, consistent security model for both Lambda and EKS. IAM roles integrate natively with AWS SDKs, eliminating the need for custom authentication logic or environment-specific credentials. This aligns with AWS best practices for least privilege and simplifies governance.

Option A introduces inconsistent authentication and custom formatting logic, increasing complexity. Option B unnecessarily introduces ElastiCache for state management, which is not required when using the Converse API correctly. Option C stores state in process memory, which is unsafe and unreliable for serverless and containerized workloads.

Therefore, Option D best satisfies the requirements for conversational consistency, multi-environment support, shared model usage, and consistent authentication with minimal operational overhead.

Option A is the only choice that establishes controls across the complete input-inference-output path. Amazon Bedrock Guardrails provides managed safeguards that evaluate model prompts and responses. AWS explicitly supports a PROMPT_ATTACK content-filter category designed to detect jailbreaks, prompt injection, and—with the appropriate tier—prompt leakage. Prompt injection attempts try to override developer instructions, while jailbreaks attempt to circumvent native model safety controls.

When using Guardrails with model invocation APIs, applications can mark untrusted user content with guardrail input tags so that the prompt-attack filter evaluates the user-controlled portion without incorrectly treating developer or system instructions as adversarial content. Guardrails can then block detected prompt attacks before unsafe content is processed. Content filters and other guardrail policies can also inspect generated model responses before they reach the end user.

AWS also recommends associating a Guardrail with Amazon Bedrock agents to help protect against prompt injection. System prompts remain useful as a defense-in-depth technique because they define the agent ' s scope, but AWS does not treat system prompting alone as an adequate security boundary.

The Lambda sanitization and output-validation portions of A can provide additional application-specific checks. In a modern implementation, Guardrails itself can perform substantially more of the input and output filtering, reducing the amount of custom Lambda logic required.

B relies entirely on probabilistic prompting and therefore lacks deterministic managed enforcement. C is fundamentally unsafe because authenticated users can still be malicious or compromised. D is reactive monitoring: logging and periodically searching historical prompts may help investigations, but it does not prevent an attack before inference or block unsafe responses.

Therefore, A is the only listed design that combines pre-processing controls, managed inference-time safeguards, and output validation.

==========

Option B is the most appropriate solution because it directly uses Amazon Bedrock cross-Region inference profiles, which are designed to provide resilience and load distribution while respecting data residency boundaries. Cross-Region inference profiles allow applications to distribute inference requests across multiple Regions within a defined geographic boundary, such as Europe or North America, without requiring custom failover logic.

By specifying geographical codes in the inference profile ID, the application ensures that European user data is processed only within Europe-based Regions, satisfying regulatory requirements. At the same time, Bedrock automatically routes requests to healthy Regions within that geography when traffic spikes or service quotas are reached, improving availability and maintaining low latency.

Using separate Amazon API Gateway HTTP APIs for Europe and North America provides a clean, simple routing layer that directs users to the appropriate regional inference profile. This avoids complex custom routing or retry logic in application code and minimizes operational overhead.

Option A relies on custom routing and manual monitoring, which increases complexity and does not provide automatic resilience. Option C introduces custom retry and fallback logic that risks violating data residency requirements if misconfigured. Option D requires significant application-level failover logic and adds operational burden with Global Accelerator configuration.

Therefore, Option B best meets the requirements for low latency, data residency compliance, resilience during traffic spikes, and minimal operational complexity.

Option A best satisfies the requirement to capture multi-hop, highly interconnected relationships with minimal operational overhead. Traditional vector similarity search excels at finding semantically similar text but is not optimized for reasoning over explicit entity-to-entity relationships, especially when analysts need indirect, multi-hop connections (for example, fund ? holding ? issuer ? sector ? regulation). Graph-based retrieval is designed specifically for these kinds of relationship traversals.

GraphRAG combines retrieval-augmented generation with graph-aware context selection. By representing entities and their relationships in a graph store, the system can traverse multiple hops to assemble a holistic set of relevant facts. This improves completeness and reduces the chance that the model misses indirect relationships that are essential for accurate investment guidance.

Amazon Neptune Analytics provides a managed graph analytics environment capable of efficiently traversing and analyzing complex relationship networks. When integrated with Amazon Bedrock Knowledge Bases, it reduces custom engineering by providing managed ingestion, retrieval, and orchestration patterns suitable for GenAI applications. This lowers operational overhead compared to building and maintaining custom multi-stage retrieval logic.

Meeting the sub-3-second requirement is also more feasible with a graph-optimized engine because multi-hop traversals can be executed efficiently compared to chaining multiple vector searches and joining results in an application layer. The managed nature of Knowledge Bases and Neptune Analytics reduces maintenance, scaling, and operational burden while enabling strong performance.

Option B and C require extensive custom logic and orchestration, increasing complexity and latency. Option D is not designed for graph-style multi-hop exploration and would require significant custom indexing and retrieval logic.

Therefore, Option A is the most AWS-aligned and operationally efficient approach for multi-hop relationship-aware RAG with strong performance.

Option C is the correct solution because AWS AppConfig is designed for real-time, validated, centrally managed configuration changes with safe rollout, immediate propagation, and rollback support—exactly matching the company’s requirements.

By storing routing rules, cost thresholds, regulatory constraints, and A/B testing logic in AWS AppConfig, the company can switch between Amazon Bedrock foundation models without redeploying Lambda code. AppConfig supports feature flags, dynamic configuration updates, JSON schema validation, and staged rollouts, which are essential for safely managing complex and frequently changing routing logic.

Using the AWS AppConfig Agent, Lambda functions can retrieve cached configurations efficiently, ensuring low latency even under thousands of concurrent requests. This approach allows the Lambda function to apply proprietary business logic—such as user tier, transaction value, Region compliance, and real-time cost metrics—before selecting the appropriate FM.

Option A is operationally fragile because environment variable changes require function restarts and do not support validation or controlled rollouts. Option B is too limited for complex, dynamic logic and is difficult to maintain at scale. Option D misuses Lambda authorizers, which are intended for authentication and authorization, not high-frequency dynamic routing decisions.

Therefore, Option C provides the most scalable, flexible, and low-overhead architecture for dynamic, regulation-aware FM routing in a global GenAI system.

Option D requires the least development effort because it uses a managed retrieval workflow that bundles the most time-consuming parts of semantic search: embedding generation, vector indexing, and natural language retrieval. With an Amazon Bedrock knowledge base, the application does not need to implement and operate separate services to (1) generate embeddings for hundreds of millions of records, (2) store and manage vectors, (3) build query-time embedding conversion logic, and (4) implement k-NN search orchestration. Instead, the knowledge base is configured to automatically create embeddings during ingestion, and the application queries it using the Amazon Bedrock Retrieve API , which accepts natural language input and performs the vector search as a managed capability.

The performance requirement (95% of queries within 500 ms) is best served by a purpose-built vector search backend rather than running similarity search directly inside a transactional PostgreSQL system at this scale. A knowledge base is designed for retrieval patterns and can be backed by scalable vector stores, which helps meet latency goals under heavy concurrency. The hourly freshness requirement maps naturally to ingestion updates: the pipeline can re-ingest updated restaurant details on a schedule so the knowledge base remains current without building custom re-embedding workflows in application code.

Cost-effective scaling during peak periods is also easier with a managed retrieval layer because scaling the retrieval workload is separated from the operational database. This avoids overprovi sioning PostgreSQL for peak semantic-search traffic and reduces the engineering effort to tune performance, sharding, indexing, and retry logic.

Options B and C can work, but they require the team to build and maintain embedding pipelines, query embedding generation, vector index management, and operational scaling strategies. Option A does not provide semantic search because it relies on keyword-based matching rather than embeddings.