Black Friday Flash Sale - Everything Must Go at 75% Off - Ends in 0d 00h 00m 00s - Coupon code: w75best

Databricks Context-Engineer-Associate Dumps

Databricks Certified Context Engineer Associate Questions and Answers

Question 1

A context engineer is building a customer support agent on Databricks. The agent’s session-initialization routine must populate a context object before turn 1 begins; the context object is then passed to every turn handler. The agent needs the user’s plan tier, region, and a few entitlement flags from the Lakebase customer_profile table in that context object. The values must be present before the first turn handler executes and may be referenced on any subsequent turn. The values do not change during a session, but could change across different sessions. The team wants to minimize per-turn Lakebase round-trips and the latency they add to turn responses.

Which retrieval approach should the engineer implement for this agent architecture?

Options:

A.

Query Lakebase for the plan tier, region, and entitlement flags once and store them in a shared cross-session cache, then have each session read its values from that cache at session start.

B.

Pre-load the user’s plan tier, region, and entitlement flags from Lakebase into the agent’s per-session context object at session start, and reuse the loaded values for the rest of the session.

C.

Query Lakebase for the plan tier, region, and entitlement flags during each turn that references them, so the agent pulls the current values from the table on those turns.

D.

Pre-load the user’s plan tier, region, and entitlement flags from Lakebase at session start, and re-fetch them on a fixed five-minute cadence to keep the agent’s copy in sync with Lakebase.

Question 2

A context engineer is debugging a Databricks agent that staffs an internal IT help desk. The agent is already connected to a retrieval pipeline over a live, continuously updated knowledge base, and relevant KB passages are retrieved and placed in its context on every request. Its system prompt has three parts: a 400-token persona preamble, a 600-token list of every supported software title, and a 200-token closing instruction block. None of these parts explains how to weigh retrieved passages against the model’s own training knowledge.

Observed behavior: the agent correctly identifies the user’s intent, and the correct KB passages are present in context. However, for version-specific questions, it answers from its training knowledge and recommends releases that the knowledge base marks as deprecated. The team will accept only a change that does not rewrite the full prompt and does not add or modify retrieval infrastructure.

Which system-prompt revision addresses the version-accuracy behavior?

Options:

A.

Expand the persona preamble to state the model’s training-data cutoff date, so users understand version details may be out of date.

B.

Add a sentence to the closing instruction block telling the agent that, when retrieved passages and its own training knowledge conflict, the retrieved passages take priority.

C.

Move the 600-token software-title list to the very end of the prompt, after the closing block, so the supported-software context is the most recent thing the model reads before answering.

D.

Add a directive to the closing block requiring the agent to present every version number in a consistent format, such as semantic versioning (MAJOR.MINOR.PATCH).

Question 3

A context engineer is debugging a Databricks customer support agent that manages complex billing escalations.

The system prompt instructs the agent to:

Strictly apply the company’s official refund policy.

Treat entries from the “Billing-Policies” tool as authoritative.

Treat FAQ snippets and prior chat history as non-binding guidance only.

In one multi-step trace, the engineer observes the following:

Step 1: The agent calls the “Billing-Policies” tool and retrieves the official refund policy, which clearly states that chargebacks filed more than 90 days after purchase are not eligible for refunds.

Step 2: The agent calls a “Customer-FAQ-Search” tool that returns a community-authored FAQ thread. A top-voted but outdated and unofficial answer incorrectly claims that chargebacks are fully refundable regardless of when they are filed, and the agent summarizes this in the running conversation as an established fact.

Step 3: In a later turn, the customer describes a chargeback dispute from 18 months ago. The agent reasons from its own earlier summary, approves a full refund, and makes no reference to the official policy section excluding cases older than 90 days, even though that policy text remains in the context.

Step 4: In subsequent similar cases, the agent repeatedly approves refunds for old chargebacks, citing its prior summary as justification each time.

Which context failure mode describes what is occurring in this trace?

Options:

A.

Context distraction, because the context has grown so long with policy text, FAQs, and chat history that the model loses focus on the specific 90-day rule and drifts toward irrelevant retrieved content.

B.

Context clash, because the agent is simultaneously presented with two contradictory authoritative sources and produces an inconsistent response that partially applies each policy.

C.

Context confusion, because the agent misidentifies which retrieved policy section governs chargeback disputes, applying refund rules intended for a different transaction category to the current case.

D.

Context poisoning, because a mistaken statement about refund eligibility enters the context as ground truth and is repeatedly reused in downstream steps, overriding the correct policy that is also present.

Question 4

A context engineer is debugging a Databricks agent that supports a multi-turn customer support application. The agent keeps a running summary of all conversation history across every user session in a single vector index and retrieves it on every turn through semantic search. Users report that the agent loses track of facts stated earlier in the same session, while unrelated details from other users’ past sessions appear unexpectedly. Latency has also increased as conversation volume grows.

Which storage configuration correctly resolves the memory type mismatch that is causing this degraded behavior?

Options:

A.

Partition the vector index by user ID and session ID so that semantic retrieval is scoped per session, preventing cross-session bleed while reserving long-term facts for all users.

B.

Use a session-scoped short-term buffer to retain all within-session conversation turns, and reserve the vector store for durable cross-session user facts retrieved by semantic search.

C.

Replace the vector index with a relational table partitioned by session ID, and retrieve all rows matching the current session on every turn to maintain full conversational context for both short-term and long-term memory needs.

D.

Use a session-scoped short-term buffer to retain all within-turn context, and write a full conversation summary to the vector index at the end of each turn so semantic retrieval stays current across all active sessions.

Question 5

A context engineer is building a regulatory compliance agent on Databricks that connects to an external compliance management platform through an MCP Service registered in Unity Catalog.

The MCP server exposes the following tools:

search_compliance_records: Retrieves existing compliance records without modifying them.

get_submission_status: Checks the status of previously submitted reports.

submit_regulatory_report: Sends a finalized regulatory report to an external authority.

delete_compliance_record: Permanently deletes an existing compliance record.

The agent serves compliance officers who are authorized to retrieve records and submit reports. However, organizational policy requires explicit human approval before every regulatory report submission.

The agent must continue executing read-only tools without interruption. It must also prevent unauthorized destructive operations and maintain an auditable record of tool invocations.

The engineering team has confirmed that the MCP tools function correctly. The remaining requirement is to enforce the approval and authorization rules at the platform governance layer rather than relying exclusively on instructions inside the agent ' s system prompt.

Which approach should the context engineer implement?

Options:

A.

Add instructions to the system prompt requiring the agent to ask the user for confirmation before invoking submit_regulatory_report, and instruct the agent never to invoke delete_compliance_record.

B.

Increase the model ' s reasoning effort so the agent evaluates the consequences of each MCP invocation before deciding whether user approval is necessary.

C.

Configure the MCP Service with appropriate Unity Catalog permissions and tool restrictions, and attach an input-phase service policy that requires approval for submit_regulatory_report while allowing authorized read-only calls.

D.

Remove all tools capable of modifying external systems from the MCP server and require compliance officers to submit regulatory reports through an independent manual process.

Question 6

A context engineer manages a Genie space for a finance team. Users repeatedly ask the same shape of QUESTION NO: with different fiscal periods: “What is the total open pipeline by region for FY26 Q1?”, “...for FY26 Q2?” “...for the last quarter?”. The SQL pattern Genie generates is identical across these questions (same JOIN, GROUP BY, and aggregation, with only the fiscal-period filter changing), and the team requires that responses to these recurring questions be labeled Trusted in the chat UI. The engineer must register an asset that reuses the same vetted SQL pattern with the user-supplied fiscal period.

Which curation choice should the engineer make?

Options:

A.

A parameterized example SQL query with a typed (Date or String) fiscal-period parameter, so Genie can reuse the SQL pattern with the user-supplied value each time the QUESTION NO: is asked.

B.

A Unity Catalog SQL function that defines open_pipeline as a reusable measure, with Genie composing the surrounding per-period and per-region SQL around the function call each turn.

C.

A general instructions text block that describes the desired SELECT, JOIN, WHERE, and GROUP BY structure so Genie can regenerate the SQL on every turn from that description.

D.

Multiple static example SQL queries (one for each commonly asked fiscal period: FY26 Q1, FY26 Q2, last quarter), so Genie matches each user QUESTION NO: to its corresponding vetted example.

Question 7

A context engineer is debugging a long-running data pipeline orchestration agent that runs multi-step workflows using registered Databricks tools such as run_job, query_catalog, and validate_schema. After compaction occurs at turn 40, the agent starts re-invoking tools it successfully called earlier in the session and ignores results that downstream steps depend on. Inspection of the compacted context shows that the summarization prompt was instructed to retain only the final state of each pipeline stage. The current compaction prompt reads: “Summarize the current pipeline state in a few sentences and include only what is necessary.”

Which revision to the compaction prompt addresses the coherence failure while keeping token cost low?

Options:

A.

Replace “include only what is necessary” with: “Include the reasoning chain and internal thinking text produced before each tool invocation.”

B.

Replace “include only what is necessary” with: “Include a compact record of each tool called, its key arguments, and its returned result.”

C.

Append: “For each tool invocation, include the full input payload and every response field returned by the tool.”

D.

Append: “Retain the user ' s original task description and all clarifying questions asked during the session.”

Question 8

A context engineer is creating a Databricks agent to triage incoming customer support tickets for a B2B software platform. Each ticket averages 200 tokens.

For each ticket, the agent must:

(1) assign a severity rating of P0/P1/P2/P3 based on whether the issue is fully blocking, degrades core functionality, affects a non-critical feature, or is informational—a judgment that requires reading the ticket body rather than matching keywords;

(2) route the ticket to one of eight engineering teams based on the technical area implied by the ticket;

(3) generate a brief, context-aware acknowledgment reply.

The pipeline must process up to 500 tickets per minute with an end-to-end latency budget of under 2 seconds per ticket. The token budget per invocation is 2,048 tokens, and the operations team has flagged that inference costs must remain minimal at this throughput.

Which reasoning mode should the context engineer configure for the agent?

Options:

A.

Standard mode with extended thinking disabled, because skipping all reasoning overhead minimizes both per-invocation latency and inference cost at 500 tickets per minute.

B.

Extended thinking with max_tokens capped at 1,024, because limiting the response length reduces cost while preserving full reasoning depth.

C.

Extended thinking with a default thinking budget, because severity classification across four tiers and routing across eight teams benefits from deep chain-of-thought reasoning to maximize accuracy.

D.

Reduced thinking, because the task requires modest structured reasoning across four severity tiers, a small thinking budget fits within the 2,048-token invocation, and latency and cost stay manageable at 500 tickets per minute.

Question 9

A context engineer is assessing a Databricks agent that coordinates a multi-week pharmaceutical supply chain compliance workflow across dozens of distribution centers. The agent uses a flat task decomposition strategy, dividing the entire workflow into a single-level list of atomic tasks that are dispatched and tracked independently. The workflow contains clusters of tightly coupled sub-tasks, such as per-facility inspection records that must all complete before a regional compliance certificate can be issued, and the agent repeatedly fails to coordinate these cluster-level completions correctly. Logs show that the agent loses track of intermediate group states, issues compliance certificates prematurely on incomplete facility data, and cannot recover gracefully when individual facility inspection tasks fail.

Which two changes should the context engineer make to resolve the observed failure?

Choose two

Options:

A.

Switch to a parallel decomposition strategy that executes all facility inspection and certificate tasks simultaneously, relying on eventual consistency to merge partial results into the final compliance record.

B.

Add a retry loop at the top-level agent that restarts the entire flat task list from the beginning whenever any single facility inspection task fails, ensuring no partial state persists across runs.

C.

Replace the flat task decomposition with a hierarchical decomposition strategy that groups related facility inspection sub-tasks under a parent node, enabling group-level completion tracking before dependent tasks proceed.

D.

Introduce explicit dependency gates at each cluster boundary so the compliance certificate task is dispatched only after all facility inspection tasks in the group have reached a confirmed completed state.

E.

Replace the workflow with a fixed sequential chaining strategy that executes every facility inspection one at a time before issuing any certificate, eliminating all concurrency from the pipeline.

Question 10

A context engineer is developing a Databricks agent for a retail inventory management system. The system prompt and tool descriptions consume 1,800 tokens of a 4,096-token context window, and the engineer reserves 1,000 tokens for the user turn and model response. The remaining tokens are used for few-shot examples, each costing approximately 250 tokens, so the engineer includes exactly five examples.

The agent uses three tools: inventory_lookup, reorder_check, and supplier_lead_time.

Six candidate examples are available:

Example 1: A warehouse manager asks whether a depleted SKU needs reordering; the agent calls inventory_lookup, confirms depletion, calls reorder_check, and returns a binary reorder decision.

Example 2: A procurement officer asks when a low-stock item can be replenished; the agent calls reorder_check, calls supplier_lead_time, and returns a replenishment recommendation.

Example 3: A store associate asks for the current stock count of a single product; the agent calls inventory_lookup and returns a scalar quantity.

Example 4: A store associate asks for the current stock count of a single product; the agent calls inventory_lookup and returns a structured status object containing the quantity and a restocking flag.

Example 5: A store associate asks whether a forecasted shortfall requires immediate action; the agent calls inventory_lookup, compares against minimums, calls reorder_check, and returns a binary reorder decision.

Example 6: A logistics coordinator asks how long a specific supplier takes to fulfill an order; the agent calls supplier_lead_time and returns a scalar lead-time value.

Which example should the engineer omit to preserve the token budget while maximizing behavioral coverage?

Options:

A.

Example 1, because the same tools are exercised across Examples 2 and 5, making its specific decision path redundant.

B.

Example 6, because supplier_lead_time is already invoked in Example 2, and a standalone lead-time lookup does not add new tools to the demonstrated call space.

C.

Example 3, because another example in the set covers the same user role and tool path, but the output of the other example is richer.

D.

Example 5, because its forecasting logic duplicates the threshold-check pattern already established in Example 1, and its user role (store associate) appears elsewhere in the set.

Question 11

A context engineer is building a memory-augmented agent that stores user session memories in Lakebase as an OLTP Postgres table. Each memory record contains columns such as user_id, session_timestamp, preference_category, and confirmed_preference_value. At runtime, the agent must retrieve all confirmed preferences for a specific user that were recorded within the last 30 days. A Databricks AI Search index is created over conversation summary embeddings as part of a delta table synced from the Lakebase, providing an additional data source.

Which retrieval mechanism should the context engineer configure for this type of query?

Options:

A.

A hybrid retrieval combining Databricks AI Search similarity scoring and a structured post-filter, because combining both mechanisms improves recall when querying a bounded time window in Lakebase.

B.

Structured query retrieval against the Lakebase OLTP Postgres table using exact filters on user_id and session_timestamp, over a bounded time range with no need for similarity ranking.

C.

Databricks AI Search against the memory embeddings index with a date range metadata filter, because Databricks AI Search with pre-filtering is the recommended approach for scoping time-bounded memory retrieval in agent frameworks.

D.

Structured query retrieval against the Lakebase OLTP Postgres table using exact filters on user_id, session_id, and preference_category, because scoping the lookup to all three attributes produces the most precise memory retrieval for a single user.

Question 12

A context engineer is developing a multi-agent research pipeline on Databricks. A coordinator agent divides an incoming scientific literature query into two parallel subtasks: a citation-retrieval agent and a methodology-analysis agent. Both agents independently receive only the original user query, produce their outputs, and return them to the coordinator, which then invokes a synthesis agent. The synthesis agent produces a final report that contradicts the citation-retrieval findings because it relies solely on the methodology-analysis output and has no visibility into retrieved citations.

Which two context propagation changes would prevent the conflicting outputs in the synthesis agent?

Choose two

Options:

A.

Configure the coordinator agent to merge outputs from the citation-retrieval and methodology-analysis agents into a single context payload before invoking the synthesis agent.

B.

Replace the parallel dispatch pattern with a sequential chain so the methodology-analysis agent runs first, and the citation-retrieval agent runs afterward, without changing what context is forwarded to the synthesis agent.

C.

Configure the coordinator to forward only a high-level methodology summary into the synthesis agent’s context while omitting the underlying citation-retrieval data, to keep the context window small.

D.

Broadcast every agent’s full raw interaction history, including intermediate prompts and tool calls, directly to the synthesis agent, allowing the LLM to self-structure citation results from methodology analysis.

E.

Update the synthesis agent’s input schema to accept a structured context object containing both citation-retrieval results and methodology-analysis results as named fields.

Question 13

A context engineer is developing a Databricks agent for a financial research platform that answers analyst queries using a vector search index over earnings reports. The agent uses a 180-token system prompt, a 250-token conversation history window, and a RAG pipeline that retrieves 8 document chunks at runtime. Each chunk contains 550 tokens, contributing 4,400 tokens of retrieved context. The model’s context window is 8,192 tokens, leaving just 3,362 tokens for the analyst query and model response. Profiling shows that the retrieved chunks consistently contain repetitive regulatory boilerplate and duplicated table headers that are rarely cited in the model’s final answers.

Which two changes should the context engineer make to reduce the token footprint of retrieved context without discarding relevant financial content?

Choose two

Options:

A.

Reduce retrieved chunks from 8 to 3 and apply a reranker to select the highest-relevance chunks, preserving pertinent financial content while cutting injected tokens by over 60%.

B.

Switch the retrieval strategy from cosine similarity to MMR to increase diversity across retrieved chunks, reducing redundancy between chunks without modifying chunk size or removing boilerplate.

C.

Reduce each chunk from 550 tokens to 150-200 tokens by splitting at semantic boundaries and stripping repeated regulatory boilerplate and duplicate headers before indexing.

D.

Re-index the earnings reports using a finer-grained embedding model to improve retrieval precision, surfacing more relevant passages without altering chunk boundaries or stripping metadata.

E.

Expand the conversation history window from 250 tokens to 900 tokens to improve multi-turn coherence across analyst sessions and offset token pressure from the retrieved chunks.

Question 14

An AI engineer is auditing a Databricks compliance agent that has handled 65 conversation turns for a quarterly financial audit. The context window is at 92% capacity, and several audit findings remain open. The engineer wants to recover space by clearing specific raw tool outputs from the message history without compacting the conversation, and is reviewing four tool_result blocks. They also want to minimize the risk of losing information the agent still relies on.

The history contains:

A ledger reconciliation output at turn 7 returning 8,800 tokens of raw transaction rows from a read-only general ledger. The agent calculated aggregated taxable and non-taxable totals from these rows and passed them to the tax classification call at turn 10. The agent’s later replies and tool calls do not quote any underlying transaction rows.

A tax classification output at turn 10 returning 5,200 tokens of per-line bucket breakdowns across 312 transaction lines. The agent extracted the bucket totals and passed them to the compliance flag call at turn 13. The agent’s later replies and tool calls do not quote any per-line bucket assignments.

A compliance flag output at turn 13 returning 95 tokens with three flag codes and one-sentence explanations. The agent quotes specific flag codes and explanations from this output in turns 24, 38, and 61, incorporating them into the audit findings it is currently drafting.

A vendor master lookup output at turn 19 returning 3,400 tokens of supplier records and tax IDs from a read-only vendor master database. The agent quotes a vendor name and tax ID from this output in turns 41 and 57.

Which tool outputs should the engineer clear?

Options:

A.

The ledger reconciliation (turn 7) and tax classification (turn 10) outputs, because the agent’s later reasoning relies on the compliance flag summary (turn 13) rather than on the upstream raw data.

B.

No outputs from the chain (turns 7, 10, 13), because the agent may need to re-quote raw transaction rows or per-line bucket assignments in the open audit findings still being drafted.

C.

The ledger reconciliation (turn 7), tax classification (turn 10), and vendor master lookup (turn 19) outputs, because they are the three largest blocks and yield the most context capacity at once.

D.

Only the tax classification output (turn 10), because the ledger reconciliation is the root of the dependency chain and must be retained for re-derivation if downstream conclusions are challenged.

Question 15

A context engineer is investigating a multi-agent pipeline on Databricks where a coordinating agent breaks down a document analysis task and dispatches subtasks to three specialized sub-agents. After deployment, the sub-agents produce outputs that are internally consistent but contradict one another and do not reflect earlier inferences made at the pipeline level. The sub-agents have access to the same retrieval index, the embedding model is verified as current, and individual sub-agent outputs are accurate when tested in isolation with full context supplied manually.

What is a reasonable root cause of the downstream failures?

Options:

A.

The coordinating agent’s temperature parameter is set too high, introducing non-determinism into the subtask decomposition and producing inconsistent dispatch instructions.

B.

Each sub-agent is dispatched with only its individual task message and lacks access to the coordinator’s earlier reasoning, tool outputs, and decisions.

C.

The retrieval index used by the sub-agents is misconfigured, so they are querying a different corpus than the coordinating agent, leading to contradictory but locally consistent outputs.

D.

The embedding model used for retrieval was not trained on the document domain, causing sub-agents to retrieve irrelevant chunks and produce contradictory summaries.

Page: 1 / 5
Total 50 questions