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 — 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 — Parse the HTML with a library that isolates the main article content and strips navigation, ad, and boilerplate elements before extracting text.

• A. Correct. Parsing the HTML with a library that isolates the main article content and strips navigation, ad, and boilerplate elements before extracting text removes the extraneous content before chunking and embedding. This prevents noisy text from ever entering the vector index and degrading RAG retrieval.
• B. Incorrect. Relying on the LLM to ignore irrelevant navigation-menu, cookie-consent, and sidebar-ad sections at answer time does not fix the underlying data quality problem and still consumes context window and retrieval capacity with noisy content. The extraneous text remains embedded and can continue to reduce retrieval precision.
• C. Incorrect. Splitting into very small fixed-size chunks based on token count ignores HTML structure, so navigation and ad text can still land inside the same chunks as article body text. Only removing chunks that contain solely boilerplate does not address mixed chunks that still contain ads or menu links.
• D. Incorrect. Re-ranking retrieved chunks with a cross-encoder only changes the order of chunks already retrieved; it does not remove navigation and ad chunks from the index. Noisy chunks can still surface for some queries and continue to degrade RAG output.

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 — 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 — 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 — Explicitly instruct the model to respond only with a JSON object matching a given schema, such as `{"product_name": string, "price": number}`, and include an example of correctly formatted output.

• A. Correct. Explicitly requiring only a JSON object that matches a defined schema — including field names like `product_name` and `price` with their types — removes ambiguity about the expected structure. Including an example of correctly formatted output further steers the model toward machine-readable JSON that downstream parsers can consume reliably.
• B. Incorrect. Asking the model to 'try to format the answer nicely' is vague and does not impose a strict, predictable schema or syntax. Even if the model places `blender` and `$39.99` on separate lines, minor variations in wording, labels, or spacing can still break a downstream parser that expects consistent machine-readable output.
• C. Incorrect. Using visible delimiters such as underscores is not a standard machine-readable format and does not guarantee consistent key-value structure. A parser that scans for `__blender__` and `__$39.99__` may still fail if the model adds extra text, changes the markers, or varies the field order.
• D. Incorrect. Shortness alone does not create structured output. A compact token string like `blender 39.99` is still unstructured prose that lacks labeled fields or a reliable syntax, making it difficult for a downstream function to extract the product name and price without error.

Correct answer: A — Detect the entities "blue XL hoodie" and "usual store" in the message, resolve "usual store" against the user's stored default store ID, and add the resolved store ID and current inventory data for the SKU into the prompt context.

• A. Correct. Identifying the key entities in the current message and resolving ambiguous references like "usual store" against the user's stored default store ID gives the model concrete, user-specific context. Adding the resolved store ID and the relevant current SKU inventory data lets the LLM answer accurately instead of reasoning from vague or inferred facts.
• B. Incorrect. Forwarding the message unchanged and instructing the LLM to guess a store from generic training-data naming patterns ignores the exact default store ID the application already has. This produces an unreliable location and can make the inventory lookup irrelevant or incorrect.
• C. Incorrect. Generating a nationwide list of stores and asking the user to manually pick one defeats the purpose of automatic prompt augmentation, since the user's usual store is already stored in the profile. It adds unnecessary friction and may rely on a model-generated store list rather than the known default store ID.
• D. Incorrect. Dumping the entire multi-year purchase history without identifying which specific terms in the current message need resolution adds noisy, unfocused context. The LLM may infer an incorrect store or product when the application could instead resolve the "usual store" and "blue XL hoodie" directly against known user data.

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: 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 — Pass a representative `input_example` such as a `messages` list with a sample user turn to `log_model`, letting MLflow infer the signature from that example and the chain's output.

• A. Correct. Providing a representative `input_example` such as a `messages` list with a sample user turn lets MLflow execute the chain and infer the signature from the observed input and output shapes. This is the recommended way to obtain a valid OpenAI-style chat signature without hand-writing the model signature, satisfying AI Playground and review app requirements.
• B. Incorrect. Unity Catalog does not automatically assign a default chat signature when a model is logged without `input_example` and signature, and the endpoint cannot reliably infer the `messages` schema on its own. The model version remains effectively unsigned, so AI Playground and the review app lack the schema they require.
• C. Incorrect. Having `predict` return a hard-coded JSON schema string and logging that string as a model tag only stores metadata; it does not create an MLflow model signature. Because it is not validated against the model's actual inputs and outputs, it does not satisfy the signature requirement for AI Playground or the review app.
• D. Incorrect. MLflow autologging does not cover LangChain retrievers, so enabling autologging for the retriever will not capture an OpenAI-style chat signature from the retriever's `messages` input. Even retriever execution were logged, that does not apply a chat signature to the RAG agent endpoint.

Correct answer: A — Block the request or response outright, or sanitize it by rewriting the flagged content in place.

• A. Built-in guardrails support two enforcement actions: blocking, which rejects the request or response outright with an error, and sanitizing, which dynamically rewrites the flagged text in place without terminating the request.
• B. Retrying with a truncated context and escalating to a human queue are not actions that a Unity AI Gateway guardrail applies to flagged content; guardrails enforce policy directly rather than routing to manual review.
• C. Forwarding violations to an external SIEM tool and automatically downgrading the model are not guardrail enforcement actions; guardrails act on the content itself through blocking or sanitizing, not infrastructure changes.
• D. Caching flagged content and throttling rate limits are unrelated to how a guardrail responds to a detected violation; enforcement is limited to blocking the content or sanitizing it, not session-level rate control.

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 — Replace the scraped blog corpus with first-party content or a dataset under a license that explicitly permits this use

• A. Swapping in first-party content or a dataset with a license that clearly permits the intended use removes the legal risk at its source, since the corpus no longer relies on ambiguous reuse terms.
• B. Citing the source URL may be good practice for attribution, but it does not resolve the underlying licensing uncertainty about whether the company is permitted to reuse and redistribute the scraped content.
• C. Shortening the chunk size changes how much text is retrieved per query, but the content still originates from a corpus with unresolved reuse rights, so the licensing risk remains unchanged.
• D. A fair-use disclaimer in the prompt is not a legal determination and does not change the actual licensing status of the scraped content, so the underlying risk to the company persists.

Correct answer: A — Remove the web-scraped content with unclear licensing from the training set and replace it with data under a confirmed commercially permissive license before shipping.

• A. Correct. Removing the web-scraped content with unclear licensing from the training set and replacing it with data under a confirmed commercially permissive license directly eliminates the legal exposure before the feature ships to external customers. This addresses the root cause instead of working around it.
• B. Incorrect. Adding a disclaimer and listing the web-scraped sources in launch notes only discloses the risk; it does not remove the underlying legal exposure from using data with unverified rights in a launched product. Documentation alone cannot cure a licensing gap.
• C. Incorrect. Differential privacy noise may limit attribution of individual web-scraped contributions, but it does not establish copyright or licensing permissions for the underlying content. Documenting it as satisfying legal review therefore mischaracterizes the legal risk.
• D. Incorrect. Encrypting embedding vectors at rest with a production key-management service protects confidentiality, but it has no effect on whether the organization has the legal right to use the web-scraped data. Encryption does not satisfy licensing requirements.

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.

Correct answer: A — Attach custom key-value pairs to each request through the Databricks-Ai-Gateway-Request-Tags header, then group results by the request_tags column in the usage tracking system table.

• A. Correct. Request tags sent in the `Databricks-Ai-Gateway-Request-Tags` header label each individual request with custom key-value pairs, such as a business unit name. Those tags are recorded in the `request_tags` column of the usage tracking system table, so the team can group usage and cost by business unit without changing which model or endpoint each unit calls.
• B. Incorrect. The `status_code` column only records the HTTP outcome of a request, so filtering on it selects successful calls but does not attribute them to anyone. A department value is not something the gateway records or returns on its own, so grouping by it would not give a reliable per-business-unit breakdown.
• C. Incorrect. A rate limit's configured QPM value is a throughput ceiling, not a measurement of what a group actually consumed. Reading it off a billing dashboard would show the configured limit rather than real usage or spend, so it cannot attribute cost to each business unit.
• D. Incorrect. Unity Catalog lineage shows how tables, notebooks, and models relate to one another, not which caller or business unit sent a given inference request. It therefore cannot provide per-business-unit cost attribution for requests on a shared endpoint.