{"id":18141,"date":"2026-09-22T05:38:39","date_gmt":"2026-09-22T05:38:39","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18141"},"modified":"2026-09-22T05:38:39","modified_gmt":"2026-09-22T05:38:39","slug":"databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part10-q181-200","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part10-q181-200\/","title":{"rendered":"Databricks Certified Generative AI Engineer Associate Practice Test Questions and Exam Dumps Part10 Q181-200"},"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 181. Which technique is most useful for ensuring retrieved documents are relevant before they are provided to an LLM?<\/b><\/p>\n

    \n
  1. <\/b> Increasing temperature<\/span><\/li>\n
  2. <\/b> Reranking retrieved documents<\/span><\/li>\n
  3. <\/b> Increasing response length<\/span><\/li>\n
  4. <\/b> Removing metadata<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. Reranking retrieved documents<\/b><\/p>\n

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

    Reranking improves the relevance of retrieved documents by evaluating the initial search results more carefully and ordering them according to their relationship to the user’s query. In a RAG system, the first retrieval stage may return several documents that are broadly similar but not equally useful. A reranker can examine the query and candidate passages together and place the most relevant information first. This helps the generation model receive better context and can reduce irrelevant or distracting information. Reranking is particularly useful when the retrieval index contains a large and diverse collection of documents where simple similarity search alone may not provide sufficiently precise results.<\/span><\/p>\n

    Question 182. What is a primary benefit of using metadata filters during retrieval in a RAG application?<\/b><\/p>\n

      \n
    1. <\/b> They increase the LLM’s context window<\/span><\/li>\n
    2. <\/b> They automatically fine-tune the model<\/span><\/li>\n
    3. <\/b> They restrict retrieval to documents matching specified attributes<\/span><\/li>\n
    4. <\/b> They eliminate the need for embeddings<\/span><\/li>\n<\/ol>\n

      Correct Answer: 3. They restrict retrieval to documents matching specified attributes<\/b><\/p>\n

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

      Metadata filters allow a retrieval system to narrow the search space using attributes associated with documents or chunks. Examples include department, document type, language, date, product, region, or access classification. Instead of searching every indexed item, the system can first restrict candidates to records that satisfy the required conditions. This can improve relevance, reduce unnecessary retrieval, and support access-control requirements. Metadata filtering is especially valuable in enterprise RAG systems where users may need information from a particular business unit or a specific time period. It complements semantic or lexical search rather than replacing those retrieval techniques.<\/span><\/p>\n

      Question 183. A RAG application frequently retrieves outdated policies. What should the development team investigate first?<\/b><\/p>\n

        \n
      1. <\/b> Whether the knowledge base is being updated and re-indexed correctly<\/span><\/li>\n
      2. <\/b> Whether the temperature is too low<\/span><\/li>\n
      3. <\/b> Whether the answer contains enough adjectives<\/span><\/li>\n
      4. <\/b> Whether the model has a larger context window<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. Whether the knowledge base is being updated and re-indexed correctly<\/b><\/p>\n

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

        Outdated retrieval results commonly indicate a problem in the data ingestion or indexing lifecycle. If new or revised policies are not successfully ingested, transformed, and indexed, the retriever may continue returning older versions even when the source system contains current information. The team should therefore verify that document changes are detected, processed, embedded when required, and reflected in the active retrieval index. Metadata such as effective dates and document versions can also help prevent obsolete content from being selected. Changing the generation temperature or increasing the model’s context window does not address the underlying problem when the retriever itself is supplying stale information.<\/span><\/p>\n

        Question 184. Which evaluation approach helps determine whether an LLM answer is supported by retrieved context?<\/b><\/p>\n

          \n
        1. <\/b> Measuring only endpoint throughput<\/span><\/li>\n
        2. <\/b> Counting the number of prompt tokens<\/span><\/li>\n
        3. <\/b> Checking the model’s parameter count<\/span><\/li>\n
        4. <\/b> Evaluating groundedness against the retrieved evidence<\/span><\/li>\n<\/ol>\n

          Correct Answer: 4. Evaluating groundedness against the retrieved evidence<\/b><\/p>\n

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

          Groundedness evaluation examines whether the generated response is supported by the evidence supplied to the model. This is especially important for RAG applications because retrieval is intended to provide authoritative or relevant context that constrains generation. A grounded response should make claims that can be justified from the retrieved material rather than introducing unsupported facts. Evaluating groundedness separately from general answer quality helps teams identify hallucinations and weaknesses in the generation stage. A response can be fluent and relevant while still containing unsupported claims, so metrics that specifically assess grounding provide an important dimension of a comprehensive generative AI evaluation process.<\/span><\/p>\n

          Question 185. Why should an evaluation dataset contain examples that resemble real production queries?<\/b><\/p>\n

            \n
          1. <\/b> To make the model’s vocabulary smaller<\/span><\/li>\n
          2. <\/b> To make evaluation results more representative of expected application behavior<\/span><\/li>\n
          3. <\/b> To eliminate the need for monitoring<\/span><\/li>\n
          4. <\/b> To guarantee every answer is correct<\/span><\/li>\n<\/ol>\n

            Correct Answer: 2. To make evaluation results more representative of expected application behavior<\/b><\/p>\n

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

            A representative evaluation dataset allows a team to measure system behavior under conditions similar to those expected in production. If evaluation examples are unrealistic, overly simple, or unrelated to actual users, strong evaluation results may not reflect real application performance. Representative datasets can include common requests, difficult queries, ambiguous questions, different document types, and important edge cases. They should also reflect the intended user population and business domain. Although a representative dataset cannot guarantee perfect production behavior, it provides a much stronger basis for comparing prompts, retrieval strategies, models, and application changes before those changes are released.<\/span><\/p>\n

            Question 186. What is a key purpose of tracing in a generative AI application?<\/b><\/p>\n

              \n
            1. <\/b> To increase the model’s training data automatically<\/span><\/li>\n
            2. <\/b> To replace authentication<\/span><\/li>\n
            3. <\/b> To provide visibility into requests, retrieval steps, and model calls<\/span><\/li>\n
            4. <\/b> To permanently increase model accuracy<\/span><\/li>\n<\/ol>\n

              Correct Answer: 3. To provide visibility into requests, retrieval steps, and model calls<\/b><\/p>\n

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

              Tracing provides detailed visibility into the sequence of operations performed during an application request. In a RAG system, a trace can help show the incoming query, retrieval operation, selected documents, prompt construction, model invocation, latency, and resulting response. This information is useful when diagnosing unexpected behavior because developers can identify whether a problem originated in retrieval, prompt construction, model generation, or another component. Tracing also supports performance analysis and debugging across complex multi-step workflows. It does not itself improve model accuracy, but it provides the observability required to understand system behavior and make informed improvements.<\/span><\/p>\n

              Question 187. What should an application do when retrieved context does not contain enough information to answer a user’s question reliably?<\/b><\/p>\n

                \n
              1. <\/b> Generate a confident answer from unrelated knowledge<\/span><\/li>\n
              2. <\/b> Increase temperature<\/span><\/li>\n
              3. <\/b> Ignore the retrieved context<\/span><\/li>\n
              4. <\/b> Acknowledge the limitation or request clarification<\/span><\/li>\n<\/ol>\n

                Correct Answer: 4. Acknowledge the limitation or request clarification<\/b><\/p>\n

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

                When the retrieved evidence is insufficient, generating a confident answer can introduce unsupported information and increase hallucination risk. A well-designed application should instead communicate the limitation, ask the user for clarification, or indicate that the available sources do not provide enough information. This behavior can be reinforced through system instructions and application-level guardrails. Retrieval thresholds can also help determine when evidence is insufficient for generation. Designing the system to recognize uncertainty is particularly important for enterprise applications, where incorrect answers may lead users to make decisions based on information that was never supported by the organization’s approved knowledge sources.<\/span><\/p>\n

                Question 188. Which change can reduce unnecessary latency when the same expensive operation is repeatedly performed?<\/b><\/p>\n

                  \n
                1. <\/b> Introducing appropriate caching<\/span><\/li>\n
                2. <\/b> Increasing temperature<\/span><\/li>\n
                3. <\/b> Removing all monitoring<\/span><\/li>\n
                4. <\/b> Increasing the number of retrieved documents<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 1. Introducing appropriate caching<\/b><\/p>\n

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

                  Caching can reduce latency by storing results of operations that are expensive and likely to be reused. Depending on the architecture, an application may cache embeddings, frequently requested retrieval results, configuration data, or other deterministic intermediate results. When a valid cached result is available, the system can avoid repeating the underlying operation. However, caching must be designed carefully because stale information can be problematic in applications whose data changes frequently. Appropriate cache invalidation and expiration policies are therefore important. Caching does not replace optimization of retrieval or model calls, but it can significantly improve response time and resource efficiency for suitable workloads.<\/span><\/p>\n

                  Question 189. What is the main difference between authentication and authorization in an AI application?<\/b><\/p>\n

                    \n
                  1. <\/b> Authentication determines what information a user can access<\/span><\/li>\n
                  2. <\/b> Authorization verifies the user’s identity<\/span><\/li>\n
                  3. <\/b> Authentication verifies identity, while authorization determines permitted access<\/span><\/li>\n
                  4. <\/b> They are identical security processes<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 3. Authentication verifies identity, while authorization determines permitted access<\/b><\/p>\n

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

                    Authentication and authorization address different security questions. Authentication establishes who a user or service is, commonly through credentials, tokens, or another identity mechanism. Authorization occurs after identity has been established and determines what that authenticated identity is allowed to access or perform. In an enterprise generative AI application, authentication may identify an employee, while authorization may determine whether that employee can retrieve confidential documents from a particular department. Keeping these concepts separate is important when designing secure RAG systems. A system that successfully identifies users but does not enforce appropriate authorization could still expose information to users who should not have access.<\/span><\/p>\n

                    Question 190. Why is prompt versioning useful during generative AI development?<\/b><\/p>\n

                      \n
                    1. <\/b> It allows teams to compare behavior across prompt changes<\/span><\/li>\n
                    2. <\/b> It automatically removes hallucinations<\/span><\/li>\n
                    3. <\/b> It increases the model’s parameter count<\/span><\/li>\n
                    4. <\/b> It eliminates evaluation requirements<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. It allows teams to compare behavior across prompt changes<\/b><\/p>\n

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

                      Prompt versioning makes changes to instructions, templates, examples, and formatting requirements traceable over time. When a team modifies a prompt, version control allows developers to identify exactly which prompt produced a particular evaluation result or production behavior. This makes experimentation more reproducible and helps teams compare different prompt versions against a consistent evaluation dataset. If an updated prompt causes unexpected behavior, the previous version can also be identified and restored more easily. Prompt versioning is therefore an important part of disciplined generative AI development, particularly when prompts influence retrieval instructions, response formats, safety requirements, or domain-specific behavior.<\/span><\/p>\n

                      Question 191. Which retrieval strategy combines semantic similarity with keyword-based matching?<\/b><\/p>\n

                        \n
                      1. <\/b> Generative-only retrieval<\/span><\/li>\n
                      2. <\/b> Hybrid search<\/span><\/li>\n
                      3. <\/b> Random sampling<\/span><\/li>\n
                      4. <\/b> Model fine-tuning<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2. Hybrid search<\/b><\/p>\n

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

                        Hybrid search combines multiple retrieval approaches, commonly semantic vector search and lexical or keyword-based search. Semantic retrieval is useful for finding content that is conceptually related even when the wording differs, while lexical retrieval can perform well when exact terms, product names, identifiers, or specialized terminology are important. Combining these signals can improve retrieval coverage across different query types. The results may then be merged, scored, or reranked before the final context is provided to the language model. Hybrid search is therefore a useful strategy when a single retrieval method does not consistently capture the different ways users express information needs.<\/span><\/p>\n

                        Question 192. What is the purpose of an output schema in a generative AI application?<\/b><\/p>\n

                          \n
                        1. <\/b> To increase the number of model parameters<\/span><\/li>\n
                        2. <\/b> To define the expected structure and fields of the response<\/span><\/li>\n
                        3. <\/b> To replace document retrieval<\/span><\/li>\n
                        4. <\/b> To prevent all possible model errors<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 2. To define the expected structure and fields of the response<\/b><\/p>\n

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

                          An output schema specifies the structure that a generated response is expected to follow. For example, an application might require fields such as a summary, confidence indicator, source identifiers, and recommended actions. Structured output is particularly useful when the model’s response will be consumed by software rather than read only by a human. After generation, the application can validate the response against the schema and handle invalid output appropriately. A schema does not guarantee that the model will always produce correct information, but it provides a predictable interface and makes downstream processing more reliable. This is especially important for production applications integrating LLMs with other systems.<\/span><\/p>\n

                          Question 193. What is a major risk of using excessively large chunks in a RAG knowledge base?<\/b><\/p>\n

                            \n
                          1. <\/b> The embedding model stops functioning<\/span><\/li>\n
                          2. <\/b> The documents become impossible to store<\/span><\/li>\n
                          3. <\/b> Retrieved results may contain too much unrelated information<\/span><\/li>\n
                          4. <\/b> Authentication becomes unavailable<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 3. Retrieved results may contain too much unrelated information<\/b><\/p>\n

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

                            Excessively large chunks can reduce retrieval precision because a single retrieved unit may contain many topics that are not relevant to the user’s question. Although the chunk may match semantically, the additional material can consume valuable context-window capacity and distract the generation model. Large chunks can also make it harder to identify the exact evidence supporting an answer. Chunking should therefore balance sufficient context with focused retrieval. The appropriate size depends on document structure, query patterns, embedding behavior, and the downstream model’s context limitations. Testing different chunking strategies with representative evaluation queries is generally more reliable than choosing a single size without measuring retrieval quality.<\/span><\/p>\n

                            Question 194. What does retrieval recall measure in a retrieval evaluation?<\/b><\/p>\n

                              \n
                            1. <\/b> How many relevant items were successfully retrieved<\/span><\/li>\n
                            2. <\/b> How quickly the model generates tokens<\/span><\/li>\n
                            3. <\/b> How many parameters the model contains<\/span><\/li>\n
                            4. <\/b> How many users accessed the application<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. How many relevant items were successfully retrieved<\/b><\/p>\n

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

                              Retrieval recall measures the ability of a retrieval system to find relevant information that should have been retrieved for a query. A low recall value can indicate that important documents or passages are being missed entirely. This differs from retrieval precision, which focuses on how many retrieved items are actually relevant. Both measures are useful because a system may retrieve highly relevant documents but miss other necessary evidence, or retrieve many documents while including substantial irrelevant material. Evaluating recall can help teams investigate embedding selection, chunking, query formulation, filters, indexing, and top-k settings when important information is consistently absent from retrieved results.<\/span><\/p>\n

                              Question 195. Which practice improves reproducibility when comparing two RAG system versions?<\/b><\/p>\n

                                \n
                              1. <\/b> Change several variables simultaneously without recording them<\/span><\/li>\n
                              2. <\/b> Use a consistent evaluation dataset and record system configurations<\/span><\/li>\n
                              3. <\/b> Evaluate only successful production requests<\/span><\/li>\n
                              4. <\/b> Remove all previous experiment results<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. Use a consistent evaluation dataset and record system configurations<\/b><\/p>\n

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

                                Reproducible evaluation requires teams to know exactly what was tested and under which conditions. Using the same evaluation dataset when comparing system versions helps ensure that differences in results are associated with the system changes rather than different test questions. Teams should also record important configuration details such as model versions, prompts, retrieval settings, chunking strategy, embedding model, reranking configuration, and relevant application parameters. This creates a reliable basis for analyzing improvements or regressions. Without such records, it can be difficult to determine why a change affected performance or to recreate a previous experiment when investigating unexpected results.<\/span><\/p>\n

                                Question 196. Why should sensitive information be protected during generative AI application logging?<\/b><\/p>\n

                                  \n
                                1. <\/b> Logs are never useful for debugging<\/span><\/li>\n
                                2. <\/b> Logging automatically improves retrieval<\/span><\/li>\n
                                3. <\/b> Sensitive data in logs can create additional exposure and compliance risks<\/span><\/li>\n
                                4. <\/b> Models cannot process logs<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Sensitive data in logs can create additional exposure and compliance risks<\/b><\/p>\n

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

                                  Application logs can contain prompts, retrieved documents, model outputs, user identifiers, or other information generated during an AI workflow. If sensitive information is recorded unnecessarily, logs can become an additional location where confidential data is exposed or retained. Teams should therefore apply appropriate access controls, data minimization, retention policies, masking, and monitoring to observability systems. Logging remains important for troubleshooting and auditing, but it should be implemented with security and privacy considerations in mind. The goal is to collect enough information to understand system behavior without unnecessarily storing sensitive content or expanding the number of systems that can access it.<\/span><\/p>\n

                                  Question 197. What is the role of guardrails in a generative AI application?<\/b><\/p>\n

                                    \n
                                  1. <\/b> They increase the model’s context window<\/span><\/li>\n
                                  2. <\/b> They help constrain unsafe, inappropriate, or unwanted behavior<\/span><\/li>\n
                                  3. <\/b> They replace all model evaluation<\/span><\/li>\n
                                  4. <\/b> They guarantee factual accuracy<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 2. They help constrain unsafe, inappropriate, or unwanted behavior<\/b><\/p>\n

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

                                    Guardrails are controls designed to constrain how a generative AI system behaves. Depending on the application, they can address harmful content, sensitive information, prohibited requests, output formats, unsupported claims, or other defined requirements. Guardrails may be implemented through prompts, input and output checks, policy rules, classifiers, filters, or application logic. They are useful because language models can produce unexpected outputs even when given detailed instructions. However, guardrails should not be treated as a complete guarantee of safety or correctness. They work alongside evaluation, monitoring, access controls, data governance, and other engineering practices to create a more controlled application.<\/span><\/p>\n

                                    Question 198. A production RAG system suddenly shows a drop in answer quality. What should be examined before changing the model?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Retrieval quality and recent data or configuration changes<\/span><\/li>\n
                                    2. <\/b> The user’s screen resolution<\/span><\/li>\n
                                    3. <\/b> The font used in the application<\/span><\/li>\n
                                    4. <\/b> The number of browser tabs open<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. Retrieval quality and recent data or configuration changes<\/b><\/p>\n

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

                                      A sudden decline in RAG answer quality may originate from changes outside the language model itself. The team should examine retrieval metrics, index freshness, source-document changes, embedding updates, metadata filters, chunking configuration, reranking behavior, and recent application deployments. Comparing current traces and evaluation results with a known-good baseline can help identify where the degradation began. If retrieval quality has declined, changing the generation model may not solve the problem because the model may simply be receiving poor or incomplete context. Investigating recent changes systematically helps isolate the affected component and reduces the risk of introducing unnecessary changes to a production system.<\/span><\/p>\n

                                      Question 199. Which practice is most useful for identifying whether a RAG improvement actually helped?<\/b><\/p>\n

                                        \n
                                      1. <\/b> Relying only on a single anecdotal response<\/span><\/li>\n
                                      2. <\/b> Increasing model temperature after every change<\/span><\/li>\n
                                      3. <\/b> Comparing evaluation results against a documented baseline<\/span><\/li>\n
                                      4. <\/b> Removing the retrieval component<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Comparing evaluation results against a documented baseline<\/b><\/p>\n

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

                                        A documented baseline provides a reference point for measuring whether a change produces meaningful improvement. Before modifying a RAG system, teams can record relevant metrics such as retrieval precision, retrieval recall, groundedness, response relevance, latency, cost, and other application-specific measures. After the change, the same evaluation dataset and measurement process can be used for comparison. This makes it easier to distinguish genuine improvements from random variation or improvements in one metric that cause regressions elsewhere. Baseline evaluation also supports controlled experimentation and provides historical evidence that can help teams understand how the system has evolved across different versions.<\/span><\/p>\n

                                        Question 200. What is an appropriate high-level lifecycle for developing and operating a reliable RAG application?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Deploy immediately, then define requirements later<\/span><\/li>\n
                                        2. <\/b> Retrieve randomly, generate answers, and never monitor them<\/span><\/li>\n
                                        3. <\/b> Fine-tune first and ignore the knowledge source<\/span><\/li>\n
                                        4. <\/b> Build the knowledge pipeline, evaluate retrieval and generation, deploy with monitoring, and continuously improve<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4. Build the knowledge pipeline, evaluate retrieval and generation, deploy with monitoring, and continuously improve<\/b><\/p>\n

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

                                          A reliable RAG application requires an end-to-end lifecycle rather than focusing only on the language model. The process typically begins with preparing trustworthy source data, designing ingestion and chunking, generating embeddings, and configuring retrieval. Teams should then evaluate retrieval and generation quality using representative datasets before production deployment. Once deployed, monitoring and tracing can reveal changes in latency, retrieval behavior, groundedness, errors, and user experience. Feedback and evaluation results can guide controlled improvements to prompts, retrieval, data pipelines, models, and guardrails. Versioning these components and maintaining reproducible evaluations makes the overall system easier to operate, troubleshoot, and improve over time.<\/span><\/p>\n

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

                                          View Full Databricks Certified Generative AI Engineer Associate Exam Dumps and Practice Test Dumps   Question 181. Which technique is most useful for ensuring retrieved documents are relevant before they are provided to an LLM? Increasing temperature Reranking retrieved documents Increasing response length Removing metadata Correct Answer: 2. Reranking retrieved documents Explanation: Reranking improves the […]<\/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\/18141"}],"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=18141"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18141\/revisions"}],"predecessor-version":[{"id":18142,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18141\/revisions\/18142"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18141"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18141"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18141"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}