Free Databricks Databricks-Generative-AI-Engineer-Associate Practice Exam with Questions & Answers | Set: 2

The scenario describes a common " retrieval gap " where the initial bi-encoder (embedding model) used for vector search identifies relevant documents but does not rank them perfectly. This happens because embedding models represent entire documents as a single vector, which can lose nuance. The standard engineering solution is to implement a Reranker (Cross-Encoder). Unlike embedding models, a reranker processes the query and a candidate document simultaneously, allowing it to capture deep semantic interactions between the two. In a Mosaic AI workflow, after the vector search retrieves the top $k$ documents, the reranker evaluates those specific $k$ documents to produce a more accurate relevance score. This ensures that the most contextually relevant documents are placed at the top of the list (and thus the top of the LLM prompt), which is crucial because LLMs are sensitive to document order and often prioritize information found at the beginning of the context.

In the context of designing a chatbot to engage users on a gaming platform, diversity of responses (option B) is a key metric to increase user engagement and retention. Here’s why:

Diverse and Engaging Interactions : A chatbot that provides varied and interesting responses will keep users engaged, especially in an interactive environment like a gaming platform. Gamers typically enjoy dynamic and evolving conversations, and diversity of responses helps prevent monotony, encouraging users to interact more frequently with the bot.

Increasing Retention : By offering different types of responses to similar queries, the chatbot can create a sense of novelty and excitement, which enhances the user’s experience and makes them more likely to return to the platform.

Why Other Options Are Less Effective :

A (Randomness) : Random responses can be confusing or irrelevant, leading to frustration and reducing engagement.

C (Lack of Relevance) : If responses are not relevant to the user’s queries, this will degrade the user experience and lead to disengagement.

D (Repetition of Responses) : Repetitive responses can quickly bore users, making the chatbot feel uninteresting and reducing the likelihood of continued interaction.

Thus, diversity of responses (option B) is the most effective way to keep users engaged and retain them on the platform.

The task requires an LLM pipeline for multi-stage reasoning with external tools, necessitating planning, adaptability, and complex reasoning. Let’s evaluate the options based on Databricks’ recommendations for advanced LLM workflows.

Option A: Train the LLM to generate a single, comprehensive response without interacting with any external tools, relying solely on its pre-trained knowledge

This approach limits the LLM to its static knowledge base, excluding external tools and multi-stage reasoning. It can’t adapt or plan actions dynamically, failing the requirements.

Databricks Reference : " External tools enhance LLM capabilities beyond pre-trained knowledge " ( " Building LLM Applications with Databricks, " 2023).

Option B: Implement a framework like ReAct which allows the LLM to generate reasoning traces and perform task-specific actions that leverage external tools if necessary

ReAct (Reasoning + Acting) combines reasoning traces (step-by-step logic) with actions (e.g., tool calls), enabling the LLM to plan, adapt, and execute complex tasks iteratively. This meets all requirements: multi-stage reasoning, tool use, and adaptability.

Databricks Reference : " Frameworks like ReAct enable LLMs to interleave reasoning and external tool interactions for complex problem-solving " ( " Generative AI Cookbook, " 2023).

Option C: Encourage the LLM to make multiple API calls in sequence without planning or structuring the calls, allowing the LLM to decide when and how to use external tools spontaneously

Unstructured, spontaneous API calls lack planning and may lead to inefficient or incorrect tool usage. This doesn’t ensure effective multi-stage reasoning or adaptability.

Databricks Reference : Structured frameworks are preferred: " Ad-hoc tool calls can reduce reliability in complex tasks " ( " Building LLM-Powered Applications " ).

Option D: Use a Chain-of-Thought (CoT) prompting technique to guide the LLM through a series of reasoning steps, then manually input the results from external tools for the final answer

CoT improves reasoning but relies on manual tool interaction, breaking automation and adaptability. It’s not a scalable pipeline solution.

Databricks Reference : " Manual intervention is impractical for production LLM pipelines " ( " Databricks Generative AI Engineer Guide " ).

Conclusion : Option B (ReAct) is the best approach, as it integrates reasoning and tool use in a structured, adaptive framework, aligning with Databricks’ guidance for complex LLM workflows.

Model inversion attacks occur when an attacker uses the model ' s outputs to reconstruct the sensitive training data used during the fine-tuning process. To mitigate this in a public-facing application, implementing AI Guardrails is the most relevant strategy. Guardrails act as a programmable " filter " between the LLM and the end-user. They can be configured to detect if a model ' s response contains patterns that look like proprietary training data or PII (Personally Identifiable Information). While ACLs (B) and ABAC (D) protect the model ' s infrastructure (who can invoke the API), they do not inspect the content of the output, which is where the inversion attack actually manifests. Databricks provides integrated guardrail capabilities (via Mosaic AI Gateway) specifically to enforce compliance and prevent the leakage of sensitive internal knowledge that may have been baked into the model weights during fine-tuning.

To mitigate the issue of the LLM including explanations of how summaries are generated in its output, the best approach is to adjust the training or prompt structure. Here’s why Option D is effective:

Few-shot Learning : By providing specific examples of how the desired output should look (i.e., just the summary without explanation), the model learns the preferred format. This few-shot learning approach helps the model understand not only what content to generate but also how to format its responses.

Prompt Engineering : Adjusting the user prompt to specify the desired output format clearly can guide the LLM to produce summaries without additional explanatory text. Effective prompt design is crucial in controlling the behavior of generative models.

Why Other Options Are Less Suitable:

A : While technically feasible, splitting the output by newline and truncating could lead to loss of important content or create awkward breaks in the summary.

B : Tuning chunk sizes or changing embedding models does not directly address the issue of the model ' s tendency to generate explanations along with summaries.

C : Revisiting document ingestion logic ensures accurate source data but does not influence how the model formats its output.

By using few-shot examples and refining the prompt, the engineer directly influences the output format, making this approach the most targeted and effective solution.

In the Agent Evaluation terminology used by this question, correctness compares the generated response with the expected answer, while context_sufficiency determines whether the retrieved context contains enough information to produce that expected answer. Both therefore depend on ground-truth information supplied through expected_response. Groundedness instead examines whether the response is supported by the retrieved context; it does not inherently need a reference answer. Chunk relevance and relevance to the query assess alignment with the user’s request, while guideline adherence evaluates compliance with specified instructions. Databricks explicitly distinguishes the ground-truth-dependent judges in its migration documentation. In MLflow 3, names and schemas have evolved, including expectations.expected_response and explicitly selected scorers, so the question should be interpreted using its stated legacy judge terminology. Databricks documentation

The task is to set up a Databricks Vector Search index for news articles, supporting queries like “monster truck news around January 5th, 1992,” with minimal effort. The index must filter by topic and a 10-day date range. Let’s evaluate the options.

Option A: Split articles by 10-day blocks and return the block closest to the query

Pre-splitting articles into 10-day blocks requires significant preprocessing and index management (e.g., one index per block). It’s effort-intensive and inflexible for dynamic date ranges.

Databricks Reference : " Static partitioning increases setup complexity; metadata filtering is preferred " ( " Databricks Vector Search Documentation " ).

Option B: Include metadata columns for article date and topic to support metadata filtering

Adding date and topic as metadata in the Vector Search index allows dynamic filtering (e.g., date ± 5 days, topic = “monster truck”) at query time. This leverages Databricks’ built-in metadata filtering, minimizing setup effort.

Databricks Reference : " Vector Search supports metadata filtering on columns like date or category for precise retrieval with minimal preprocessing " ( " Vector Search Guide, " 2023).

Option C: Pass the query directly to the vector search index and return the best articles

Passing the full query (e.g., “Tell me about monster truck news around January 5th, 1992”) to Vector Search relies solely on embeddings, ignoring structured filtering for date and topic. This risks inaccurate results without explicit range logic.

Databricks Reference : " Pure vector similarity may not handle temporal or categorical constraints effectively " ( " Building LLM Applications with Databricks " ).

Option D: Create separate indexes by topic and add a classifier model to appropriately pick the best index

Separate indexes per topic plus a classifier model adds significant complexity (index creation, model training, maintenance), far exceeding “least effort.” It’s overkill for this use case.

Databricks Reference : " Multiple indexes increase overhead; single-index with metadata is simpler " ( " Databricks Vector Search Documentation " ).

Conclusion : Option B is the simplest and most effective solution, using metadata filtering in a single Vector Search index to handle date ranges and topics, aligning with Databricks’ emphasis on efficient, low-effort setups.

Problem Context : After switching to a model with a shorter context length, the error message indicating that the prompt token count has exceeded the limit suggests that the input to the model is too large.

Explanation of Options :

Option A: Use a smaller embedding model to generate – This wouldn ' t necessarily address the issue of prompt size exceeding the model’s token limit.

Option B: Reduce the maximum output tokens of the new model – This option affects the output length, not the size of the input being too large.

Option C: Decrease the chunk size of embedded documents – This would help reduce the size of each document chunk fed into the model, ensuring that the input remains within the model ' s context length limitations.

Option D: Reduce the number of records retrieved from the vector database – By retrieving fewer records, the total input size to the model can be managed more effectively, keeping it within the allowable token limits.

Option E: Retrain the response generating model using ALiBi – Retraining the model is contrary to the stipulation not to change the response generating model.

Options C and D are the most effective solutions to manage the model’s shorter context length without changing the model itself, by adjusting the input size both in terms of individual document size and total documents retrieved.

The task described in the question involves enhancing customer experience by automatically handling common customer inquiries using an LLM-powered AI solution. This requires the system to process input data (customer inquiries) and generate personalized, relevant responses efficiently. Let’s evaluate the options step-by-step in the context of Databricks Generative AI Engineer principles, which emphasize leveraging LLMs for tasks like question answering, summarization, and retrieval-augmented generation (RAG).

Option A: Input: Customer reviews; Output: Group the reviews by users and aggregate per-user average rating, then respond

This option focuses on analyzing customer reviews to compute average ratings per user. While this might be useful for sentiment analysis or user profiling, it does not directly address the goal of handling common customer inquiries or improving response times for personalized interactions. Customer reviews are typically feedback data, not real-time inquiries requiring immediate responses.

Databricks Reference : Databricks documentation on LLMs (e.g., " Building LLM Applications with Databricks " ) emphasizes that LLMs excel at tasks like question answering and conversational responses, not just aggregation or statistical analysis of reviews.

Option B: Input: Customer service chat logs; Output: Group the chat logs by users, followed by summarizing each user ' s interactions, then respond

This option uses chat logs as input, which aligns with customer service scenarios. However, the output—grouping by users and summarizing interactions—focuses on user-specific summaries rather than directly addressing inquiries. While summarization is an LLM capability, this approach lacks the specificity of finding answers to common questions, which is central to the problem.

Databricks Reference : Per Databricks’ " Generative AI Cookbook, " LLMs can summarize text, but for customer service, the emphasis is on retrieval and response generation (e.g., RAG workflows) rather than user interaction summaries alone.

Option C: Input: Customer service chat logs; Output: Find the answers to similar questions and respond with a summary

This option uses chat logs (real customer inquiries) as input and tasks the LLM with identifying answers to similar questions, then providing a summarized response. This directly aligns with the goal of handling common inquiries efficiently while maintaining personalization (by referencing past interactions or similar cases). It leverages LLM capabilities like semantic search, retrieval, and response generation, which are core to Databricks’ LLM workflows.

Databricks Reference : From Databricks documentation ( " Building LLM-Powered Applications, " 2023), an exact extract states: " For customer support use cases, LLMs can be used to retrieve relevant answers from historical data like chat logs and generate concise, contextually appropriate responses. " This matches Option C’s approach of finding answers and summarizing them.

Option D: Input: Customer reviews; Output: Classify review sentiment

This option focuses on sentiment classification of reviews, which is a valid LLM task but unrelated to handling customer inquiries or improving response times in a conversational context. It’s more suited for feedback analysis than real-time customer service.

Databricks Reference : Databricks’ " Generative AI Engineer Guide " notes that sentiment analysis is a common LLM task, but it’s not highlighted for real-time conversational applications like customer support.

Conclusion : Option C is the best fit because it uses relevant input (chat logs) and defines an LLM task (finding answers and summarizing) that meets the requirements of improving response times and maintaining personalized interaction. This aligns with Databricks’ recommended practices for LLM-powered customer service solutions, such as retrieval-augmented generation (RAG) workflows.

A best describes the dataset-based evaluation and inference-table-based monitoring workflow referenced in the question. Evaluation runs an application against selected test cases, collects traces, and calculates metrics to compare versions or detect regressions. Production monitoring examines real usage over time to identify operational or quality problems. Evaluation does not require all historical inference records, and monitoring is not limited to latency or service-level metrics; it can also assess response quality and policy adherence. Option B incorrectly treats production tracing as the defining evaluation activity. Current MLflow 3 monitoring can apply scorers directly to production traces, so inference-table metrics profiles are one documented monitoring architecture rather than a universal requirement for every modern Databricks deployment. Evaluation documentation , monitoring documentation