{"id":18127,"date":"2026-09-22T05:35:59","date_gmt":"2026-09-22T05:35:59","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18127"},"modified":"2026-09-22T05:35:59","modified_gmt":"2026-09-22T05:35:59","slug":"databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part3-q41-60","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part3-q41-60\/","title":{"rendered":"Databricks Certified Generative AI Engineer Associate Practice Test Questions and Exam Dumps Part3 Q41-60"},"content":{"rendered":"

View Full <\/b>Databricks Certified Generative AI Engineer Associate Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/p>\n

 <\/p>\n

Question 41. What is the main purpose of a tokenizer in a generative AI system?<\/b><\/p>\n

    \n
  1. <\/b> To convert input text into tokens that the model can process<\/span><\/li>\n
  2. <\/b> To create database tables<\/span><\/li>\n
  3. <\/b> To manage user permissions<\/span><\/li>\n
  4. <\/b> To monitor GPU temperature<\/span><\/li>\n<\/ol>\n

    Correct Answer: 1. To convert input text into tokens that the model can process<\/b><\/p>\n

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

    A tokenizer converts text into smaller units called tokens that can be processed by a language model. Depending on the tokenizer, a token may represent a complete word, part of a word, punctuation, or another text unit. Tokenization is important because language models operate on token representations rather than raw text characters in the same form users see. The number of tokens in a prompt also affects context-window usage and can influence inference cost and latency. In a RAG application, both the user’s query and retrieved context ultimately need to fit within the model’s supported context limits. Therefore, understanding tokenization is useful when designing prompts and managing retrieved information.<\/span><\/p>\n

    Question 42. What does a model’s context window determine?<\/b><\/p>\n

      \n
    1. <\/b> The physical size of the serving cluster<\/span><\/li>\n
    2. <\/b> The amount of input and output token context the model can handle<\/span><\/li>\n
    3. <\/b> The number of users allowed in Unity Catalog<\/span><\/li>\n
    4. <\/b> The number of vector indexes in a workspace<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2. The amount of input and output token context the model can handle<\/b><\/p>\n

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

      A model’s context window defines how much tokenized information can be considered during an inference request, subject to the model’s specific limits. This can include system instructions, user prompts, retrieved documents, conversation history, and generated output. Context-window size is particularly important in RAG applications because retrieved chunks must fit alongside the user’s question and application instructions. If too much information is included, the application may exceed the model’s supported token limit or consume resources unnecessarily. Effective retrieval and chunking help provide relevant information without overwhelming the context. The context window is therefore an important design consideration when selecting models and constructing prompts.<\/span><\/p>\n

      Question 43. Which technique can help reduce the amount of irrelevant information passed to a language model?<\/b><\/p>\n

        \n
      1. <\/b> Increasing the number of unrelated documents<\/span><\/li>\n
      2. <\/b> Removing all retrieval<\/span><\/li>\n
      3. <\/b> Improving retrieval and reranking relevant results<\/span><\/li>\n
      4. <\/b> Disabling metadata<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. Improving retrieval and reranking relevant results<\/b><\/p>\n

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

        Improving retrieval quality can reduce the amount of irrelevant information supplied to a language model. A retrieval system can first identify candidate documents or chunks, while a reranker can reorder those candidates based on their relevance to the user’s query. Selecting a smaller set of high-quality results can help the model focus on useful evidence and conserve context-window capacity. Poor retrieval may introduce unrelated information, making it more difficult for the model to identify the correct context. Simply removing retrieval would eliminate the grounding benefits of a RAG architecture. Therefore, better retrieval and ranking are important techniques for constructing focused and useful model context.<\/span><\/p>\n

        Question 44. What is one benefit of using a smaller document chunk size in a RAG system?<\/b><\/p>\n

          \n
        1. <\/b> It always eliminates hallucinations<\/span><\/li>\n
        2. <\/b> It can provide more precise retrieval for narrowly focused questions<\/span><\/li>\n
        3. <\/b> It removes the need for embeddings<\/span><\/li>\n
        4. <\/b> It guarantees lower inference cost<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2. It can provide more precise retrieval for narrowly focused questions<\/b><\/p>\n

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

          Smaller document chunks can make retrieval more precise when a user’s question relates to a specific piece of information within a larger document. Instead of returning a large section containing many unrelated topics, the retrieval system can return a focused chunk that directly addresses the query. However, chunk size involves trade-offs. Chunks that are too small may lose important context or split related information across separate records. Larger chunks can preserve more context but may introduce irrelevant material. Therefore, chunk size should be selected based on document structure and application requirements and evaluated using representative queries. No single chunk size is universally optimal for every RAG workload.<\/span><\/p>\n

          Question 45. Why might overlapping chunks be used during document chunking?<\/b><\/p>\n

            \n
          1. <\/b> To preserve context across chunk boundaries<\/span><\/li>\n
          2. <\/b> To permanently duplicate the entire knowledge base<\/span><\/li>\n
          3. <\/b> To prevent embeddings from being generated<\/span><\/li>\n
          4. <\/b> To increase model temperature<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. To preserve context across chunk boundaries<\/b><\/p>\n

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

            Chunk overlap means that a portion of text appears in neighboring chunks. This technique can help preserve important context when a sentence, explanation, or related concept crosses a chunk boundary. Without overlap, information split between two chunks may become harder to retrieve as a coherent unit. Overlap can therefore improve retrieval quality in some document-processing scenarios. However, excessive overlap can increase the number of tokens stored and retrieved, potentially increasing indexing and inference costs. The appropriate amount depends on document structure and the retrieval workload. Overlap should be evaluated rather than applied blindly because the ideal chunking strategy depends on the characteristics of the source content.<\/span><\/p>\n

            Question 46. What is a common purpose of query rewriting in a RAG application?<\/b><\/p>\n

              \n
            1. <\/b> To change the model’s training weights<\/span><\/li>\n
            2. <\/b> To transform a user’s query into a form that can improve retrieval<\/span><\/li>\n
            3. <\/b> To remove all metadata<\/span><\/li>\n
            4. <\/b> To disable vector search<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. To transform a user’s query into a form that can improve retrieval<\/b><\/p>\n

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

              Query rewriting modifies or expands a user’s original question to improve the retrieval process. Users may submit vague, conversational, abbreviated, or context-dependent questions that are not ideal for searching a knowledge base. A query-rewriting step can clarify terminology, add relevant context from the conversation, or generate a search-oriented representation of the request. This can help the retrieval system identify more appropriate documents. Query rewriting does not modify the underlying model weights and does not require disabling vector search. Because rewriting can also introduce unintended changes to the user’s intent, it should be evaluated carefully. The objective is to improve retrieval while preserving the meaning of the original request.<\/span><\/p>\n

              Question 47. What is multi-turn conversation handling concerned with in a generative AI application?<\/b><\/p>\n

                \n
              1. <\/b> Maintaining relevant conversational context across multiple interactions<\/span><\/li>\n
              2. <\/b> Increasing database storage automatically<\/span><\/li>\n
              3. <\/b> Creating GPU hardware<\/span><\/li>\n
              4. <\/b> Removing previous user messages in every request<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. Maintaining relevant conversational context across multiple interactions<\/b><\/p>\n

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

                Multi-turn conversation handling allows a generative AI application to respond appropriately when users ask follow-up questions that depend on previous exchanges. The application may maintain selected conversation history, summaries, retrieved information, or other contextual state and provide the relevant information to the model with each request. Because context windows are limited, applications generally should not send unlimited conversation history. Instead, they may summarize older messages or retain only the information relevant to the current task. Good conversation handling helps the model understand references such as “that document” or “the previous result.” It is therefore an important consideration when building conversational RAG assistants.<\/span><\/p>\n

                Question 48. What is one reason to summarize older conversation history in a long-running AI interaction?<\/b><\/p>\n

                  \n
                1. <\/b> To increase the model’s training dataset<\/span><\/li>\n
                2. <\/b> To eliminate the need for retrieval<\/span><\/li>\n
                3. <\/b> To reduce context usage while preserving important information<\/span><\/li>\n
                4. <\/b> To permanently change the model’s weights<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. To reduce context usage while preserving important information<\/b><\/p>\n

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

                  Long conversations can consume a significant portion of a model’s available context window. Summarizing older exchanges can reduce the number of tokens that need to be included in subsequent requests while retaining important information from earlier interactions. This can make the application more efficient and help keep the current request within the model’s context limits. A summary should preserve information that is relevant to the ongoing task and should avoid introducing unsupported details. Summarization does not retrain the model or eliminate the need for retrieval when external knowledge is required. It is primarily a context-management technique for applications that need to maintain useful conversational continuity over many turns.<\/span><\/p>\n

                  Question 49. What is a key difference between fine-tuning and RAG?<\/b><\/p>\n

                    \n
                  1. <\/b> RAG changes model weights while fine-tuning never does<\/span><\/li>\n
                  2. <\/b> Fine-tuning changes model parameters, while RAG supplies external context during inference<\/span><\/li>\n
                  3. <\/b> Both always require retraining the model<\/span><\/li>\n
                  4. <\/b> Neither can use external data<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 2. Fine-tuning changes model parameters, while RAG supplies external context during inference<\/b><\/p>\n

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

                    Fine-tuning and RAG address different aspects of generative AI application development. Fine-tuning involves additional training that changes model parameters so the model can learn patterns associated with a specific task, style, or domain. RAG does not normally change the model’s weights. Instead, it retrieves relevant external information at inference time and provides that information as context. RAG can therefore be useful when an application needs access to changing or organization-specific knowledge. Fine-tuning may be considered when the desired behavior cannot be achieved adequately through prompting and retrieval alone. The two approaches can also be used together, depending on the application’s requirements and evaluation results.<\/span><\/p>\n

                    Question 50. Which scenario is particularly suitable for RAG?<\/b><\/p>\n

                      \n
                    1. <\/b> An application must answer questions using frequently updated company documentation<\/span><\/li>\n
                    2. <\/b> An application needs to permanently change the model’s architecture<\/span><\/li>\n
                    3. <\/b> An application needs to physically increase GPU memory<\/span><\/li>\n
                    4. <\/b> An application wants to remove all external knowledge<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. An application must answer questions using frequently updated company documentation<\/b><\/p>\n

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

                      RAG is well suited to applications that need to answer questions using external information that may change over time. Examples include company policies, product documentation, internal procedures, technical manuals, and knowledge bases. Instead of retraining the foundation model whenever these documents change, the application can update the knowledge source and retrieval index. At query time, relevant information is retrieved and supplied to the model as context. This architecture separates the model’s general language capabilities from the application’s current knowledge. RAG is not intended to increase physical GPU memory or modify the model’s architecture. Its value comes from connecting generation with external, retrievable information.<\/span><\/p>\n

                      Question 51. What is the purpose of a model endpoint’s authentication mechanism?<\/b><\/p>\n

                        \n
                      1. <\/b> To control which clients are authorized to invoke the endpoint<\/span><\/li>\n
                      2. <\/b> To improve document chunking<\/span><\/li>\n
                      3. <\/b> To increase embedding dimensions<\/span><\/li>\n
                      4. <\/b> To create evaluation datasets automatically<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1. To control which clients are authorized to invoke the endpoint<\/b><\/p>\n

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

                        Authentication verifies the identity or credentials of a client attempting to access a model endpoint. This is important because production model endpoints should not necessarily be accessible to every user or application. Authentication can be combined with authorization so that authenticated clients receive only the permissions appropriate to their roles or identities. Proper endpoint security helps prevent unauthorized model usage and can also support auditing and usage management. Authentication does not improve document chunking or automatically create evaluation datasets. For production generative AI applications, teams should consider authentication, authorization, secret management, network security, monitoring, and logging as complementary controls around model-serving interfaces.<\/span><\/p>\n

                        Question 52. What is authorization responsible for in an AI application?<\/b><\/p>\n

                          \n
                        1. <\/b> Converting text into embeddings<\/span><\/li>\n
                        2. <\/b> Determining what an authenticated user or service is allowed to access<\/span><\/li>\n
                        3. <\/b> Generating natural-language responses<\/span><\/li>\n
                        4. <\/b> Increasing context-window size<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. Determining what an authenticated user or service is allowed to access<\/b><\/p>\n

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

                          Authorization determines which resources or actions an authenticated identity is permitted to access. In an enterprise generative AI application, authorization can affect access to documents, vector indexes, model endpoints, databases, and other resources. Authentication establishes who or what is making a request, while authorization determines what that identity is allowed to do. This distinction is important for RAG systems because retrieving unauthorized documents could expose sensitive information even if the model endpoint itself is protected. Authorization policies should therefore be applied throughout the application’s data and AI workflow. It is not responsible for generating responses or converting text into embeddings.<\/span><\/p>\n

                          Question 53. Why should sensitive credentials generally not be hard-coded into application source code?<\/b><\/p>\n

                            \n
                          1. <\/b> Hard-coded credentials can be exposed through source code and are difficult to manage securely<\/span><\/li>\n
                          2. <\/b> Hard-coded credentials always improve model accuracy<\/span><\/li>\n
                          3. <\/b> Source code cannot contain strings<\/span><\/li>\n
                          4. <\/b> Credentials are required to be stored in prompts<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Hard-coded credentials can be exposed through source code and are difficult to manage securely<\/b><\/p>\n

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

                            Embedding passwords, API keys, tokens, or other secrets directly into source code creates significant security and operational risks. Source code may be copied, shared, committed to version control, or exposed to developers and systems that do not require access to the secret. Rotating a hard-coded credential can also require code changes and redeployment. Secure secret-management mechanisms provide a better way to store and retrieve sensitive credentials while limiting access through appropriate identities and permissions. Generative AI applications may interact with multiple services, so protecting API credentials and other secrets is particularly important. Secrets should also be handled carefully in logs, configuration files, prompts, and error messages.<\/span><\/p>\n

                            Question 54. What is the purpose of rate limiting for a generative AI endpoint?<\/b><\/p>\n

                              \n
                            1. <\/b> To increase document size<\/span><\/li>\n
                            2. <\/b> To prevent all users from accessing the application<\/span><\/li>\n
                            3. <\/b> To control request volume and help protect service capacity<\/span><\/li>\n
                            4. <\/b> To modify model training data<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 3. To control request volume and help protect service capacity<\/b><\/p>\n

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

                              Rate limiting restricts how frequently clients can send requests to a service during a defined period. For generative AI endpoints, rate limits can help manage resource consumption, prevent a single client from overwhelming the service, and support predictable operational behavior. Rate limiting can also contribute to cost management and protection against certain forms of abusive or accidental traffic. It does not modify training data or automatically improve model quality. The appropriate limits depend on workload requirements, endpoint capacity, user expectations, and service configuration. Rate limiting should be considered alongside authentication, authorization, monitoring, error handling, and capacity planning when operating production AI services.<\/span><\/p>\n

                              Question 55. What does latency represent in a generative AI application?<\/b><\/p>\n

                                \n
                              1. <\/b> The amount of storage used by documents<\/span><\/li>\n
                              2. <\/b> The time required to process a request and return a response<\/span><\/li>\n
                              3. <\/b> The number of training examples<\/span><\/li>\n
                              4. <\/b> The size of the model vocabulary<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. The time required to process a request and return a response<\/b><\/p>\n

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

                                Latency represents the time taken for an operation or request to complete. In a generative AI application, end-to-end latency can include query processing, retrieval, prompt construction, model inference, and response delivery. Monitoring latency is important because users generally expect conversational applications to respond within reasonable time limits. High latency may originate from inefficient retrieval, large prompts, slow model inference, infrastructure limitations, or downstream services. Measuring only one component may not reveal the complete user experience, so production monitoring should consider appropriate end-to-end and component-level measurements. Latency should be evaluated together with response quality, throughput, reliability, and cost when optimizing an AI application.<\/span><\/p>\n

                                Question 56. What does throughput measure for an AI serving system?<\/b><\/p>\n

                                  \n
                                1. <\/b> The number of requests or tokens processed over a period of time<\/span><\/li>\n
                                2. <\/b> The accuracy of every generated response<\/span><\/li>\n
                                3. <\/b> The number of source documents in a knowledge base<\/span><\/li>\n
                                4. <\/b> The size of a prompt template<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1. The number of requests or tokens processed over a period of time<\/b><\/p>\n

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

                                  Throughput describes how much work a system can process during a given period. Depending on the workload, it may be measured in requests per second, tokens per second, or another suitable unit. Throughput is an important operational metric for AI serving because production applications may receive many concurrent requests. A system can have acceptable individual-request latency while still failing to meet overall demand if its throughput capacity is insufficient. Throughput does not directly measure response accuracy or knowledge-base size. Teams may evaluate throughput alongside latency, resource utilization, concurrency, cost, and quality to determine whether the serving configuration can support expected production workloads.<\/span><\/p>\n

                                  Question 57. What is a benefit of caching in a generative AI application when applied appropriately?<\/b><\/p>\n

                                    \n
                                  1. <\/b> It can reduce repeated computation for identical or reusable results<\/span><\/li>\n
                                  2. <\/b> It guarantees all responses are current<\/span><\/li>\n
                                  3. <\/b> It eliminates access control<\/span><\/li>\n
                                  4. <\/b> It permanently retrains the model<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. It can reduce repeated computation for identical or reusable results<\/b><\/p>\n

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

                                    Caching stores results or intermediate information so that repeated requests can sometimes be served without performing the same computation again. In a generative AI application, caching may be useful for repeated retrieval operations, frequently requested information, or other deterministic or reusable components. Appropriate caching can reduce latency, resource usage, and potentially inference costs. However, cached information can become stale, so cache invalidation and freshness requirements must be considered carefully. Caching does not guarantee that responses are current and does not remove the need for authorization or other security controls. It should be implemented according to the application’s data characteristics and consistency requirements.<\/span><\/p>\n

                                    Question 58. Why is observability important for production generative AI systems?<\/b><\/p>\n

                                      \n
                                    1. <\/b> It allows teams to understand system behavior and diagnose issues<\/span><\/li>\n
                                    2. <\/b> It guarantees zero hallucinations<\/span><\/li>\n
                                    3. <\/b> It removes the need for evaluation<\/span><\/li>\n
                                    4. <\/b> It replaces all security mechanisms<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. It allows teams to understand system behavior and diagnose issues<\/b><\/p>\n

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

                                      Observability provides information that helps teams understand what is happening inside a production application. For generative AI systems, useful signals can include request latency, error rates, retrieval behavior, model responses, resource utilization, endpoint health, and other application-specific metrics. Logs, metrics, and traces can work together to help identify the source of problems. For example, a slow response may result from retrieval rather than model inference, and tracing can help distinguish these cases. Observability does not guarantee that hallucinations disappear and does not replace security or evaluation. Instead, it provides the operational visibility required to maintain and troubleshoot complex AI applications after deployment.<\/span><\/p>\n

                                      Question 59. What is a useful reason to retain model and application version information with evaluation results?<\/b><\/p>\n

                                        \n
                                      1. <\/b> To connect evaluation outcomes with the exact configuration that produced them<\/span><\/li>\n
                                      2. <\/b> To eliminate future testing<\/span><\/li>\n
                                      3. <\/b> To increase the model’s context window<\/span><\/li>\n
                                      4. <\/b> To remove the need for source control<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. To connect evaluation outcomes with the exact configuration that produced them<\/b><\/p>\n

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

                                        Recording model versions, prompt versions, retrieval configurations, code revisions, and other relevant metadata alongside evaluation results improves traceability. When a team observes that one version performs better or worse than another, this information helps identify exactly which configuration produced the measured results. It also supports reproducibility and makes it easier to investigate regressions after application changes. Without version information, evaluation results may be difficult to interpret because the underlying model or prompt may have changed. Versioned evaluation records do not eliminate the need for future testing or source control. They complement those practices by creating a clear relationship between measured outcomes and application configurations.<\/span><\/p>\n

                                        Question 60. Which practice best supports responsible deployment of a generative AI application?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Deploying without evaluation because model outputs are probabilistic<\/span><\/li>\n
                                        2. <\/b> Allowing unrestricted access to all enterprise data<\/span><\/li>\n
                                        3. <\/b> Combining evaluation, security controls, monitoring, governance, and controlled releases<\/span><\/li>\n
                                        4. <\/b> Removing all production logs<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Combining evaluation, security controls, monitoring, governance, and controlled releases<\/b><\/p>\n

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

                                          Responsible deployment requires more than simply selecting a capable language model. Teams should evaluate application quality and safety, protect sensitive data, apply appropriate authentication and authorization, monitor production behavior, and govern access to data and AI resources. Controlled releases can reduce the impact of unexpected behavior and provide opportunities to validate changes before broad deployment. Logging and observability should also be implemented carefully while respecting privacy and security requirements. No single control can address every risk associated with generative AI. Combining evaluation, governance, security, monitoring, and lifecycle practices provides a more comprehensive approach to operating an AI application and supports ongoing improvement based on observed evidence.<\/span><\/p>\n

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

                                          View Full Databricks Certified Generative AI Engineer Associate Exam Dumps and Practice Test Dumps   Question 41. What is the main purpose of a tokenizer in a generative AI system? To convert input text into tokens that the model can process To create database tables To manage user permissions To monitor GPU temperature Correct Answer: […]<\/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\/18127"}],"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=18127"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18127\/revisions"}],"predecessor-version":[{"id":18128,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18127\/revisions\/18128"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18127"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18127"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18127"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}