{"id":18137,"date":"2026-09-22T05:38:04","date_gmt":"2026-09-22T05:38:04","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18137"},"modified":"2026-09-22T05:38:04","modified_gmt":"2026-09-22T05:38:04","slug":"databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part8-q141-160","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part8-q141-160\/","title":{"rendered":"Databricks Certified Generative AI Engineer Associate Practice Test Questions and Exam Dumps Part8 Q141-160"},"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 141. Which component is responsible for finding relevant information from a knowledge base in a RAG application?<\/b><\/p>\n

    \n
  1. <\/b> Generator<\/span>
    \n<\/span>2.<\/b> Retriever<\/span>
    \n<\/span>3.<\/b> Tokenizer<\/span>
    \n<\/span>4.<\/b> Output validator<\/span><\/li>\n<\/ol>\n

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

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

    The retriever is the component responsible for finding information that is relevant to a user’s query from an external knowledge source. Depending on the architecture, retrieval may use vector similarity, keyword search, hybrid search, metadata filters, or reranking. After relevant information is identified, the retrieved content can be passed to the generation model as context. The generator then uses the query, instructions, and retrieved information to produce the response. A tokenizer converts text into tokens, while an output validator checks whether the generated response satisfies defined requirements. Separating retrieval from generation allows the application to use current or domain-specific information without relying entirely on the model’s pretrained knowledge.<\/span><\/p>\n

    Question 142. What is the main purpose of tokenization in a language model workflow?<\/b><\/p>\n

      \n
    1. <\/b> Convert text into tokens that the model can process<\/span>
      \n<\/span>2.<\/b> Store documents in a vector database<\/span>
      \n<\/span>3.<\/b> Rank retrieved documents<\/span>
      \n<\/span>4.<\/b> Authenticate application users<\/span><\/li>\n<\/ol>\n

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

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

      Tokenization converts text into smaller units called tokens that a language model can process numerically. Depending on the tokenizer, a token may represent a complete word, part of a word, punctuation, or another text unit. Tokenization is important because model context limits and generation limits are generally expressed in tokens rather than ordinary words or characters. Understanding token usage helps developers estimate prompt size, retrieved-context requirements, and output capacity. Tokenization does not perform document retrieval, rank search results, or authenticate users. It is a fundamental preprocessing step that enables the language model to represent and process natural-language input and generate token-based output.<\/span><\/p>\n

      Question 143. Why should retrieved context be relevant to the user’s question?<\/b><\/p>\n

        \n
      1. <\/b> Relevant context helps the model focus on evidence related to the requested information<\/span>
        \n<\/span>2.<\/b> Relevant context increases the number of unrelated documents<\/span>
        \n<\/span>3.<\/b> Relevant context eliminates all security controls<\/span>
        \n<\/span>4.<\/b> Relevant context automatically retrains the model<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. Relevant context helps the model focus on evidence related to the requested information<\/b><\/p>\n

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

        Relevant retrieved context gives the generation model information that directly relates to the user’s request. When the context is relevant, the model has stronger evidence to use when constructing an answer, which can improve usefulness and grounding. Irrelevant documents can consume tokens and introduce distracting or conflicting information. Retrieval systems therefore commonly use techniques such as semantic search, metadata filtering, reranking, and similarity thresholds to improve contextual relevance. Retrieval alone does not guarantee a correct answer, and security controls remain necessary regardless of context quality. The objective is to provide enough useful evidence for the model without unnecessarily filling the context window with unrelated material.<\/span><\/p>\n

        Question 144. Which technique can improve retrieval when exact keywords are important?<\/b><\/p>\n

          \n
        1. <\/b> Increasing temperature<\/span>
          \n<\/span>2.<\/b> Removing metadata<\/span>
          \n<\/span>3.<\/b> Keyword or lexical search<\/span>
          \n<\/span>4.<\/b> Increasing response length<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. Keyword or lexical search<\/b><\/p>\n

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

          Keyword or lexical search can be particularly effective when exact terms are important to the query. Examples include product identifiers, error codes, legal references, names, version numbers, and specialized terminology where exact matching may be valuable. Semantic search is useful for identifying conceptually similar content, but it may not always prioritize an exact identifier in the way a lexical search can. Hybrid search can combine lexical and semantic methods to benefit from both. Increasing generation temperature or response length does not improve retrieval, while removing metadata can reduce useful filtering capabilities. Retrieval strategy should therefore reflect the types of queries and documents handled by the application.<\/span><\/p>\n

          Question 145. What is the purpose of a system instruction that tells a model to use only supplied context?<\/b><\/p>\n

            \n
          1. <\/b> Encourage the model to base its response on provided evidence<\/span>
            \n<\/span>2.<\/b> Increase vector database capacity<\/span>
            \n<\/span>3.<\/b> Create new document embeddings<\/span>
            \n<\/span>4.<\/b> Increase network bandwidth<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. Encourage the model to base its response on provided evidence<\/b><\/p>\n

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

            A system instruction can guide a model to rely on supplied context when answering questions. In a RAG application, this can reinforce the application’s grounding objective by telling the model to use retrieved evidence and avoid unsupported claims when the available context does not contain an answer. Such instructions are useful but are not a complete solution by themselves. Retrieval quality, source quality, evaluation, and other controls remain important. A system instruction does not create embeddings or increase infrastructure capacity. Its role is to influence model behavior and establish expectations for how the model should use the information supplied to it during generation.<\/span><\/p>\n

            Question 146. What is one advantage of using metadata such as document version or effective date?<\/b><\/p>\n

              \n
            1. <\/b> It can help retrieve the appropriate version of information<\/span>
              \n<\/span>2.<\/b> It guarantees that every document is accurate<\/span>
              \n<\/span>3.<\/b> It eliminates the need for embeddings<\/span>
              \n<\/span>4.<\/b> It increases model parameters<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1. It can help retrieve the appropriate version of information<\/b><\/p>\n

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

              Document version and effective-date metadata can help an application distinguish between current and outdated information. For example, an enterprise knowledge assistant may need to retrieve the policy that is currently effective rather than an older version stored in the same knowledge base. Metadata filters can restrict candidates according to dates, versions, departments, or other attributes before or during retrieval. This improves control over which information reaches the generation model. Metadata does not guarantee factual accuracy, because the source itself could contain incorrect information. It also does not eliminate embeddings when semantic search is used. Its value is providing structured information that supports more precise retrieval and governance.<\/span><\/p>\n

              Question 147. Why can duplicate documents be problematic in a RAG knowledge base?<\/b><\/p>\n

                \n
              1. <\/b> They may consume retrieval capacity and cause redundant context<\/span>
                \n<\/span>2.<\/b> They always improve retrieval precision<\/span>
                \n<\/span>3.<\/b> They automatically improve model reasoning<\/span>
                \n<\/span>4.<\/b> They eliminate the need for indexing<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. They may consume retrieval capacity and cause redundant context<\/b><\/p>\n

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

                Duplicate documents can cause a retrieval system to return repeated versions of essentially the same information. This can reduce the diversity of the retrieved context and consume part of the available top-k results with redundant content. The generation model may then receive fewer distinct sources that could have provided additional useful evidence. Duplicate content can also increase storage and indexing requirements. Deduplication or careful document management can therefore improve the efficiency and usefulness of the retrieval layer. Duplicate documents do not automatically improve reasoning or eliminate indexing requirements. Maintaining a clean knowledge base is an important part of preparing reliable retrieval data.<\/span><\/p>\n

                Question 148. Which approach is useful for handling frequently changing enterprise documents?<\/b><\/p>\n

                  \n
                1. <\/b> Re-ingest and re-index updated source content<\/span>
                  \n<\/span>2.<\/b> Keep outdated embeddings permanently<\/span>
                  \n<\/span>3.<\/b> Disable the ingestion pipeline<\/span>
                  \n<\/span>4.<\/b> Increase generation temperature<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 1. Re-ingest and re-index updated source content<\/b><\/p>\n

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

                  Frequently changing enterprise documents require a process for keeping the retrieval index synchronized with the authoritative source. When documents are updated, the ingestion pipeline can detect the changes, process the new content, generate updated embeddings where necessary, and refresh the relevant index records. Obsolete versions should also be handled according to the application’s document lifecycle rules. Simply keeping outdated embeddings can cause the assistant to retrieve stale information. Disabling ingestion prevents updates from reaching the retrieval layer, while increasing generation temperature does not update external knowledge. Regular ingestion and indexing are therefore important for maintaining freshness in knowledge-intensive RAG applications.<\/span><\/p>\n

                  Question 149. What is a potential benefit of query rewriting before retrieval?<\/b><\/p>\n

                    \n
                  1. <\/b> It can transform an unclear user request into a more retrieval-friendly query<\/span>
                    \n<\/span>2.<\/b> It permanently changes the foundation model<\/span>
                    \n<\/span>3.<\/b> It removes the need for a knowledge base<\/span>
                    \n<\/span>4.<\/b> It disables metadata filtering<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. It can transform an unclear user request into a more retrieval-friendly query<\/b><\/p>\n

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

                    Query rewriting can improve retrieval by transforming the user’s original wording into a clearer representation that better reflects the information needed from the knowledge base. This is particularly useful for conversational questions, ambiguous phrasing, abbreviations, follow-up questions, or terminology that differs from the source documents. The rewritten query can incorporate relevant conversational context while removing unnecessary wording. However, rewriting should be evaluated because an incorrect transformation could change the user’s intent and lead to poor retrieval. Query rewriting does not permanently modify model weights or eliminate the knowledge base. It is a preprocessing technique that can improve how retrieval systems interpret user requests.<\/span><\/p>\n

                    Question 150. What should a RAG application do if no retrieved document meets its relevance threshold?<\/b><\/p>\n

                      \n
                    1. <\/b> Treat the absence of sufficient evidence as a possible reason not to provide a confident factual answer<\/span>
                      \n<\/span>2.<\/b> Invent a document that supports the response<\/span>
                      \n<\/span>3.<\/b> Always return the least relevant document<\/span>
                      \n<\/span>4.<\/b> Increase temperature until a reliable source appears<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. Treat the absence of sufficient evidence as a possible reason not to provide a confident factual answer<\/b><\/p>\n

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

                      If retrieved results do not meet a defined relevance threshold, the application may not have sufficient evidence to provide a grounded answer. A suitable response could acknowledge that the available knowledge base does not contain enough information, ask the user for clarification, or request additional details. This behavior is preferable to inventing evidence or presenting weakly related documents as authoritative sources. Increasing generation temperature cannot create missing evidence because it changes generation behavior rather than retrieval quality. Thresholds should be evaluated carefully because overly strict values can exclude useful documents, while overly permissive values can introduce noise. The objective is to balance retrieval coverage with evidence quality.<\/span><\/p>\n

                      Question 151. What does a context-window limitation imply for a RAG application?<\/b><\/p>\n

                        \n
                      1. <\/b> The application must manage the amount of prompt, history, and retrieved content sent to the model<\/span>
                        \n<\/span>2.<\/b> The model can process unlimited documents<\/span>
                        \n<\/span>3.<\/b> The vector database becomes unnecessary<\/span>
                        \n<\/span>4.<\/b> The model automatically summarizes every document<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1. The application must manage the amount of prompt, history, and retrieved content sent to the model<\/b><\/p>\n

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

                        A context-window limitation means that a model can process only a bounded amount of tokenized information in a request. A RAG application therefore needs to manage system instructions, user input, conversation history, retrieved documents, and expected output within the available context capacity. Techniques such as chunking, top-k selection, reranking, metadata filtering, query-focused retrieval, and conversation summarization can help control context size. Although some modern models support large context windows, they are still finite. A vector database remains useful because retrieval helps select relevant information rather than sending an entire knowledge base to the model. Context management is therefore an important architectural consideration.<\/span><\/p>\n

                        Question 152. Which practice can help maintain consistent behavior across multiple versions of a generative AI application?<\/b><\/p>\n

                          \n
                        1. <\/b> Version prompts, models, retrieval settings, and evaluation configurations<\/span>
                          \n<\/span>2.<\/b> Change all components simultaneously without records<\/span>
                          \n<\/span>3.<\/b> Delete previous configurations<\/span>
                          \n<\/span>4.<\/b> Avoid testing new releases<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 1. Version prompts, models, retrieval settings, and evaluation configurations<\/b><\/p>\n

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

                          Versioning important application artifacts helps teams understand exactly which configuration produced a particular result. Generative AI behavior can depend on the model version, prompt template, embedding model, retrieval parameters, data-processing logic, and evaluation configuration. Recording these components makes experiments reproducible and makes it easier to compare releases. If a new version produces a regression, version information can help identify what changed and support a rollback to a known configuration. Changing everything without records makes troubleshooting difficult. Versioning does not eliminate the need for evaluation, but it provides the foundation for controlled testing, deployment, and maintenance of generative AI systems.<\/span><\/p>\n

                          Question 153. What is the main difference between authentication and authorization?<\/b><\/p>\n

                            \n
                          1. <\/b> Authentication verifies identity, while authorization determines permitted access<\/span>
                            \n<\/span>2.<\/b> Authentication creates embeddings, while authorization generates text<\/span>
                            \n<\/span>3.<\/b> Authentication ranks documents, while authorization summarizes them<\/span>
                            \n<\/span>4.<\/b> Authentication controls temperature, while authorization controls tokens<\/span><\/li>\n<\/ol>\n

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

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

                            Authentication and authorization are related but distinct security concepts. Authentication verifies who a user, application, or service is, commonly through credentials, tokens, or another identity mechanism. Authorization determines what that authenticated identity is allowed to access or perform. In a generative AI application, authentication might establish the identity of a user accessing an endpoint, while authorization could determine which documents or model resources that user may retrieve. Both controls are important in enterprise environments, particularly when RAG systems access confidential information. Neither concept directly controls model temperature, embedding generation, document ranking, or response formatting.<\/span><\/p>\n

                            Question 154. Why is monitoring important after deploying a generative AI application?<\/b><\/p>\n

                              \n
                            1. <\/b> Production behavior can differ from development and evaluation conditions<\/span>
                              \n<\/span>2.<\/b> Monitoring automatically retrains every model<\/span>
                              \n<\/span>3.<\/b> Monitoring eliminates all security requirements<\/span>
                              \n<\/span>4.<\/b> Production applications never change after deployment<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. Production behavior can differ from development and evaluation conditions<\/b><\/p>\n

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

                              Production monitoring provides visibility into how an application behaves under real usage conditions. Even when an application performs well during development and evaluation, production traffic can introduce unexpected queries, load patterns, data changes, retrieval failures, latency problems, or model behavior that was not represented in testing. Monitoring can track relevant metrics such as latency, errors, throughput, retrieval quality signals, usage, and other application-specific indicators. Appropriate logging and tracing can also help investigate failures. Monitoring does not automatically retrain models or eliminate security requirements. It is an operational practice that helps teams detect issues and maintain reliable service after deployment.<\/span><\/p>\n

                              Question 155. Which technique can reduce the cost of repeatedly generating identical embeddings?<\/b><\/p>\n

                                \n
                              1. <\/b> Cache reusable embedding results<\/span>
                                \n<\/span>2.<\/b> Recalculate every embedding unnecessarily<\/span>
                                \n<\/span>3.<\/b> Increase model temperature<\/span>
                                \n<\/span>4.<\/b> Remove the vector index<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. Cache reusable embedding results<\/b><\/p>\n

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

                                Caching embedding results can reduce repeated computation when the same text is processed multiple times and the embedding configuration has not changed. Instead of generating an embedding again for identical content, an application can reuse a previously computed result. This can reduce compute consumption, processing time, and potentially operational cost. Cache invalidation must be considered carefully because changing the embedding model or modifying source text can make previously cached vectors unsuitable. Increasing generation temperature does not affect embedding computation, while removing the vector index would interfere with retrieval. Caching is therefore an optimization that should be applied where repeated deterministic work occurs.<\/span><\/p>\n

                                Question 156. What is a potential problem when too many retrieved documents are included in a prompt?<\/b><\/p>\n

                                  \n
                                1. <\/b> Irrelevant information may distract the model and consume context capacity<\/span>
                                  \n<\/span>2.<\/b> The model automatically becomes more grounded<\/span>
                                  \n<\/span>3.<\/b> Retrieval becomes unnecessary<\/span>
                                  \n<\/span>4.<\/b> Authentication is strengthened<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1. Irrelevant information may distract the model and consume context capacity<\/b><\/p>\n

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

                                  Including too many retrieved documents can introduce irrelevant or contradictory information into the model’s context. Even when useful evidence is present, excessive context can consume tokens that could otherwise be used for relevant information or response generation. This can also make it harder for the model to identify the most important evidence. Retrieval systems commonly address this through top-k tuning, similarity thresholds, metadata filtering, reranking, and improved chunking. More retrieved documents are not automatically better. The objective is to provide a focused set of high-quality evidence that supports the user’s question while staying within the available context window and maintaining acceptable latency and cost.<\/span><\/p>\n

                                  Question 157. Which evaluation approach can compare two versions of a RAG application using the same test cases?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Run both versions against the same evaluation dataset<\/span>
                                    \n<\/span>2.<\/b> Use unrelated questions for each version<\/span>
                                    \n<\/span>3.<\/b> Delete the baseline results<\/span>
                                    \n<\/span>4.<\/b> Compare only their interface colors<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Run both versions against the same evaluation dataset<\/b><\/p>\n

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

                                    Using the same evaluation dataset for two application versions creates a controlled basis for comparison. Developers can measure relevant quality and operational metrics under comparable conditions and determine whether a new prompt, retrieval strategy, model, or configuration improves or degrades performance. The dataset should contain representative examples and should be managed carefully to avoid leakage or overfitting. Using unrelated questions for each version makes direct comparison much more difficult because differences may come from the test data rather than the application change. Retaining baseline results is important for analysis. Controlled evaluation is a fundamental practice for reliable generative AI development.<\/span><\/p>\n

                                    Question 158. What is the role of feedback in improving a production generative AI system?<\/b><\/p>\n

                                      \n
                                    1. <\/b> It can reveal real-world failure patterns and opportunities for improvement<\/span>
                                      \n<\/span>2.<\/b> It guarantees every response is correct<\/span>
                                      \n<\/span>3.<\/b> It replaces all automated evaluation<\/span>
                                      \n<\/span>4.<\/b> It eliminates the need for monitoring<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. It can reveal real-world failure patterns and opportunities for improvement<\/b><\/p>\n

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

                                      User or operational feedback can reveal problems that may not have appeared in development datasets. Feedback can identify incorrect answers, missing information, poor retrieval, confusing responses, formatting issues, or other areas where the application does not meet user needs. When collected and handled appropriately, these observations can contribute to new evaluation cases and guide improvements to prompts, retrieval, source data, or model selection. Feedback does not guarantee correctness and should not replace automated evaluation or production monitoring. Instead, it complements those practices by providing evidence about real-world usage and helping teams expand their understanding of application behavior.<\/span><\/p>\n

                                      Question 159. Why should an application distinguish between source data quality and model quality during evaluation?<\/b><\/p>\n

                                        \n
                                      1. <\/b> A poor response may result from either weak source information or model behavior<\/span>
                                        \n<\/span>2.<\/b> Source data never affects generated responses<\/span>
                                        \n<\/span>3.<\/b> Model quality is unrelated to evaluation<\/span>
                                        \n<\/span>4.<\/b> Both are always identical measurements<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. A poor response may result from either weak source information or model behavior<\/b><\/p>\n

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

                                        A RAG application contains multiple components, so an incorrect response does not necessarily indicate that the language model itself is the sole cause. The source documents may be outdated, incomplete, contradictory, or incorrect. Retrieval may also fail to locate the appropriate evidence, while the generation model may misinterpret or improperly use retrieved context. Separating these factors during evaluation helps teams identify the actual source of a failure and choose an appropriate remedy. Improving the model will not necessarily solve a missing-document problem, just as improving source data may not solve a generation problem. Component-level evaluation therefore supports more effective troubleshooting.<\/span><\/p>\n

                                        Question 160. Which sequence best represents a typical RAG request flow?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Generate \u2192 retrieve \u2192 authenticate \u2192 tokenize<\/span>
                                          \n<\/span>2.<\/b> Retrieve \u2192 delete context \u2192 generate \u2192 ignore output<\/span>
                                          \n<\/span>3.<\/b> Query \u2192 retrieve relevant context \u2192 construct prompt \u2192 generate response<\/span>
                                          \n<\/span>4.<\/b> Generate \u2192 create documents \u2192 retrieve \u2192 validate identity<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Query \u2192 retrieve relevant context \u2192 construct prompt \u2192 generate response<\/b><\/p>\n

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

                                          A typical RAG request begins with a user’s query, which may first undergo preprocessing or rewriting. The application then uses the query to retrieve relevant information from an external knowledge source. Retrieved content is combined with the user’s request and system instructions to construct the prompt supplied to the generation model. The model generates a response using this context, and additional validation, filtering, or monitoring may occur depending on the architecture. This sequence separates knowledge retrieval from response generation and allows the system to incorporate external information at inference time. Effective retrieval, prompt construction, and generation all contribute to the overall quality of the final response.<\/span><\/p>\n

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

                                          View Full Databricks Certified Generative AI Engineer Associate Exam Dumps and Practice Test Dumps   Question 141. Which component is responsible for finding relevant information from a knowledge base in a RAG application? Generator 2. Retriever 3. Tokenizer 4. Output validator Correct Answer: 2. Retriever Explanation: The retriever is the component responsible for finding information […]<\/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\/18137"}],"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=18137"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18137\/revisions"}],"predecessor-version":[{"id":18138,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18137\/revisions\/18138"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18137"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18137"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18137"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}