{"id":18139,"date":"2026-09-22T05:38:22","date_gmt":"2026-09-22T05:38:22","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18139"},"modified":"2026-09-22T05:38:22","modified_gmt":"2026-09-22T05:38:22","slug":"databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part9-q161-180","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/databricks-certified-generative-ai-engineer-associate-practice-test-questions-and-exam-dumps-part9-q161-180\/","title":{"rendered":"Databricks Certified Generative AI Engineer Associate Practice Test Questions and Exam Dumps Part9 Q161-180"},"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 161. What is the primary purpose of grounding a generative AI response?<\/b><\/p>\n

    \n
  1. <\/b> To make the response longer<\/span>
    \n<\/span>2.<\/b> To increase model temperature<\/span>
    \n<\/span>3.<\/b> To connect generated claims to reliable provided information<\/span>
    \n<\/span>4.<\/b> To eliminate the need for retrieval<\/span><\/li>\n<\/ol>\n

    Correct Answer: 3. To connect generated claims to reliable provided information<\/b><\/p>\n

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

    Grounding means generating responses using reliable information supplied to the model rather than relying entirely on unsupported model knowledge. In a RAG application, retrieved documents can provide evidence that the model uses when constructing its answer. Grounding is especially useful for enterprise knowledge assistants where responses should reflect organizational policies, documentation, or other authoritative sources. Although grounding can reduce unsupported claims, it does not guarantee that every response will be correct. The quality of the source material and retrieval process remains important. Grounding also works together with prompt instructions, evaluation, validation, and monitoring to create a more reliable generative AI workflow.<\/span><\/p>\n

    Question 162. Which component converts a user’s query into a vector for semantic similarity search?<\/b><\/p>\n

      \n
    1. <\/b> Embedding model<\/span>
      \n<\/span>2.<\/b> Output validator<\/span>
      \n<\/span>3.<\/b> Reranker<\/span>
      \n<\/span>4.<\/b> Guardrail<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. Embedding model<\/b><\/p>\n

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

      An embedding model transforms text such as a user’s query into a numerical vector representation. The resulting vector can then be compared with vectors representing stored document chunks to identify content with similar semantic meaning. This allows a retrieval system to find relevant information even when the query and document use different wording. The same or a compatible embedding approach is generally used when preparing documents for indexing so that query and document vectors can be compared consistently. A reranker can refine results after initial retrieval, while a validator checks generated output. Embeddings therefore form a core foundation of semantic vector search.<\/span><\/p>\n

      Question 163. What is one reason to use a reranker after initial vector retrieval?<\/b><\/p>\n

        \n
      1. <\/b> To improve the ordering of candidate documents based on query relevance<\/span>
        \n<\/span>2.<\/b> To permanently modify the source documents<\/span>
        \n<\/span>3.<\/b> To replace the language model<\/span>
        \n<\/span>4.<\/b> To increase user authentication strength<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. To improve the ordering of candidate documents based on query relevance<\/b><\/p>\n

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

        Initial vector retrieval is generally optimized for efficiently finding candidate documents that are semantically similar to a query. However, similarity alone may not always produce the most useful ranking. A reranker can examine the query and retrieved candidates more deeply and assign a refined relevance order. This can place the strongest evidence closer to the beginning of the context supplied to the language model. Reranking can therefore improve the quality of the information available during generation. It does not modify source documents, replace the generation model, or provide authentication. Its role is specifically to refine candidate retrieval results before generation.<\/span><\/p>\n

        Question 164. Which action can help maintain a clean RAG knowledge base?<\/b><\/p>\n

          \n
        1. <\/b> Keep every outdated document indefinitely<\/span>
          \n<\/span>2.<\/b> Remove duplicates and obsolete content according to data-management rules<\/span>
          \n<\/span>3.<\/b> Disable document updates<\/span>
          \n<\/span>4.<\/b> Increase model temperature<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2. Remove duplicates and obsolete content according to data-management rules<\/b><\/p>\n

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

          A clean knowledge base helps a RAG system retrieve accurate and relevant information. Duplicate documents can cause redundant results, while obsolete documents may cause the assistant to provide outdated information. A data-management process can identify duplicate records, replace superseded versions, and remove content that should no longer be used. Metadata such as version numbers and effective dates can further support document lifecycle management. Increasing model temperature does not improve the quality of source data, and disabling updates prevents current information from reaching the index. Maintaining source quality is therefore an important part of RAG engineering and should be handled as an ongoing data-management process.<\/span><\/p>\n

          Question 165. What can a similarity threshold help determine during retrieval?<\/b><\/p>\n

            \n
          1. <\/b> Whether a retrieved result is sufficiently similar to the query to be considered<\/span>
            \n<\/span>2.<\/b> Whether a user should be authenticated<\/span>
            \n<\/span>3.<\/b> Whether the model needs more training data<\/span>
            \n<\/span>4.<\/b> Whether the endpoint should generate tokens faster<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. Whether a retrieved result is sufficiently similar to the query to be considered<\/b><\/p>\n

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

            A similarity threshold provides a rule for determining whether retrieved candidates are sufficiently related to a user’s query. If a candidate’s similarity score does not meet the defined threshold, the application can exclude it from the context or treat the retrieval result as insufficient. This can reduce irrelevant information and help the system avoid generating answers from weakly related documents. Threshold selection should be based on evaluation because an excessively high threshold can remove useful evidence, while a very low threshold can introduce noise. Similarity thresholds do not authenticate users or improve model training. They are retrieval controls used to manage relevance.<\/span><\/p>\n

            Question 166. Which retrieval method is particularly useful when exact identifiers or terms must match?<\/b><\/p>\n

              \n
            1. <\/b> Lexical or keyword search<\/span>
              \n<\/span>2.<\/b> Random generation<\/span>
              \n<\/span>3.<\/b> Conversation summarization<\/span>
              \n<\/span>4.<\/b> Output formatting<\/span><\/li>\n<\/ol>\n

              Correct Answer: 1. Lexical or keyword search<\/b><\/p>\n

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

              Lexical or keyword search is useful when exact terms have significant importance. Examples include error codes, product IDs, document numbers, technical commands, legal references, and specific names. Semantic search can identify conceptually related content, but exact-match techniques can be more effective when the precise wording or identifier matters. Many RAG systems combine lexical and semantic retrieval through hybrid search to cover both use cases. Conversation summarization and output formatting serve different purposes and do not directly perform document retrieval. Selecting an appropriate search method depends on the application’s content, query patterns, and the types of information users need to locate.<\/span><\/p>\n

              Question 167. Why can hybrid retrieval be useful in enterprise knowledge systems?<\/b><\/p>\n

                \n
              1. <\/b> It can combine semantic similarity with exact keyword matching<\/span>
                \n<\/span>2.<\/b> It removes the need for source data<\/span>
                \n<\/span>3.<\/b> It guarantees every generated answer<\/span>
                \n<\/span>4.<\/b> It replaces authorization<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. It can combine semantic similarity with exact keyword matching<\/b><\/p>\n

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

                Hybrid retrieval combines multiple retrieval approaches, commonly semantic vector search and lexical or keyword search. Semantic search is useful when a query expresses an idea differently from the wording in the source material, while lexical search can perform strongly when exact terms, identifiers, or phrases matter. Combining both can make retrieval more robust across diverse enterprise content. Hybrid retrieval does not guarantee that generated answers are correct because generation quality still depends on source quality, retrieval accuracy, and model behavior. It also does not replace authorization. Access controls must remain in place to ensure that users only retrieve information they are permitted to access.<\/span><\/p>\n

                Question 168. What is an important consideration when selecting chunk boundaries?<\/b><\/p>\n

                  \n
                1. <\/b> Chunks should preserve meaningful semantic units when possible<\/span>
                  \n<\/span>2.<\/b> Every document should become one enormous chunk<\/span>
                  \n<\/span>3.<\/b> Chunk boundaries should be selected randomly<\/span>
                  \n<\/span>4.<\/b> Chunking should eliminate all metadata<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 1. Chunks should preserve meaningful semantic units when possible<\/b><\/p>\n

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

                  Effective chunking attempts to divide documents into sections that retain meaningful information together. For example, a heading and its associated explanation may be more useful when kept within the same chunk rather than separated arbitrarily. Poor chunk boundaries can cause retrieved passages to lack necessary context or include excessive unrelated content. The appropriate chunk size depends on the document structure, embedding model, retrieval strategy, and application requirements. Very large chunks may introduce noise, while extremely small chunks may fragment important information. Metadata should generally be preserved because it can support filtering and traceability. Chunking should therefore be designed and evaluated rather than applied randomly.<\/span><\/p>\n

                  Question 169. What is the purpose of an ingestion pipeline in a RAG architecture?<\/b><\/p>\n

                    \n
                  1. <\/b> Prepare and index source content for retrieval<\/span>
                    \n<\/span>2.<\/b> Generate every final user response<\/span>
                    \n<\/span>3.<\/b> Authenticate users at login<\/span>
                    \n<\/span>4.<\/b> Increase the model’s temperature<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. Prepare and index source content for retrieval<\/b><\/p>\n

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

                    An ingestion pipeline prepares source information so that it can be searched and retrieved by the application. Typical steps can include extracting content, cleaning it, splitting it into chunks, attaching metadata, generating embeddings, and writing the resulting records to an index or vector store. For changing knowledge sources, the pipeline can also detect updates and refresh affected records. The ingestion process is separate from the online generation stage, where a user query is processed and relevant content is retrieved. It does not normally generate the final answer or authenticate users. A reliable ingestion pipeline helps keep the knowledge base consistent, searchable, and current.<\/span><\/p>\n

                    Question 170. Why should an ingestion pipeline handle document updates carefully?<\/b><\/p>\n

                      \n
                    1. <\/b> Incorrect update handling can leave stale or conflicting information in the index<\/span>
                      \n<\/span>2.<\/b> Updates always improve every response automatically<\/span>
                      \n<\/span>3.<\/b> Updates eliminate the need for evaluation<\/span>
                      \n<\/span>4.<\/b> Updates permanently increase model capacity<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1. Incorrect update handling can leave stale or conflicting information in the index<\/b><\/p>\n

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

                      When source documents change, the corresponding indexed records must be updated appropriately. If old versions remain active alongside new versions without suitable metadata or filtering, retrieval may return conflicting information. If an updated document is not reprocessed, the index may continue to contain stale embeddings and outdated text. An ingestion pipeline should therefore define how additions, modifications, deletions, and superseded versions are handled. Effective-date and version metadata can help manage these situations. Updating the index does not automatically guarantee better responses, and evaluation remains important after data changes. Proper update handling supports information freshness and retrieval consistency.<\/span><\/p>\n

                      Question 171. Which metric is most directly related to how many requests a service can process over time?<\/b><\/p>\n

                        \n
                      1. <\/b> Groundedness<\/span>
                        \n<\/span>2.<\/b> Throughput<\/span>
                        \n<\/span>3.<\/b> Retrieval precision<\/span>
                        \n<\/span>4.<\/b> Answer relevance<\/span><\/li>\n<\/ol>\n

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

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

                        Throughput measures the amount of work a system can process over a given period. In a model-serving environment, it can be represented by requests per second, tokens processed per second, or another workload-specific unit. Throughput is useful for understanding whether a service can support expected traffic levels and how performance changes as demand increases. It is different from latency, which measures how long an individual request takes to complete. Groundedness, retrieval precision, and answer relevance are primarily quality-oriented measures. Production monitoring should generally consider throughput alongside latency, errors, resource utilization, and application quality so that teams can understand both operational capacity and user-facing behavior.<\/span><\/p>\n

                        Question 172. What can latency monitoring reveal in a RAG application?<\/b><\/p>\n

                          \n
                        1. <\/b> Which parts of the workflow may be contributing to slow responses<\/span>
                          \n<\/span>2.<\/b> Whether every answer is factually correct<\/span>
                          \n<\/span>3.<\/b> Whether a source document is permanently accurate<\/span>
                          \n<\/span>4.<\/b> Whether a user prefers a particular writing style<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 1. Which parts of the workflow may be contributing to slow responses<\/b><\/p>\n

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

                          Latency monitoring can help identify performance bottlenecks in different stages of a RAG workflow. Developers may measure total request time as well as individual stages such as query processing, vector search, reranking, prompt construction, model inference, and downstream operations. If retrieval is taking much longer than generation, optimization efforts can focus on the retrieval infrastructure. If generation dominates latency, model or serving configuration may need investigation. Latency does not directly determine factual accuracy or source correctness. Detailed monitoring therefore provides useful operational evidence and can help teams improve responsiveness without assuming that a slow application necessarily has a quality problem.<\/span><\/p>\n

                          Question 173. Which approach can help control the amount of conversation history sent to a model?<\/b><\/p>\n

                            \n
                          1. <\/b> Summarize older messages and retain relevant recent context<\/span>
                            \n<\/span>2.<\/b> Include every historical message indefinitely<\/span>
                            \n<\/span>3.<\/b> Delete the current user query<\/span>
                            \n<\/span>4.<\/b> Remove all system instructions<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. Summarize older messages and retain relevant recent context<\/b><\/p>\n

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

                            Long conversations can consume a significant portion of a model’s context window. Summarizing older messages allows an application to retain important facts, decisions, and conversational state without sending every historical message in full. Recent messages can then be retained directly when their detailed wording remains important. This approach can reduce token consumption while preserving useful context. However, summaries may omit details or introduce errors, so the application should determine which information must be preserved exactly. Including unlimited history can create context pressure and irrelevant information. Removing the current query or system instructions would undermine the model’s ability to understand and safely respond to the request.<\/span><\/p>\n

                            Question 174. What is one benefit of using a structured output schema?<\/b><\/p>\n

                              \n
                            1. <\/b> It makes responses easier to validate and consume programmatically<\/span>
                              \n<\/span>2.<\/b> It guarantees the model’s factual correctness<\/span>
                              \n<\/span>3.<\/b> It removes the need for prompts<\/span>
                              \n<\/span>4.<\/b> It replaces the knowledge base<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. It makes responses easier to validate and consume programmatically<\/b><\/p>\n

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

                              Structured output schemas define the expected format of a model response, including fields, data types, and sometimes required or optional elements. This is valuable when generated information must be passed to software components that expect predictable data. For example, an application can validate whether a response contains required fields before sending it to a database or another API. Structured outputs do not guarantee that the values are factually correct, so semantic evaluation and grounding remain necessary. They also do not eliminate prompts or external knowledge sources. Their primary benefit is making model output more predictable, machine-readable, and easier to validate.<\/span><\/p>\n

                              Question 175. Why should model outputs sometimes be validated before being passed to downstream systems?<\/b><\/p>\n

                                \n
                              1. <\/b> Validation can detect malformed or unexpected output before it causes downstream problems<\/span>
                                \n<\/span>2.<\/b> Validation automatically retrains the model<\/span>
                                \n<\/span>3.<\/b> Validation increases vector-search recall<\/span>
                                \n<\/span>4.<\/b> Validation eliminates the need for monitoring<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. Validation can detect malformed or unexpected output before it causes downstream problems<\/b><\/p>\n

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

                                Generative models produce probabilistic outputs, so applications should not always assume that every response will exactly match the format expected by downstream software. Validation can check required fields, data types, allowed values, length constraints, or other application-specific requirements before the response is processed further. If the output fails validation, the application can reject it, request a corrected response, or route the case for additional handling. Validation does not retrain the model or directly improve retrieval recall. It is one layer of reliability that can protect deterministic application components from malformed model output and should be combined with appropriate evaluation and monitoring.<\/span><\/p>\n

                                Question 176. What is a key purpose of application observability?<\/b><\/p>\n

                                  \n
                                1. <\/b> Provide visibility into system behavior and help diagnose problems<\/span>
                                  \n<\/span>2.<\/b> Replace all security controls<\/span>
                                  \n<\/span>3.<\/b> Increase model context automatically<\/span>
                                  \n<\/span>4.<\/b> Guarantee zero production failures<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1. Provide visibility into system behavior and help diagnose problems<\/b><\/p>\n

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

                                  Observability provides information that helps teams understand what is happening inside an application and diagnose unexpected behavior. For a generative AI system, useful observability can include request latency, errors, retrieval results, model versions, prompt versions, token usage, endpoint performance, and other relevant signals. Traces can connect these events across multiple components so that a team can investigate where a failure occurred. Observability does not guarantee that failures will never happen and does not replace authentication, authorization, or other security controls. Instead, it gives developers and operators the information needed to detect issues, investigate causes, and improve the system over time.<\/span><\/p>\n

                                  Question 177. Which practice can help make generative AI experiments reproducible?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Record the relevant model, prompt, data, and configuration versions<\/span>
                                    \n<\/span>2.<\/b> Change several variables without recording them<\/span>
                                    \n<\/span>3.<\/b> Delete evaluation results after every experiment<\/span>
                                    \n<\/span>4.<\/b> Use a different evaluation dataset for every comparison<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Record the relevant model, prompt, data, and configuration versions<\/b><\/p>\n

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

                                    Reproducibility requires enough information to recreate an experiment and understand why a particular result occurred. In generative AI applications, this may include the model version, prompt template, embedding model, source-data version, retrieval parameters, generation settings, and evaluation dataset. Recording these artifacts makes it possible to compare experiments consistently and identify which change affected performance. Without this information, developers may struggle to reproduce a successful result or diagnose a regression. Deleting evaluation results and changing datasets between experiments also makes comparisons less meaningful. Version tracking is therefore an important engineering practice for controlled experimentation and reliable generative AI development.<\/span><\/p>\n

                                    Question 178. What can user feedback contribute to an evaluation dataset?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Real-world failure cases and representative examples of user needs<\/span>
                                      \n<\/span>2.<\/b> Automatic model-weight updates<\/span>
                                      \n<\/span>3.<\/b> Guaranteed factual answers<\/span>
                                      \n<\/span>4.<\/b> Permanent elimination of security risks<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. Real-world failure cases and representative examples of user needs<\/b><\/p>\n

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

                                      User feedback can provide valuable examples of how an application performs in actual usage. Feedback may identify incorrect answers, missing information, confusing responses, poor retrieval, or requests that were not represented in the original evaluation dataset. With appropriate privacy and governance controls, useful feedback cases can be transformed into evaluation examples that help test future versions. This creates a feedback loop between production usage and development. User feedback does not automatically change model weights or guarantee correctness. It should complement structured evaluation, monitoring, and expert review rather than replace them. Real-world examples can help make future testing more representative of actual user needs.<\/span><\/p>\n

                                      Question 179. Why is it useful to evaluate retrieval separately from final answer quality?<\/b><\/p>\n

                                        \n
                                      1. <\/b> It helps determine whether a failure originated in retrieval or generation<\/span>
                                        \n<\/span>2.<\/b> Retrieval quality has no effect on generation<\/span>
                                        \n<\/span>3.<\/b> It eliminates the need for model evaluation<\/span>
                                        \n<\/span>4.<\/b> It guarantees perfect source data<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1. It helps determine whether a failure originated in retrieval or generation<\/b><\/p>\n

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

                                        A RAG application contains multiple stages, and evaluating them separately can make troubleshooting much easier. Retrieval evaluation can determine whether relevant documents are being found, while answer evaluation can determine whether the model uses the supplied evidence appropriately. If the correct document was never retrieved, changing the generation prompt may not solve the underlying problem. Conversely, if highly relevant evidence was retrieved but the answer is still incorrect, the generation stage may require investigation. Separating these evaluations helps teams identify component-level weaknesses and choose targeted improvements. It also supports more meaningful experimentation with retrieval settings, prompts, models, and source data.<\/span><\/p>\n

                                        Question 180. Which approach best supports reliable deployment of a generative AI application?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Deploy changes without evaluation or monitoring<\/span>
                                          \n<\/span>2.<\/b> Test representative cases, version artifacts, deploy carefully, and monitor results<\/span>
                                          \n<\/span>3.<\/b> Make random production changes whenever users report an issue<\/span>
                                          \n<\/span>4.<\/b> Remove rollback procedures<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2. Test representative cases, version artifacts, deploy carefully, and monitor results<\/b><\/p>\n

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

                                          Reliable deployment involves more than simply placing a new model or prompt into production. Teams should evaluate changes against representative test cases, compare them with a known baseline, and record relevant versions of models, prompts, data, and retrieval configuration. Deployment can then be performed using appropriate release controls, with monitoring used to identify unexpected changes in quality, latency, errors, or resource consumption. A rollback mechanism can provide an additional safeguard when a release causes unacceptable behavior. Random production changes make it difficult to determine what caused a problem. A structured development, evaluation, deployment, and monitoring process supports more predictable and maintainable generative AI systems.<\/span><\/p>\n

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

                                          View Full Databricks Certified Generative AI Engineer Associate Exam Dumps and Practice Test Dumps   Question 161. What is the primary purpose of grounding a generative AI response? To make the response longer 2. To increase model temperature 3. To connect generated claims to reliable provided information 4. To eliminate the need for retrieval Correct […]<\/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\/18139"}],"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=18139"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18139\/revisions"}],"predecessor-version":[{"id":18140,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18139\/revisions\/18140"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18139"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18139"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18139"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}