Free Databricks Certified Context Engineer Associate Sample Questions

Correct answer: A — Context confusion

• A. Correct. Irrelevant content (the unrelated product chunks) was present in the context and ended up being used to generate the response instead of the relevant passage — this is context confusion, where superfluous content degrades output quality.
• B. Incorrect. Context poisoning requires a hallucinated or erroneous fact to be introduced and then repeatedly relied on; here the unrelated chunks are real content, just irrelevant to the question.
• C. Incorrect. Context distraction is about over-weighting a large volume of prior actions/history, not about a small number of irrelevant retrieved documents being misused.
• D. Incorrect. Context clash requires two contradictory statements both present in context; the unrelated chunks do not contradict the warranty passage, they are simply off-topic.

Correct answer: A — MLflow 3 for GenAI

• A. Correct. MLflow 3 for GenAI is the current, unified framework for tracing, evaluation, and monitoring of GenAI applications, and Databricks documents migration paths from legacy Agent Evaluation to it.
• B. Incorrect. Lakebase is a transactional Postgres database for application and agent state, not an evaluation or tracing framework.
• C. Incorrect. Unity Catalog is a governance and data catalog layer; it does not provide tracing, evaluation, or monitoring for agent behavior.
• D. Incorrect. MCP connects agents to tools and resources; it has no built-in evaluation or tracing capability of its own.

Correct answer: A — Apply tool result clearing to discard the superseded raw output while keeping the turn's outcome in history

• A. Correct. Once a tool result deep in history is no longer needed verbatim, clearing that raw output is one of the lightest-touch and safest forms of compaction, freeing attention budget while preserving the decision or outcome that mattered.
• B. Incorrect. A higher reasoning effort spends more compute per response but does not remove the stale tokens still occupying context, so the underlying dilution remains.
• C. Incorrect. Re-running the tool call adds another large, mostly redundant listing to history, increasing token consumption rather than reducing it.
• D. Incorrect. An added instruction competes for attention just like any other token and does not actually remove the large stale listing from context, so the disproportionate consumption remains.

Correct answer: A — Introduce context compaction that summarizes older turns and superseded tool results before the context window becomes full.

• A. Correct. Repeated redundant tool calls and contradictory answers indicate that the model's reasoning is being degraded by an overlong context. Context compaction summarizes older turns and superseded tool results, preserving essential facts while removing noise, which restores reliable behavior for long sessions.
• B. Incorrect. Increasing the maximum token limit for model responses only makes each response longer; it does not resolve the underlying problem of an overly long context collapsing reasoning. In fact, longer responses add more tokens to the conversation history, which can further dilute the model's ability to recall earlier facts and increase the chance of contradictions.
• C. Incorrect. Switching to a higher-latency reasoning endpoint provides more compute time per turn but does not mitigate the real issue: the agent's context has become overloaded with accumulated history. The repeated tool calls and contradictions stem from a diluted context, not insufficient processing time, so this intervention would not restore reliable behavior.
• D. Incorrect. Adding more few-shot examples to the system prompt directly increases the token count in an already strained context, which is likely to exacerbate the degradation. This intervention does not remove accumulated noise and may even intensify contradictions and redundant calls by further diluting the model's attention.

Correct answer: C — CAN EDIT

Correct answer: A — Include the fourth example and drop one of the redundant single-table filter examples

Correct answer: A — Enable example values or a value dictionary so the agent maps spoken country names to stored codes

• A. Correct. This is exactly the value-matching failure mode that example values and value dictionaries are designed to solve: the agent learns the mapping once, with no added per-query tokens and no ongoing instruction upkeep.
• B. Incorrect. Spelling out every mapping in a general instruction bloats the prompt with data that belongs in metadata, adds tokens to every request, and must be manually updated whenever new countries appear.
• C. Incorrect. Pushing the mapping burden onto users breaks the natural-language interface and does not fix the agent's behavior for anyone who phrases the question naturally.
• D. Incorrect. Changing the underlying table schema is a data engineering change outside prompt revision scope and may break other systems that depend on the coded values.
• E. Incorrect. Enumerating every code in separate example queries is far higher maintenance than a single value dictionary and does not scale as new codes are added.

Correct answer: A — Config B is justified: the few-shot examples drive a large accuracy gain in a safety-critical domain where the added latency is quite acceptable.

• A. Correct. The few-shot examples in Config B lead to a substantial 12-point accuracy increase, which is critical for safety in medical-device troubleshooting. The added latency (from 1.2s to 2.1s) is modest and acceptable given the high stakes, so the tradeoff strongly favors Config B.
• B. Incorrect. The scenario does not state any pre-defined safety threshold for accuracy, and a hard 1-second latency limit is an arbitrary constraint not supported by the domain. In safety-critical contexts, the priority is typically on reducing wrong diagnoses, not an absolute latency ceiling.
• C. Incorrect. A higher token count alone does not inherently improve output quality; it is the specific few-shot examples that likely drive the accuracy gain. Selecting Config B simply because it is longer ignores the fact that prompt content, not length, determines effectiveness.
• D. Incorrect. Config A’s 82% accuracy suggests it does not adequately cover the edge cases captured by the few-shot examples in Config B. The lower accuracy implies that the plain instructions miss important failure patterns that the examples help diagnose correctly.
• E. Incorrect. MLflow experiment tracking can compare prompts of different token lengths without bias, as metrics like accuracy and latency are measured based on model outputs, not prompt sizes. The token count difference does not invalidate the comparison; it is a legitimate variable in the experiment.

Correct answer: A — Add column descriptions noting `created_at` is signup time, `updated_at` is last-modified time.

• A. Correct. The ambiguity is purely semantic: two similarly named timestamp columns with no documentation of what each represents. Column descriptions give Genie the business meaning it needs to pick the right column for "signed up".
• B. Incorrect. Sample date values do not clarify which column represents signup versus modification; the values in both columns look the same (dates), so a value dictionary does not resolve the ambiguity.
• C. Incorrect. Enumerating every possible phrasing does not scale and does not address the root cause, which is that the columns themselves are undocumented.
• D. Incorrect. Renaming columns is a schema change outside typical metadata configuration and is unnecessary when a column description can resolve the ambiguity without touching the underlying table.
• E. Incorrect. `created_at` and `updated_at` are two attributes of the same row, not two separate tables needing a join relationship; cardinality configuration is not applicable here.

Correct answer: A — Approximately 10%

• A. Correct. A common starting point for chunk overlap when tuning a chunking strategy is around 10%, which is then adjusted iteratively based on document structure and evaluation results.
• B. Incorrect. 50% overlap is far higher than the typical starting baseline and would substantially increase index size and redundancy for most corpora.
• C. Incorrect. 90% overlap is an extreme value that would make most adjacent chunks nearly identical, wasting index space without a corresponding baseline recommendation.
• D. Incorrect. Some overlap is generally recommended as a starting point to avoid losing context at chunk boundaries; a 0% baseline is not the typical recommendation.

Correct answer: A — Pre-inference retrieval using an AI Search embedding index built from the Delta table holding the manual content

• A. Correct. The corpus is large, unstructured, and changes infrequently, so pre-computing embeddings once and querying the resulting AI Search index at inference time gives fast semantic matches without repeating expensive indexing work per query.
• B. Incorrect. Issuing a fresh SQL query per request suits structured, frequently changing data, not semantic search over free-form text; it also cannot perform similarity matching the way an embedding index can.
• C. Incorrect. Recomputing embeddings for the entire corpus on every inference call wastes compute and adds latency that a static quarterly-updated index avoids entirely.
• D. Incorrect. Genie spaces are designed for structured tabular question answering via generated SQL, not semantic retrieval over long-form unstructured manual text.

Correct answer: A — Add a department metadata column to the source Delta table and apply it as a filter in the AI Search query API for every retrieval call

• A. Correct. Since AI Search lacks native row/column-level security, the documented application-level pattern is to tag rows with a security metadata column and enforce it via the query-time filter API on every call.
• B. Incorrect. Unity Catalog ACLs on the index govern who can manage or query the index object as a whole; they do not filter individual rows by a department value.
• C. Incorrect. Random selection provides no reliable access boundary and could just as easily return the wrong department's data.
• D. Incorrect. Embeddings capture semantic similarity, not access policy; they cannot reliably or deterministically exclude a department's records.
• E. Incorrect. Broad CAN MANAGE grants increase exposure rather than restrict it, and endpoint-level permissions do not implement row-level filtering.

Correct answer: E — A grant controls whether a principal can access a table at all, while a row filter restricts which specific rows a principal sees within a table they can already access.

• A. Incorrect. Unity Catalog grants are not scoped only to Genie spaces; they control access to any securable object (e.g., tables, views) across Databricks. Row filters operate at query time on tables, not exclusively during AI Search indexing, and they limit visible rows regardless of the access interface.
• B. Incorrect. Grants do not filter columns—that is the role of column masks. Row filters are enforced at query time on the active data, not merely at indexing time; they dynamically restrict rows for each query, rather than being baked into indexes.
• C. Incorrect. While grants are enforced at query time, row filters are also enforced dynamically at query time and are not limited to table creation. Row filters apply to the live Delta table content and are not permanently baked into the data, so this option misrepresents their enforcement.
• D. Incorrect. Grants and row filters are distinct mechanisms: grants control object-level access, while row filters restrict row-level visibility. They do not both target columns, and they address retrieval failures differently—row filters do not act as column masks.
• E. Correct. A Unity Catalog grant (e.g., SELECT) decides whether a principal can access a table at all, acting as a coarse permission. A row filter applies after table access is granted, narrowing the result set to only those rows the principal is allowed to see, thus providing fine-grained control.

Correct answer: A — Add Databricks reranker to reorder retrieved chunks, moving the correct one up, before prompting LLM.

• A. Correct. The Databricks reranker re-scores the top retrieved chunks based on relevance, specifically moving the correct passage from a lower rank (6th-10th) to the top, directly addressing the ranking issue. This operation adds only a few hundred milliseconds of latency, fitting well within the 250ms-1s budget.
• B. Incorrect. Switching to Direct Vector Access ensures the index reflects the latest data but does not alter the ranking of already retrieved chunks. The problem is not stale data but low relevance ranking among top results, so this change would not directly fix the issue.
• C. Incorrect. Increasing chunk overlap may preserve more context but can also introduce noise and does not reorder the retrieved chunks to prioritize the most relevant one. It is an indirect and less targeted approach compared to reranking.
• D. Incorrect. Fine-tuning an embedding model is a lengthy process that might improve future retrieval quality, but it does not immediately re-rank the current top-10 chunks to surface the correct one. It also cannot guarantee that the correct chunk will move above similar but less relevant neighbors within the allowed latency.

Correct answer: A — The retriever tool's output chunks are appended to the conversation as a message, allowing the LLM to ground its next response on them.

• A. Correct. When the retriever tool executes, its output (the retrieved chunks) is appended to the conversation as a message, effectively adding the retrieved information to the agent's context. The LLM can then ground its next response on this newly available context along with the existing conversation history.
• B. Incorrect. The system prompt defines the agent's overall instructions and behavior and is not replaced by retrieved chunks. Instead, the chunks are added as supplementary context, augmenting rather than substituting the prompt.
• C. Incorrect. Writing chunks back to the source Delta table does not make them available to the LLM for the current request and would only duplicate data already indexed. The LLM obtains context directly from the retriever's output, not by re-querying the table.
• D. Incorrect. Unity Catalog function definitions describe a tool's interface and implementation, not a mechanism for passing per-query retrieval results. Retrieved content flows through the agent's context window, not by being injected into function definitions.

Correct answer: B — Persist step progress to a Lakebase-backed state table and reload it on restart

• A. Incorrect: an in-context scratchpad is lost whenever the process restarts or the session ends, so it cannot survive a multi-day job with compute restarts.
• B. Correct: a Delta-backed state store like Lakebase persists across restarts and sessions, letting the agent read back exactly where it stopped and resume reliably.
• C. Incorrect: resummarizing conversation history does not recover durable checkpoint data and still depends on context that may already be gone after a restart.
• D. Incorrect: an in-process variable is held in memory and is wiped out the moment the process restarts, offering no durability.

Correct answer: A — Databricks AI Search vector similarity search over embedded memory entries

• A. Correct. Finding conceptually related content that shares no exact keywords requires comparing embeddings for semantic closeness, which is exactly what Databricks AI Search's vector similarity search provides.
• B. Incorrect. An exact-match category filter only returns rows that share the same discrete label; it cannot surface conceptually related memories that fall outside that category or use different wording.
• C. Incorrect. Sorting by recency retrieves memories based on time, not on conceptual relevance to the new ticket's content.
• D. Incorrect. A join against a fixed lookup table resolves known relationships between records; it does not measure semantic similarity between free-text memory content and a new query.

Correct answer: C — Weigh both scorer results together against the task's requirements rather than deciding from either scorer alone

Correct answer: A — Degraded output quality caused by irrelevant retrieved memories crowding out the relevant ones in context

• A. Correct: context pollution describes the over-retrieval symptom where too much irrelevant or low-value memory content is included, diluting the relevant signal and degrading response quality.
• B. Incorrect: this describes a security/tampering issue, not the quality-dilution effect that context pollution refers to.
• C. Incorrect: this describes an availability failure, not the retrieval-quality issue captured by 'context pollution'.
• D. Incorrect: this describes a data-integrity or write-path issue, unrelated to the concept of irrelevant content diluting retrieved context.

Correct answers: A, C, D — Retrieved passages are on-target but answer a different sub-question than intended, implying retrieval occurred before intent resolution.; The agent frequently needs a second retrieval pass after user rephrasing, because the first pass targeted the wrong meaning of the query.; The same literal query text should map to different answers depending on the conversation context the agent had ignored before retrieving.

• A. Correct. When retrieved passages are on-target but answer a different sub-question than intended, it indicates the system fetched documents without first disambiguating the query's intended meaning. This is a clear sign that retrieval happened before intent resolution, rather than a retrieval-quality problem.
• B. Incorrect. Growing query latency as the index grows larger is a performance and scalability issue, not evidence that intent resolution was skipped. Returning results for partial queries may reflect an as-you-type search pattern, which is a user interface design and does not necessarily mean the pipeline failed to resolve user intent before retrieval.
• C. Correct. Requiring a second retrieval pass after user rephrasing suggests the initial query targeted the wrong meaning, implying that intent was not properly resolved before the first retrieval. This rephrase-and-retry pattern is characteristic of unresolved intent, not a deficiency in retrieval quality.
• D. Correct. When conversation context that should disambiguate a literal query is ignored before retrieval, the agent fails to resolve user intent. This directly leads to different answers for the same query text, which is a telltale sign that retrieval was performed without first interpreting what the user meant.
• E. Incorrect. A day-late Delta table refresh results in a stale index snapshot, which is a data-freshness issue in the retrieval layer. This timing mismatch does not indicate that user intent was unresolved before retrieval; it simply means the retriever is working with outdated data.
• F. Incorrect. Upgrading the embedding model changes the vector space, causing a misalignment between retrieval and query rewriting. This is a retrieval-quality or model-drift issue, not evidence that the pipeline is retrieving before resolving user intent.

Correct answer: D — Persist past ticket history to Lakebase keyed by customer account ID, and retrieve the relevant history when a new session for that customer begins.

• A. Incorrect. The conversation buffer is reset at the start of every new session regardless of its length, so extending it does not allow information to survive across separate sessions.
• B. Incorrect. Retaining one shared buffer across all customers indefinitely conflates unrelated customers' histories and fails to scope persistence to the correct customer identity, creating a new mismatch rather than resolving the original one.
• C. Incorrect. This approach works around the missing memory rather than fixing it, and it increases friction for the customer instead of matching the memory type to the actual cross-session need.
• D. Correct. The information need spans separate sessions weeks apart, which is a cross-session persistence need. Storing ticket history durably in Lakebase, keyed by customer account ID, and retrieving the relevant history at the start of a new session is the correct memory strategy.

Correct answer: A — It is a fully managed Postgres database. Any authorized compute node can connect to it for consistent reads and writes.

• A. Correct. Lakebase is a fully managed Postgres database, providing a centralized, consistent data store. Multiple agent instances on different compute nodes can connect to it with proper authorization, enabling reliable concurrent reads and writes with ACID guarantees.
• B. Incorrect. Lakebase does not store memory records locally on the creating node; it is a managed remote database service. Allowing other nodes to directly read and write local storage over the network would bypass centralized consistency controls and lead to conflicts.
• C. Incorrect. Lakebase provides a single shared database, not per-node local copies. Maintaining separate local copies would cause data divergence and consistency issues, undermining the goal of durable, shared state across distributed agent instances.
• D. Incorrect. As a fully managed Postgres database, Lakebase supports multiple concurrent connections and uses standard concurrency control mechanisms. Serializing all operations through a single connection would create a severe bottleneck and limit scalability for distributed agent workflows.

Correct answer: A — Both descriptions say the tool "finds matching entries for a query" without naming the data source, so intent can't map to catalog vs. FAQ content.

• A. Correct. Neither description states what is being searched (the product catalog vs. the FAQ knowledge base), so the two tools read as functionally identical to the model, which then has to guess.
• B. Incorrect. A shared parameter name affects how arguments are supplied, not whether the model can distinguish which tool's purpose matches the user's intent — the failure here is in the description text, not the schema.
• C. Incorrect. Verb tense in a description has no bearing on how many tools an LLM is willing to select from; this isn't a documented mechanism of tool-selection ambiguity.
• D. Incorrect. Being hosted on the same MCP server does not merge Unity Catalog permission scopes or tool identities; each registered tool retains its own description and access control entry.

Correct answer: A — Progressive disclosure changes only when a schema enters context, not which tools exist; every tool stays discoverable and callable

• A. Correct. Progressive disclosure is a staging strategy for token cost, not a restriction on capability: the always-available summary keeps every one of the 25 tools discoverable, and any tool's full schema can still be loaded into context whenever the agent decides to call it, so no functionality is lost relative to loading everything upfront.
• B. Incorrect. Nothing about progressive disclosure imposes a hard cutoff after a fixed number of turns; a tool's full schema can be loaded on whichever turn the agent actually selects it, even late in a long conversation, as long as its summary remained discoverable.
• C. Incorrect. There is no inherent one-tool-per-session limit in progressive disclosure; the agent can call as many different tools as the task requires, it just loads each one's full schema only at the point it is needed rather than all at once.
• D. Incorrect. Progressive disclosure operates entirely within the agent's own tool-calling flow -- it changes what enters context and when, not whether the agent can call tools at all -- so it does not require removing automated tool calling or substituting human execution.

Correct answer: A — Functional fit, input/output compatibility, and task requirements

• A. Correct. Tool selection from a registered set should be justified by how well a tool's purpose (functional fit), its parameter and return types (input/output compatibility), and its match to what the task actually needs (task requirements) align with the request.
• B. Incorrect. Cost, region, and ownership are operational or governance details, not the criteria used to determine whether a tool functionally matches a given agent task.
• C. Incorrect. Superficial text properties like name or docstring length say nothing about whether a tool's behavior and schema satisfy the task.
• D. Incorrect. Runtime, cluster, and warehouse configuration affect where a Unity Catalog function executes, not whether it is the semantically correct tool to select for a task.

Correct answer: A — The explicit exclusion decision the user gave was discarded, rather than being carried forward as a standing constraint

• A. Correct. A specific user decision ("exclude sales_2019_legacy") was reduced to a vague narrative phrase ("relevant sales tables") that no longer encodes the exclusion, so the agent re-added the table. Decisions and their rationale need to survive compaction as explicit, standing constraints, not paraphrased narrative.
• B. Incorrect. Nothing in the scenario suggests the warehouse type was lost or caused the observed behavior; the failure is specifically about a table being re-added, tied to a decision, not a configuration detail like warehouse type.
• C. Incorrect. Row counts are reference statistics unrelated to which table was excluded; losing them would not explain the agent re-adding a specifically excluded table.
• D. Incorrect. The display name has no bearing on which tables are included in the space, so its loss would not produce this symptom.

Correct answer: A — Re-run the summarizer on traces with known important facts and confirm those facts still appear in the summaries

Correct answer: A — The pattern is non-monotonic: a fact stated early stays critical throughout, so recency-only trimming misses it and compaction is needed here.

• A. Correct. The schema fact remains critical long after it ages out of recency-based trimming, showing the relevance pattern is not purely recency-driven and requires compaction to preserve durable facts.
• B. Incorrect. If the pattern were purely recency-based, dropping the schema turn would not have caused a downstream failure; the observed failure demonstrates the opposite.
• C. Incorrect. This assumes all older turns are equally safe to discard, which is exactly the assumption the failure disproves for this task.
• D. Incorrect. The scenario states context pressure did trigger trimming; the failure is about what was dropped, not whether pressure existed.

Correct answer: A — The four unused chunks not referenced again in the trace

• A. Correct. Chunks 1, 3, 4, and 5 were retrieved but never used in reasoning or in the final answer, so they are redundant retrieval results that can be discarded without any loss of used information.
• B. Incorrect. This is the chunk the answer actually quotes; removing it would strip the source evidence the final answer relies on.
• C. Incorrect. The original question is needed to verify the answer addressed the right policy topic and to support any follow-up questions in the same session.
• D. Incorrect. This is the agent's live deliverable built from the cited chunk, not superseded retrieval noise, so it should be preserved.

Correct answer: A — Conservative compaction, because it preserves higher fidelity of prior context even though it costs more tokens

Correct answers: A, B, C — The specific objective the sub-agent is responsible for completing; The exact output format expected for the sub-agent's response; A clear boundary describing what is out of scope for this sub-agent

Correct answer: A — Refresh the re-planning sub-agent's context with the latest checkpoint before it plans next

• A. Correct. Propagating the most recent checkpoint state into the re-planning sub-agent's context before it plans ensures it knows which tables are already migrated, directly preventing the duplicate scheduling.
• B. Incorrect. Ignoring checkpoints and restarting from the original plan discards progress information entirely, which would cause even more redundant re-migration rather than preventing it.
• C. Incorrect. Running the sub-agents in parallel without coordination removes propagation altogether, making it more likely the re-planning sub-agent acts on stale information.
• D. Incorrect. Fewer checkpoints reduces tracking overhead but widens the window during which the re-planning sub-agent's view of progress is stale.
• E. Incorrect. Write access changes what the sub-agent is permitted to do, but does not ensure it is given the current migration progress before it plans.

Correct answer: A — Persist intermediate reasoning locally and return only a compact final-result summary

• A. Correct. Keeping the detailed intermediate reasoning local to the sub-agent and passing only a compact summary of the final outcome gives the orchestrator exactly what it needs to continue planning while removing the bulk of the token volume from its context.
• B. Incorrect. Deleting the intermediate notes entirely removes any ability to audit or debug the sub-agent's process later, which is unnecessary risk when the notes could simply be kept local rather than discarded.
• C. Incorrect. Omitting the final result while keeping the verbose intermediate reasoning defeats the purpose — the orchestrator still receives the bulky content and loses the one piece of information it actually needs.
• D. Incorrect. Storing the intermediate reasoning in the orchestrator's own context is the opposite of load reduction; it moves the bulky content into the very context that is saturating.
• E. Incorrect. A single long paragraph of compressed reasoning without the final result still adds unnecessary bulk while withholding the outcome the orchestrator actually requires.

Correct answer: A — Reduce the number of supervisor layers and delegation hops between the user and the working agent

• A. Correct. Four layers of nested supervisors mean the original request is summarized and re-summarized repeatedly before reaching the working agent — excessive handoff compression overhead. Flattening the hierarchy to fewer delegation hops reduces the number of lossy summarization points.
• B. Incorrect. Expanding the working agent's tool set does nothing to address constraints being dropped during the multi-layer delegation chain; the loss happens in the handoffs, not in the working agent's capabilities.
• C. Incorrect. The problem described is detail lost during repeated summarization across supervisor layers, not any single agent running out of context space, so enlarging context windows would not fix the root cause.
• D. Incorrect. Consolidating Genie spaces into the top-level supervisor does not by itself reduce the number of delegation layers between the user and the working agent where the constraint loss is occurring.

Correct answer: A — A shared-context gap between agents about the currency of their knowledge sources produces inconsistent answers to the same question.

• A. Correct. Neither agent is aware that the other is using knowledge of a different age, so their outputs diverge; this mismatch in shared understanding of context freshness is a core shared-context failure.
• B. Incorrect. The scenario does not describe any permission conflict; both agents can access their sources, but the disagreement arises because they are unaware of each other's knowledge recency, not because Unity Catalog permissions gave them different snapshots.
• C. Incorrect. An incorrectly configured SQL warehouse would typically cause query errors or wrong results, but the described disagreement stems from differing knowledge currency between agents, not a configuration error in one agent's execution environment.
• D. Incorrect. Aggressive chunking affects retrieval quality within a single vector index, not the cross-agent unawareness of different knowledge ages. The problem here is that neither agent knows the other is using differently aged sources.