Free Databricks Certified Generative AI Engineer Associate Sample Questions

Correct answer: A — Structured information extraction against a defined schema

• A. Pulling named fields such as dates, terms, and party names into a fixed schema is exactly what structured information extraction (e.g. `ai_extract`) is designed for, and it maps directly onto a Delta table with fixed columns.
• B. Generation would produce free-form prose summaries, which do not give the fixed, queryable columns (start date, term, counterparty) the team needs for the Delta table.
• C. A chat interface answers ad hoc questions interactively but does not batch-produce structured field values across thousands of documents for a table load.
• D. Classification assigns each document to one of a set of predefined labels, which does not recover the specific field values the team needs to populate table columns.

Correct answer: A — Instruct the model to wrap the JSON output in specific delimiters such as triple backticks, then have the downstream code extract only the text between those delimiters

• A. Asking the model to enclose its output in a distinctive delimiter such as triple backticks gives the downstream code a reliable anchor to extract exactly the JSON substring, even if the model still adds a stray lead-in sentence outside the delimiters.
• B. Dropping the JSON instruction removes the format constraint altogether, making the response less structured and harder to parse, which is the opposite of what the pipeline needs.
• C. Having the model restate the instruction adds extra conversational text to the response and does not stop it from also adding a lead-in sentence before the JSON object.
• D. A one-word prompt removes the context the model needs to know what fields to extract and does not specifically address the lead-in text problem; it is likely to make the output less reliable, not more.

Correct answer: A — Constrain `issue_payment` so it only runs after `check_policy_coverage` approves the claim, and write tool descriptions that lead the agent to call lookup, then coverage check, then payment in that order.

• A. Constraining the payment tool to run only after coverage approval, and describing the tools so the agent naturally sequences lookup, then verification, then action, matches Databricks guidance that consequential actions in a multi-stage reasoning loop should be gated behind the verification step they depend on. This prevents the model from reaching an irreversible action tool before the required check has succeeded.
• B. Calling the payment tool before verifying coverage defeats the purpose of the coverage check, since the payment would already be issued by the time the audit-log calls run. This ordering allows an unapproved claim to be paid, which is exactly the failure mode the design must prevent.
• C. Identical generic tool descriptions remove the signal the agent needs to reason about which tool serves which purpose, and running the payment and coverage-check tools in parallel means the payment can complete before the coverage result is even known. This creates a race condition that can pay out non-covered claims.
• D. Removing the coverage-check tool eliminates the automated gate entirely, so every claim would be paid regardless of eligibility, with correctness pushed onto a reviewer who only sees the claim after money has already moved. This does not satisfy the requirement that payments never occur for claims failing verification.

Correct answer: A — Configure adjacent chunks to overlap by a set number of tokens so boundary content appears in more than one chunk.

• A. Adding overlap between adjacent chunks means content near a boundary is duplicated into both chunks, so an instruction that straddles the boundary will appear in full inside at least one chunk and can be retrieved intact.
• B. Returning more candidate chunks increases the chance both neighboring chunks are retrieved together, but neither chunk individually contains the complete instruction, so the response context is still fragmented across two partial chunks.
• C. A domain-tuned embedding model can improve semantic matching for retrieval, but it does not change where chunk boundaries fall, so the instruction would still be split across two chunks.
• D. Physical storage order in the vector index does not affect which chunks are returned for a similarity search, so this does not help the retriever surface the complete instruction.

Correct answer: A — Create the Delta Sync Index with `pipeline_type="TRIGGERED"` so the index only syncs when explicitly triggered or scheduled after each nightly write completes.

• A. A triggered pipeline type syncs the index on demand or on a schedule the team controls, which matches a workflow where new data lands once nightly and the index only needs to refresh after that batch is written.
• B. A continuous pipeline type keeps compute running at all times to sync near-instantly as changes occur, which is unnecessary and more costly for a workload that only produces new data once per night.
• C. A direct access index requires the application to manage embeddings and upserts itself via API calls rather than syncing from a Delta table, which abandons the Delta table-driven sync workflow the team already has in place.
• D. A Delta Sync Index does not fall back to a fixed hourly schedule when `pipeline_type` is unspecified; the pipeline type must be explicitly chosen to control whether syncing is triggered or continuous.

Correct answer: A — Run the scraped documents through classifiers to detect and filter out personal information and harmful language before ingestion

• A. Applying classifiers to detect personal information and harmful language during source preparation directly prevents sensitive or offensive content from entering the corpus at all. This matches the guidance that sensitive information and harmful language in source documents should be filtered using classifiers before ingestion.
• B. Relying on inference-time guardrails does not stop the retriever from surfacing the sensitive content as retrieved context, and the guardrail could still fail to catch every instance. The underlying risk originates in the source data, so filtering needs to happen during preparation rather than after retrieval.
• C. Splitting sensitive text across smaller chunks does not remove personal information or offensive language from the corpus; the content is still present and retrievable, just fragmented. Chunk size affects retrieval granularity, not content safety.
• D. Placing the forum posts in a separate table that is queried less often reduces but does not eliminate the chance that sensitive or harmful content is retrieved and surfaced to users. The unfiltered content remains available as a knowledge source.

Correct answer: A — Precision@k evaluated at a small k, such as precision@3, to confirm that nearly every top result is relevant

• A. Precision at a small k directly measures whether the handful of results an agent actually reads are relevant, which matches a scenario where exact top-of-list accuracy matters more than exhaustive coverage.
• B. Recall at a large k answers whether relevant articles exist anywhere in a broad candidate pool, which does not address whether the top one or two results the agent will actually read are correct.
• C. An average relevance score across the whole candidate set dilutes the signal from the top positions with lower-ranked results the agent will never see, so it does not isolate top-of-list accuracy.
• D. A relevance distribution describes how graded scores are spread across all retrieved results, which is a diagnostic overview rather than a targeted measure of whether the very top result is correct.

Correct answer: B — Configure the chunker to carry a window of trailing sentences into the start of the next chunk.

• A. Retrieving more chunks increases the chance that a second chunk with the missing fact is also returned, but it does not guarantee it, and it adds noise and cost to the prompt without directly fixing the boundary-splitting issue.
• B. Carrying a window of trailing sentences from one chunk into the next, known as chunk overlap, ensures continuity across the boundary so a fact split between two chunks is likely to appear intact in at least one of them.
• C. Switching to a fixed-character splitter changes where boundaries fall but does not add continuity across them, so facts can still be split between chunks just as before, only at different points in the text.
• D. Shrinking the chunk size increases the number of boundaries in the document, which makes it more likely, not less, that a given fact will end up split across two separate chunks.

Correct answer: A — Enable the reranker for the query types where it measurably improves DCG@10 within the latency budget, and skip it where the gain doesn't justify the cost

• A. Comparing DCG@10 with and without the reranker per query type is exactly how retrieval quality evaluation is meant to guide a rollout decision: enable reranking where it delivers a real, latency-affordable quality gain, and leave it off where the benefit doesn't clear that bar. This targeted approach makes the best use of the evaluation data collected.
• B. Applying the reranker uniformly ignores the finding that one query type saw almost no benefit; enabling it there still adds latency cost without a corresponding quality payoff. The evaluation data specifically shows the impact varies by query type, so a blanket decision discards that signal.
• C. One query type showing little improvement doesn't invalidate the significant DCG@10 gain observed for the other query type. Disabling the reranker everywhere would throw away a measured quality improvement that the evaluation clearly demonstrated for at least part of the traffic.
• D. DCG@10 is a ranking-order-sensitive metric that is well suited to measuring exactly what reranking changes: the order of results within the top-k. Recall@k measures whether relevant items appear at all in the candidate set, which doesn't capture the reordering benefit reranking provides.

Correct answer: A — Correctness, which compares the generated response against a labeled expected answer to score factual accuracy

• A. Correctness explicitly needs a labeled expected answer supplied as ground truth, against which it compares the generated response to score factual accuracy; without that label, the judge cannot run.
• B. Safety is a reference-free judge that assesses whether content is harmful, offensive, or toxic based on the response alone, so it does not require any labeled expected answer.
• C. RelevanceToQuery is reference-free and only needs the question and the response to judge whether the response addresses the query's intent.
• D. RetrievalGroundedness is reference-free and checks whether the response is supported by the retrieved context, not by a labeled ground-truth answer.

Correct answer: A — databricks-langchain

• A. This package provides the LangChain integrations, including a toolkit that wraps Unity Catalog functions so they can be passed directly into a LangChain agent's tool list.
• B. This package is a client for running Spark workloads against a remote Databricks cluster from a local environment; it has nothing to do with wrapping UC functions as LangChain tools.
• C. This package is a general-purpose REST API client for managing Databricks workspace resources such as clusters and jobs, not a LangChain tool integration library.
• D. This package is used for managing feature tables and feature lookups in the Feature Store, which is unrelated to exposing UC functions as LangChain tools.

Correct answer: A — To determine which specific context and data should be retrieved and injected into the prompt so the LLM's response is grounded in relevant, accurate information

• A. Extracting key fields, terms, and intents lets the application identify exactly what additional context (records, documents, or data) is relevant, so it can be retrieved and injected into the prompt to ground the LLM's response, which is the core purpose of this augmentation step.
• B. Storing raw messages in a vector database for fine-tuning is a separate model-training concern and is not the reason key fields and intents are extracted during prompt augmentation.
• C. There is no requirement that user input conform to a fixed grammar; natural language inputs are inherently varied, and extraction is about identifying meaning, not enforcing syntax rules.
• D. While shorter prompts can reduce cost, the purpose of extracting key fields and intents is to identify what context to retrieve, not primarily to minimize token usage.

Correct answer: A — Prepend a system/instruction prompt that defines the assistant's persona, tone, and the specific product scope it is allowed to discuss, ahead of the user's question.

• A. A system/instruction prompt that establishes persona, tone, and topic boundaries before the user turn is the standard mechanism for consistently shaping both style and scope across every interaction, since it applies as a stable constraint rather than a one-off hint.
• B. Appending a short phrase only nudges tone weakly and inconsistently, and it does nothing to constrain which product categories the assistant is allowed to discuss, leaving the scope problem unaddressed.
• C. Retraining or fine-tuning the base model is a heavyweight, costly approach reserved for cases where prompting cannot achieve the desired behavior; tone and scope framing here are directly solvable through prompt design without model retraining.
• D. Adding a second rewriting pass could adjust tone after the fact but doubles latency and cost, and it still does not prevent the first model from discussing out-of-scope products, so the underlying scope issue persists.

Correct answer: A — A large context window that can accept the entire contract in a single prompt, avoiding the need to split the document into chunks

• A large context window that can accept the entire contract in a single prompt, avoiding the need to split the document into chunks. Prioritizing a large context window is correct because the application's defining constraint is fitting long documents into one prompt, and an insufficient context window would force chunking and risk losing cross-section context in the contract.
• The highest reported benchmark score on coding tasks, since strong coding performance typically transfers to accurate long-document summarization. This is incorrect because coding benchmarks measure a different capability and do not indicate whether a model can accept or reason over very long input documents.
• The lowest cost per token, since summarization quality depends primarily on minimizing inference spend rather than input capacity. This is incorrect because a model with an inadequate context window is unusable for this task regardless of price, so input capacity is the binding constraint rather than cost.
• Fine-tuning for real-time voice transcription, since transcription-focused training improves comprehension of long written contracts. This is incorrect because voice transcription tuning targets audio-to-text conversion and has no bearing on a model's ability to process long written legal text.

Correct answer: B — Switch to the `databricks-bge-large-en` embedding model, since its 512-token context window comfortably covers every post while its smaller context window typically reduces per-request compute cost and latency.

• A. Batching posts into one request packs several separate posts into a single call, but each post still needs to be tracked and embedded as distinct text for retrieval; this does not address the underlying issue of paying for an oversized context window that the workload never needs.
• B. This is correct: since no post ever approaches even the smaller model's 512-token window, moving to this model still fully covers every post while typically lowering per-request compute cost and latency compared to a model provisioned for much longer text.
• C. Reducing refresh frequency changes how often the index is updated with new content, not how much compute each embedding call consumes, so the pipeline keeps paying for context capacity the short posts never use.
• D. This claim is factually incorrect: `databricks-bge-large-en` and `databricks-gte-large-en` both produce 1024-dimension embeddings, so the smaller model's benefit here comes from its smaller context window rather than any dimensionality difference.

Correct answer: B — Model Y, because it satisfies the latency requirement while offering benchmark quality close to Model X's score

• A. Treating benchmark score as the only decision factor ignores the application's stated latency requirement; a chatbot that cannot respond within the required time degrades the user experience regardless of its raw accuracy score.
• B. Selecting the model that meets the latency requirement while remaining close in benchmark quality is correct because model selection should weigh application attributes like response-time constraints alongside evaluation metrics, not optimize for a single metric in isolation.
• C. A larger parameter count does not guarantee better real-world accuracy; benchmark scores already capture measured quality, and here the smaller model's score is only slightly lower while its latency profile fits the use case.
• D. Fine-tuning a smaller model specifically to match a larger model's parameter count and architecture is not a real or necessary step, since parameter count is an inherent architectural property rather than something fine-tuning changes, and doing so would defeat the latency advantage.

Correct answer: B — Select Model Y, because task-specific evaluation results from the company's own labeled dataset are more representative of production performance than general-purpose benchmark scores

• A. General-purpose leaderboard scores measure performance on broad, generic tasks and don't account for the specific distribution of the company's support tickets, so they aren't inherently more reliable than a task-specific evaluation.
• B. Correct. An evaluation run on data that reflects the actual application, such as the company's own labeled ticket dataset, more accurately predicts production performance for that task than a general-purpose leaderboard score.
• C. Model card metadata provides general reference information, but it doesn't override task-specific experiment results when the two disagree; the internal evaluation is more directly relevant to this application.
• D. Parameter count alone doesn't determine how well a model generalizes to a specific classification task, and this option ignores the actual evaluation metrics that were generated for the two candidates.

Correct answer: A — Install `databricks-langchain` and instantiate `VectorSearchRetrieverTool` with the `index_name` and `tool_description` parameters.

• A. This is correct because this class from the Databricks AI Bridge package is purpose-built to wrap a Databricks-managed vector index as a ready-to-use LangChain tool with minimal setup for local prototyping.
• B. This is incorrect because an embeddings class produces vector representations of text; it is not itself a retriever tool and cannot be passed to an agent as a callable tool.
• C. This is incorrect because standing up a managed MCP server is the recommended path for production-grade, governed access, but it adds infrastructure overhead unnecessary for quick local prototyping against an already Databricks-managed index.
• D. This is incorrect because the Unity Catalog connection pattern is intended for indexes or vector stores hosted outside Databricks, not for an index that already uses Databricks-managed embeddings and hosting.

Correct answer: A — Poll `GET .../messages/{message_id}` until the status is conclusive (such as completed), then call `GET .../messages/{message_id}/query-result/{attachment_id}` to fetch the rows.

• A. This is correct because message processing is asynchronous: the agent must poll the message endpoint until a conclusive status is reached before the generated SQL's results become retrievable via the query-result endpoint keyed by attachment ID.
• B. This is incorrect because SQL generation and execution take time and are not guaranteed to finish synchronously; fetching the query result before processing completes will not reliably return the finished rows.
• C. This is incorrect because deleting a conversation removes it rather than finalizing it, and starting a brand-new conversation discards the in-progress question instead of retrieving its results.
• D. This is incorrect because repeatedly calling start-conversation creates a new conversation thread each time rather than checking the status of the message that was already submitted.

Correct answer: A — Filter the runs to those meeting the minimum quality score, then among the remaining runs choose the one with the lowest combined latency and cost.

• A. Filtering out runs that fail the quality threshold before comparing latency and cost across the remaining candidates directly uses all three logged metrics to satisfy the quality bar, latency target, and cost goal together.
• B. Ignoring the logged latency and cost metrics risks selecting a model that violates the sub-second response requirement or exceeds the cost target, even though it scored well on quality.
• C. Choosing purely on cost and deferring quality verification to after deployment abandons the experiment metrics that were already collected and risks shipping a model that fails the minimum quality bar.
• D. Optimizing only for latency ignores the logged quality and cost metrics, so the selected model could fail the minimum quality bar or exceed the target cost despite meeting the latency goal.

Correct answer: A — Chain the components with the pipe operator: `prompt | llm | output_parser`, composing them into one Runnable in sequence.

• A. Correct: the pipe operator is LangChain Expression Language's standard syntax for composing Runnables, so linking the prompt template, chat model, and output parser this way builds a single sequential chain.
• B. Incorrect: `LLMChain` is the legacy chain class and is not constructed by passing a prompt, chat model, and parser as three positional arguments in this way.
• C. Incorrect: `SequentialChain` composes multiple named sub-chains with declared input/output keys for multi-step workflows, it is not how a single prompt-LLM-parser pipeline built from these three objects is expressed.
• D. Incorrect: `RunnableSequence` is not instantiated with a `steps` keyword this way; the pipe operator is the documented syntax that builds a `RunnableSequence` under the hood.

Correct answer: A — Enable on-behalf-of-user authentication, build the client with `ModelServingUserCredentials` inside `predict`, and declare `api_scopes` in an `AuthPolicy` at logging time.

• A. On-behalf-of-user authentication is the feature designed for this scenario: initializing `ModelServingUserCredentials` inside the prediction function (since user identity is only known at request time) and declaring the needed API scopes lets each request enforce that specific user's own Unity Catalog permissions.
• B. Automatic authentication passthrough with a declared resource grants the same service-principal-level access to every caller of the endpoint, so it cannot differentiate row- or column-level permissions between individual end users.
• C. Referencing a single service principal's token means every request authenticates as that one identity, which enforces uniform access rather than each end user's individual row- and column-level entitlements.
• D. Granting a broad metastore admin role bypasses access checks entirely rather than applying each user's own permissions, which is the opposite of enforcing per-user row- and column-level governance.

Correct answer: A — Set `query_type="HYBRID"` and pass `filters={"category": "electronics"}` in the `similarity_search` call.

• A. HYBRID query type combines vector similarity with keyword matching, and the `filters` argument restricts results to matching metadata, together satisfying both requirements.
• B. ANN performs pure approximate nearest-neighbor vector search only; it does not blend in keyword scoring, so it would not improve recall for exact product-name matches.
• C. The `columns` parameter only controls which fields are returned in the results; it does not restrict which documents are searched, so category filtering would not actually apply.
• D. A full-text query type performs keyword-based search and does not automatically blend in semantic vector scoring, so it would not provide the combined similarity behavior needed.

Correct answer: A — Pass `modelParameters => named_struct('max_tokens', 100, 'temperature', 0.2)` to cap the generation length and reduce output variability.

• A. Correct: `modelParameters` carries chat/completion controls like `max_tokens` and `temperature` straight through to the foundation model endpoint, so capping `max_tokens` bounds summary length and lowering `temperature` reduces run-to-run variability.
• B. `returnType` describes the expected schema of a custom endpoint's response for parsing purposes; it is not a truncation mechanism and has no effect on how much text a foundation chat model generates.
• C. The endpoint argument is a plain string identifying which serving endpoint to call; wrapping it in a struct does not change generation length and would break the call rather than configure output size.
• D. `files` is used to attach image content for multimodal requests; it is unrelated to text summarization and does not influence response length or determinism for a text-only prompt.

Correct answer: C — DCG@10

• A. Recall@10 measures the fraction of all relevant documents that were retrieved in the top 10 results, but it does not weight results by degree of relevance or by their position within that top 10. It is not the metric Databricks highlights as primary for this reason.
• B. Precision@10 measures the fraction of the top 10 retrieved results that are relevant, treating all relevance levels and positions within the top 10 equally. It does not capture the graded, position-weighted signal that the recommended metric provides.
• C. Discounted Cumulative Gain at 10 sums graded relevance scores while discounting results that appear lower in the ranking, so highly relevant documents near the top contribute more than marginally relevant ones further down. This combination of graded relevance and rank-position weighting is why Databricks recommends it as the primary retrieval quality metric.
• D. Mean Reciprocal Rank only considers the position of the first relevant result and ignores the graded relevance or ranking of any other results in the list. It does not account for multiple relevant documents at varying relevance levels the way the recommended metric does.

Correct answer: A — Set the `target_qps` parameter on the index to reserve additional serving capacity, accepting that the endpoint is billed for that reserved capacity even during idle periods.

• A. Setting `target_qps` reserves dedicated serving capacity to meet the requested query throughput, and that reserved capacity is billed regardless of actual traffic, which matches a business that has approved extra spend for a latency guarantee.
• B. Scale-to-zero shuts down capacity during idle periods, which introduces a warm-up delay of a couple of minutes when traffic resumes, directly undermining a requirement for guaranteed low latency at high volume.
• C. Sync mode governs how the index ingests updates from the source table, not how query traffic is served, so changing it has no effect on query latency or throughput guarantees.
• D. Without `target_qps` set, scaling is best-effort and not guaranteed, so the endpoint may not reserve enough capacity to hold latency steady under sustained high query volume.

Correct answer: D — A fully managed, serverless Postgres OLTP database that agents use as a durable memory store.

• A. A Unity Catalog securable memory store with scoped, path-organized entries describes managed agent memory, which is a separate, Databricks-governed approach rather than what Lakebase itself is.
• B. Storing and retrieving embeddings for similarity search describes a vector search index, not Lakebase, which is a relational Postgres database rather than an embedding index.
• C. Lakebase is an operational Postgres database for transactional workloads, not a scheduling service, and it has no role in triggering Delta Lake table maintenance jobs.
• D. Lakebase is Databricks' fully managed, serverless Postgres OLTP database, and self-managed agent memory uses it as a durable store for short-term and long-term agent state such as checkpoints and conversation history.

Correct answer: A — Connect the agent to the managed Unity Catalog Functions MCP server at `/api/2.0/mcp/functions/{catalog}/{schema}`, letting Unity Catalog permissions govern access.

• A. This is correct: Databricks hosts a managed Unity Catalog Functions MCP server that exposes registered SQL/Python functions as predefined tools at a workspace endpoint, with Unity Catalog enforcing which principals can call which function, so no additional hosting is required.
• B. Building a custom MCP server on Databricks Apps is unnecessary extra work here since the functions are already governed Unity Catalog objects that the managed Unity Catalog Functions server can expose directly without any app code or deployment.
• C. External MCP registration through Unity Catalog connections is meant for servers hosted outside Databricks; functions that already live in a Unity Catalog schema inside the workspace are served by the managed server, not treated as an external third-party connection.
• D. Calling the SQL warehouse REST API directly bypasses the MCP tool-calling contract the agent framework expects and substitutes a workspace token for Unity Catalog's fine-grained function-level grants, weakening governance rather than preserving it.

Correct answer: A — A custom guardrail with a user-defined prompt sent to an evaluator endpoint, configured to block requests matching the organization-specific policy.

• A. Custom guardrails accept a user-defined prompt, up to 5000 characters, evaluated against a compatible endpoint, which lets a team codify an organization-specific policy like blocking mentions of internal codenames that no built-in template covers.
• B. The unsafe content category is fixed to detect things like hate speech, violence, and self-harm; it has no mechanism to be retuned toward an unrelated, organization-specific list of confidential codenames.
• C. Jailbreak protection is fixed to detect instruction overrides, obfuscated payloads, and role-play exploits, not arbitrary organization-specific terms, so it cannot be repurposed to flag product codenames.
• D. Hallucination detection is fixed to catch fabricated facts and invented citations in model output; a real but confidential codename mentioned in a request is not a fabrication, so this guardrail would not apply.

Correct answer: A — Attach a row filter function that excludes rows where the region does not match the querying user's team, leaving every column value unmasked.

• A. A row filter is designed to exclude entire rows based on a condition like matching region to team, which restricts which claims an analyst can see while leaving the claim amount column itself fully visible in the rows that remain.
• B. Masking the region column would hide which region a visible row belongs to rather than restrict which rows are returned, so analysts would still see every row's claim amount regardless of region, failing the row-level requirement.
• C. Masking the claim_amount column directly contradicts the requirement that claim amounts remain fully visible to every analyst, and it does nothing to restrict rows by region.
• D. Filtering rows by claim amount threshold restricts access based on the wrong attribute, since the requirement is to restrict rows by region, not by the size of the claim amount.

Correct answer: A — Confirm that the existing vendor license agreement permits internal retrieval-augmented use of the manuals, then restrict retrieval access to the employees covered by that license using Unity Catalog permissions

• A. Existing vendor licenses often specify permitted uses and user populations, so the compliant approach is to confirm the license actually covers retrieval-augmented use and then technically enforce that scope with Unity Catalog access controls. This ties the legal permission to an enforceable technical boundary.
• B. Staying within company infrastructure does not exempt copyrighted material from the terms of the license under which it was obtained; internal use can still exceed what the vendor agreement authorizes. The license scope, not the deployment boundary, determines what is permitted.
• C. Attribution can be one license requirement among several, but it does not by itself satisfy broader copyright terms such as limits on redistribution, number of users, or permitted use cases. Crediting the vendor is not a substitute for confirming the license actually allows this use.
• D. PII redaction addresses privacy concerns about individuals' personal data, which is unrelated to whether the company holds sufficient copyright permission to reuse the vendor's manuals. Removing PII has no effect on the underlying license status of the copyrighted text.

Correct answer: A — Run the scraped posts through a toxicity/profanity classifier during data preparation and remove or quarantine flagged passages before they are indexed

• A. Filtering or quarantining problematic passages during data preparation stops offensive content from ever entering the index, which is the most reliable way to prevent it from being retrieved and surfaced in responses.
• B. Temperature controls the randomness of token sampling during generation; it does not screen or remove offensive content from the underlying source documents, so the problematic text remains retrievable.
• C. A system prompt instruction depends on the model reliably recognizing and reacting to offensive retrieved content every time, which is an unreliable inference-time patch rather than a fix to the source data itself.
• D. Retrieving more chunks does not remove the offensive passages from the corpus; it can actually increase the odds that at least one problematic passage is included in the context window.

Correct answer: A — Model A should be selected, because Model B's 4.5-second response time violates the 2-second latency requirement despite its marginally higher correctness score

• A. This is correct: the application defines a hard latency requirement under 2 seconds, and Model B's measured 4.5-second average response time fails that requirement, so Model A is the only candidate that satisfies both the accuracy bar and the latency constraint.
• B. This is incorrect because model selection must weigh all relevant quantitative requirements together; a correctness edge does not override a hard latency service-level requirement that the application has defined.
• C. This is incorrect because there is no such blanket statistical rule; the scenario asks for a decision based on the stated latency requirement, not on discounting the accuracy gap outright.
• D. This is incorrect because evaluation-time latency measurements are a standard and relevant proxy for expected production latency, and dismissing them contradicts the purpose of measuring latency during evaluation.

Correct answer: A — A budget scoped to the cost-center tags with a defined threshold and usage blocking enabled for the AI Gateway endpoint.

• A. Databricks budgets can be scoped to custom tags such as cost-center identifiers, tracking spend against a defined monthly threshold and sending near real-time alerts for Unity AI Gateway usage, with an optional usage-blocking setting that halts further requests once the threshold is reached, matching both the alerting and blocking requirements.
• B. A tokens-per-minute rate limit caps request throughput rather than tracking dollar spend against a threshold, and applying one limit uniformly across all cost centers would not distinguish which specific cost center crossed $2,000, so it does not satisfy the tag-based spend alerting requirement.
• C. An inference table logs request and response payloads for auditing, evaluation, and monitoring quality, but it has no built-in mechanism to compute dollar spend per tag, trigger a threshold alert, or block further calls.
• D. An access control list can permit or deny which principals may query an endpoint, but it does not track cumulative spend or generate a threshold-crossing alert; it would only enforce an all-or-nothing access decision, not a cost-based one.

Correct answer: A — Return a `Feedback` object carrying a numeric `value` plus a `rationale` string explaining why that score was assigned

• A. A `Feedback` object is built for exactly this case: it pairs a `value` (the score) with a `rationale` (the explanation), giving stakeholders both the number and the reasoning behind it in a structured way attached to the trace.
• B. A plain `float` is a valid scorer return type, but it carries only the number with no place to attach an explanation, so it cannot satisfy the requirement for a visible written rationale.
• C. A list return is meant for reporting several distinct named metrics from one scorer, not for pairing a single score with an explanation; it does not provide a structured rationale field either.
• D. A `str` can hold text, but jamming a score and reasoning into one unstructured sentence loses the distinct, queryable `value` and `rationale` fields that a `Feedback` object provides.