{"id":12563,"date":"2026-09-15T10:19:11","date_gmt":"2026-09-15T10:19:11","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=12563"},"modified":"2026-09-15T10:19:11","modified_gmt":"2026-09-15T10:19:11","slug":"amazon-aws-certified-generative-ai-developer-professional-aip-c01-practice-test-questions-and-exam-dumps-part7-q121-140","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/amazon-aws-certified-generative-ai-developer-professional-aip-c01-practice-test-questions-and-exam-dumps-part7-q121-140\/","title":{"rendered":"Amazon AWS Certified Generative AI Developer – Professional AIP-C01 Practice Test Questions and Exam Dumps Part7 Q121-140"},"content":{"rendered":"

View Full Amazon AWS Certified Generative AI Developer – Professional AIP-C01 Exam Dumps<\/a> and Practice Test Dumps<\/b><\/h2>\n

 <\/p>\n

Question 121<\/b><\/h3>\n

Which Amazon Bedrock capability allows an agent to interact with external applications?<\/b><\/p>\n

    \n
  1. Knowledge Bases<\/span><\/li>\n
  2. Model evaluation<\/span><\/li>\n
  3. Action groups<\/span><\/li>\n
  4. Model invocation logging<\/span><\/li>\n<\/ol>\n

    Correct Answer: 3<\/b><\/p>\n

    Explanation<\/b><\/p>\n

    Action groups allow Amazon Bedrock Agents to perform specific actions by connecting the agent to APIs or AWS Lambda functions. They are useful when an agent needs to retrieve information from or perform operations in an external application. For example, a customer-service agent could use an action group to retrieve a customer’s order status from an internal system. Knowledge Bases are primarily used for retrieving information from data sources, while evaluation and logging are used for testing and monitoring rather than external application interaction.<\/span><\/p>\n

    Question 122<\/b><\/h3>\n

    A developer needs to coordinate a workflow containing validation, retrieval, model invocation, and response processing. Which AWS service is most appropriate?<\/b><\/p>\n

      \n
    1. Amazon S3<\/span><\/li>\n
    2. AWS Step Functions<\/span><\/li>\n
    3. Amazon CloudWatch<\/span><\/li>\n
    4. Amazon OpenSearch Service<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2<\/b><\/p>\n

      Explanation<\/b><\/p>\n

      AWS Step Functions is designed to coordinate multiple application tasks through state machines. A generative AI workflow can use Step Functions to execute validation, data retrieval, model invocation, response evaluation, and storage in a defined sequence. It also supports branching, retries, error handling, and parallel execution. This makes it useful for complex AI workflows where each step has specific conditions or dependencies. Amazon S3 provides storage, CloudWatch provides monitoring, and OpenSearch provides search capabilities rather than workflow orchestration.<\/span><\/p>\n

      Question 123<\/b><\/h3>\n

      Which combination can expose a serverless REST API that invokes AWS Lambda?<\/b><\/p>\n

        \n
      1. Amazon API Gateway and AWS Lambda<\/span><\/li>\n
      2. Amazon S3 and Amazon DynamoDB<\/span><\/li>\n
      3. AWS CloudTrail and Amazon CloudWatch<\/span><\/li>\n
      4. Amazon OpenSearch and Amazon S3<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1<\/b><\/p>\n

        Explanation<\/b><\/p>\n

        Amazon API Gateway can expose HTTP or REST endpoints and route incoming requests to AWS Lambda functions. Lambda can process the request, invoke a generative AI service such as Amazon Bedrock, and return the result to the client. This architecture avoids the need to manage traditional application servers. API Gateway can also provide features such as authentication, throttling, and request validation. The other options provide storage, monitoring, auditing, or search capabilities but do not provide the required API-to-Lambda integration.<\/span><\/p>\n

        Question 124<\/b><\/h3>\n

        A banking assistant must retrieve a customer’s current account balance from an external API. Which approach is most appropriate?<\/b><\/p>\n

          \n
        1. Fine-tune the foundation model<\/span><\/li>\n
        2. Use an agent action to call the API<\/span><\/li>\n
        3. Increase the embedding dimensions<\/span><\/li>\n
        4. Increase the model temperature<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2<\/b><\/p>\n

          Explanation<\/b><\/p>\n

          An agent action allows a generative AI agent to interact with external systems and retrieve current information. The action can invoke an API or Lambda function that communicates with the banking application and returns the customer’s latest balance. This approach is preferable because account balances are dynamic and should not be stored as static knowledge for the model. Fine-tuning does not provide real-time access to external systems, while embedding dimensions and temperature do not enable API interaction.<\/span><\/p>\n

          Question 125<\/b><\/h3>\n

          Which security principle should be used when assigning permissions to an AI application’s IAM role?<\/b><\/p>\n

            \n
          1. Full administrative access<\/span><\/li>\n
          2. Shared credentials<\/span><\/li>\n
          3. Least privilege<\/span><\/li>\n
          4. Permanent access keys<\/span><\/li>\n<\/ol>\n

            Correct Answer: 3<\/b><\/p>\n

            Explanation<\/b><\/p>\n

            The principle of least privilege means granting an identity only the permissions required to perform its intended tasks. For a generative AI application, an IAM role should have access only to the specific AWS resources and operations it needs. This reduces the potential impact of compromised credentials, application vulnerabilities, or unintended actions. Giving an AI application administrator-level permissions unnecessarily increases security risk. Temporary credentials, carefully scoped IAM policies, and regular permission reviews can further strengthen the application’s overall security posture.<\/span><\/p>\n

            Question 126<\/b><\/h3>\n

            A RAG application contains company policies that are updated every month. The AI assistant must always retrieve the latest version without retraining the foundation model. What should the developer implement?<\/b><\/p>\n

              \n
            1. A document ingestion and re-indexing pipeline<\/span><\/li>\n
            2. A higher model temperature<\/span><\/li>\n
            3. A larger output token limit<\/span><\/li>\n
            4. A prompt containing every policy<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1<\/b><\/p>\n

              Explanation<\/b><\/p>\n

              A document ingestion and re-indexing pipeline allows updated source documents to be processed and reflected in the retrieval system. When a policy changes, the pipeline can identify the updated document, process its content, generate embeddings when required, and update the index. The foundation model does not need to be retrained for every factual change. This approach is more scalable than placing all policies inside prompts. Temperature and output token limits affect generation behavior but do not make the underlying knowledge source more current.<\/span><\/p>\n

              Question 127<\/b><\/h3>\n

              A generative AI application repeatedly sends a large, unchanged system prompt with every request. The company wants to reduce unnecessary token processing. What should the developer investigate?<\/b><\/p>\n

                \n
              1. Prompt caching<\/span><\/li>\n
              2. Higher temperature<\/span><\/li>\n
              3. Larger vector dimensions<\/span><\/li>\n
              4. More retrieved documents<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1<\/b><\/p>\n

                Explanation<\/b><\/p>\n

                Prompt caching can reduce repeated processing of unchanged prompt content when supported by the selected model and architecture. This can be useful for applications that repeatedly send large system instructions, reusable context, or other stable content. Developers should also review prompts and remove unnecessary information to reduce token consumption. Increasing temperature does not reduce prompt processing, while larger vector dimensions affect embeddings. Retrieving more documents can actually increase the amount of context sent to the model and potentially increase both latency and cost.<\/span><\/p>\n

                Question 128<\/b><\/h3>\n

                A RAG application fails to retrieve relevant documents when users use different words with the same meaning. Which approach can improve retrieval?<\/b><\/p>\n

                  \n
                1. Exact keyword matching only<\/span><\/li>\n
                2. Semantic search using embeddings<\/span><\/li>\n
                3. Increasing model temperature<\/span><\/li>\n
                4. Removing document metadata<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 2<\/b><\/p>\n

                  Explanation<\/b><\/p>\n

                  Semantic search uses embeddings to represent the meaning of queries and documents instead of relying only on exact words. This allows a query to retrieve relevant information even when the user’s wording differs significantly from the wording in the source documents. For example, a user asking about “employee time away” could retrieve content describing a company’s “leave policy.” Embedding-based retrieval is therefore valuable for natural-language RAG applications. Temperature affects response generation rather than document matching, while removing metadata can reduce useful retrieval information.<\/span><\/p>\n

                  Question 129<\/b><\/h3>\n

                  A company has created a new prompt for a customer-support assistant and wants to determine whether it performs better than the existing production prompt. What should the developer do?<\/b><\/p>\n

                    \n
                  1. Delete the existing prompt<\/span><\/li>\n
                  2. Increase model temperature<\/span><\/li>\n
                  3. Compare both prompts using a fixed evaluation dataset<\/span><\/li>\n
                  4. Disable response monitoring<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 3<\/b><\/p>\n

                    Explanation<\/b><\/p>\n

                    A fixed evaluation dataset provides a consistent basis for comparing different prompt versions. The existing production prompt can serve as the baseline, while the new prompt is tested against the same representative questions. Developers can compare metrics such as correctness, relevance, groundedness, safety, and format compliance. This provides objective evidence about whether the new prompt actually improves performance. Deleting the current prompt removes the baseline, while changing temperature or disabling monitoring introduces unnecessary variables that can make the comparison less reliable.<\/span><\/p>\n

                    Question 130<\/b><\/h3>\n

                    A generative AI application performs document processing that can take several minutes. Users should not have to keep an HTTP connection open while processing occurs. Which architecture is most appropriate?<\/b><\/p>\n

                      \n
                    1. A synchronous request with a very long timeout<\/span><\/li>\n
                    2. An event-driven asynchronous workflow<\/span><\/li>\n
                    3. A larger prompt<\/span><\/li>\n
                    4. A higher model temperature<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2<\/b><\/p>\n

                      Explanation<\/b><\/p>\n

                      An event-driven asynchronous architecture allows an application to accept a request and process it separately from the user’s initial connection. The request can be placed onto a queue or event system, while a worker processes the task in the background. The application can provide a job identifier or notification mechanism so the user can retrieve the result later. This approach improves scalability and resilience for long-running operations. A long synchronous timeout can create resource and reliability problems, while prompt size and temperature do not address asynchronous processing.<\/span><\/p>\n

                      Question 131<\/b><\/h3>\n

                      A developer wants a foundation model to return customer information using a predefined JSON structure. What should the developer use?<\/b><\/p>\n

                        \n
                      1. Structured output<\/span><\/li>\n
                      2. Higher temperature<\/span><\/li>\n
                      3. Fewer instructions<\/span><\/li>\n
                      4. Unrelated retrieved documents<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1<\/b><\/p>\n

                        Explanation<\/b><\/p>\n

                        Structured output capabilities can help ensure that model responses follow a predefined schema containing expected fields and data types. The developer should specify the required structure clearly and validate the returned response before passing it to downstream application components. Application-side validation is important because model output can still be incomplete or malformed in some situations. Increasing temperature generally increases variability and does not improve structural reliability. Unrelated documents can add noise and make it more difficult for the model to consistently follow the required output format.<\/span><\/p>\n

                        Question 132<\/b><\/h3>\n

                        A company wants an AI assistant to answer questions using internal product documentation. The documentation changes frequently, but the company does not want to retrain the foundation model after every update. Which solution is most appropriate?<\/b><\/p>\n

                          \n
                        1. Fine-tune the model after every document update<\/span><\/li>\n
                        2. Use a knowledge base with RAG<\/span><\/li>\n
                        3. Increase model temperature<\/span><\/li>\n
                        4. Store the documents in application logs<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2<\/b><\/p>\n

                          Explanation<\/b><\/p>\n

                          A knowledge base combined with retrieval-augmented generation allows an application to retrieve current information from external data sources during inference. When product documentation changes, the ingestion and indexing process can update the retrieval layer without modifying the foundation model. This makes RAG suitable for frequently changing factual information such as product specifications, policies, and support documentation. Fine-tuning is generally more appropriate when the goal is to influence model behavior or specialized patterns rather than continuously updating factual knowledge.<\/span><\/p>\n

                          Question 133<\/b><\/h3>\n

                          An enterprise AI agent can access several internal APIs. The security team wants to ensure that the agent can perform only approved operations. Which design provides the strongest control?<\/b><\/p>\n

                            \n
                          1. Give the agent administrator permissions<\/span><\/li>\n
                          2. Define approved actions with least-privilege permissions<\/span><\/li>\n
                          3. Allow unrestricted tool access<\/span><\/li>\n
                          4. Remove authentication from the APIs<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 2<\/b><\/p>\n

                            Explanation<\/b><\/p>\n

                            Approved actions should be explicitly defined and supported by narrowly scoped permissions. This limits the operations that the agent can perform and reduces the potential consequences of incorrect model decisions, prompt injection, or compromised application components. Downstream APIs should also enforce authorization rather than relying entirely on the model to make security decisions. Administrator permissions and unrestricted tool access create unnecessary risk. Removing authentication is especially dangerous because it could allow unauthorized users or services to invoke sensitive operations.<\/span><\/p>\n

                            Question 134<\/b><\/h3>\n

                            A Bedrock agent has two tools with similar purposes and frequently selects the wrong one. What should the developer change first?<\/b><\/p>\n

                              \n
                            1. Make tool names and descriptions more precise<\/span><\/li>\n
                            2. Add more unrelated tools<\/span><\/li>\n
                            3. Remove parameter descriptions<\/span><\/li>\n
                            4. Increase temperature<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1<\/b><\/p>\n

                              Explanation<\/b><\/p>\n

                              Agent tool selection depends heavily on tool names, descriptions, parameters, and usage instructions. When multiple tools have similar purposes, ambiguous descriptions can cause the model to select the wrong action. Developers should use descriptive tool names and clearly explain what each tool does, when it should be used, and what inputs it requires. Removing parameter information reduces useful context, while adding unrelated tools increases complexity. Increasing temperature can make tool selection more variable rather than reliably improving the agent’s ability to select the correct action.<\/span><\/p>\n

                              Question 135<\/b><\/h3>\n

                              Where should an application securely store an external API key that is required during runtime?<\/b><\/p>\n

                                \n
                              1. Source code<\/span><\/li>\n
                              2. AWS Secrets Manager<\/span><\/li>\n
                              3. A public S3 bucket<\/span><\/li>\n
                              4. A model prompt<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2<\/b><\/p>\n

                                Explanation<\/b><\/p>\n

                                AWS Secrets Manager is designed to securely store sensitive information such as API keys, passwords, and other application credentials. Applications can retrieve secrets at runtime while access can be controlled through IAM policies. Secrets Manager can also support secret rotation according to organizational requirements. Hard-coding credentials in source code or placing them inside prompts can expose them through repositories, logs, model interactions, or accidental disclosure. A public S3 bucket is clearly unsuitable for sensitive credentials. Secrets should therefore be separated from application code and model input.<\/span><\/p>\n

                                Question 136<\/b><\/h3>\n

                                A company stores confidential documents in Amazon S3 and requires centralized management of encryption keys. Which AWS service should it use?<\/b><\/p>\n

                                  \n
                                1. AWS KMS<\/span><\/li>\n
                                2. Amazon CloudWatch<\/span><\/li>\n
                                3. AWS Lambda<\/span><\/li>\n
                                4. Amazon API Gateway<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1<\/b><\/p>\n

                                  Explanation<\/b><\/p>\n

                                  AWS Key Management Service provides centralized creation, management, and control of cryptographic keys used to protect data. Amazon S3 can use KMS keys for server-side encryption, allowing organizations to apply appropriate access policies and auditing around key usage. KMS is particularly valuable for enterprise AI applications that process confidential or regulated information. CloudWatch is primarily a monitoring service, Lambda provides compute, and API Gateway provides API management. Encryption should also be combined with IAM controls, logging, and appropriate data-access restrictions for comprehensive protection.<\/span><\/p>\n

                                  Question 137<\/b><\/h3>\n

                                  Which Amazon Bedrock capability can help filter undesirable content in generative AI applications?<\/b><\/p>\n

                                    \n
                                  1. Amazon S3 Versioning<\/span><\/li>\n
                                  2. AWS Step Functions<\/span><\/li>\n
                                  3. Amazon Bedrock Guardrails<\/span><\/li>\n
                                  4. DynamoDB Streams<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 3<\/b><\/p>\n

                                    Explanation<\/b><\/p>\n

                                    Amazon Bedrock Guardrails provides configurable controls designed to improve the safety of generative AI applications. Developers can use guardrails to address unwanted content categories, topic restrictions, and other supported safety requirements. Guardrails can be integrated into supported model interactions and application workflows. S3 Versioning protects historical object versions, Step Functions manages workflows, and DynamoDB Streams captures database changes. Guardrails are therefore the most directly relevant capability when an application needs controls for potentially harmful, inappropriate, or otherwise restricted generative AI content.<\/span><\/p>\n

                                    Question 138<\/b><\/h3>\n

                                    During a security investigation, an organization needs to determine which AWS identity made specific API calls against resources used by its generative AI application. Which service should the organization examine?<\/b><\/p>\n

                                      \n
                                    1. Amazon S3<\/span><\/li>\n
                                    2. Amazon CloudWatch<\/span><\/li>\n
                                    3. AWS CloudTrail<\/span><\/li>\n
                                    4. Amazon Bedrock Knowledge Bases<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 3<\/b><\/p>\n

                                      Explanation<\/b><\/p>\n

                                      AWS CloudTrail records AWS API activity and provides information that can help identify which identity or service performed an operation. CloudTrail events can include details such as the API operation, identity, resource, timestamp, and request information. These records are valuable for security investigations, compliance, governance, and auditing. CloudWatch provides operational monitoring and log analysis, but CloudTrail is specifically designed to record AWS API activity. S3 provides storage, while Knowledge Bases support information retrieval rather than API auditing.<\/span><\/p>\n

                                      Question 139<\/b><\/h3>\n

                                      A RAG application retrieves relevant documents, but the model sometimes adds unsupported information. What should the developer prioritize?<\/b><\/p>\n

                                        \n
                                      1. Increase temperature<\/span><\/li>\n
                                      2. Instruct the model to answer only from retrieved context<\/span><\/li>\n
                                      3. Remove the retrieval system<\/span><\/li>\n
                                      4. Add unrelated documents<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 2<\/b><\/p>\n

                                        Explanation<\/b><\/p>\n

                                        When retrieval quality is good but the model generates unsupported claims, the generation stage should be constrained more strongly. Prompt instructions can require the model to answer only from the retrieved evidence, avoid unsupported statements, and indicate when the available context is insufficient. Groundedness evaluation can also identify unsupported claims during testing. Increasing temperature can increase output variability and potentially worsen hallucinations. Removing retrieval eliminates useful evidence, while unrelated documents add noise. Grounded generation instructions combined with evaluation provide a stronger approach to reducing unsupported responses.<\/span><\/p>\n

                                        Question 140<\/b><\/h3>\n

                                        After deploying a new version of a generative AI application, response latency increases significantly. What should the developer do first?<\/b><\/p>\n

                                          \n
                                        1. Immediately replace the foundation model<\/span><\/li>\n
                                        2. Disable logging<\/span><\/li>\n
                                        3. Review monitoring, logs, and traces to locate the bottleneck<\/span><\/li>\n
                                        4. Increase model temperature<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3<\/b><\/p>\n

                                          Explanation<\/b><\/p>\n

                                          The first step in troubleshooting increased latency should be identifying where the additional delay occurs. Monitoring metrics, logs, traces, model invocation information, and infrastructure telemetry can reveal whether the problem comes from retrieval, model inference, network communication, tool execution, or another downstream component. Once the bottleneck is identified, the developer can apply a targeted optimization. Replacing the model without investigation may create additional problems, while disabling logging removes valuable diagnostic information. Temperature changes generation behavior and is not an appropriate first response to application latency.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Amazon AWS Certified Generative AI Developer – Professional AIP-C01 Exam Dumps and Practice Test Dumps   Question 121 Which Amazon Bedrock capability allows an agent to interact with external applications? Knowledge Bases Model evaluation Action groups Model invocation logging Correct Answer: 3 Explanation Action groups allow Amazon Bedrock Agents to perform specific actions […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/12563"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=12563"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/12563\/revisions"}],"predecessor-version":[{"id":12589,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/12563\/revisions\/12589"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=12563"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=12563"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=12563"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}