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?

• A. 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.
• 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. 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.
• 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.

A context engineer is evaluating a Databricks agent built for a healthcare scheduling platform. The agent's system prompt is 5,100 tokens and includes detailed instructions for three rarely invoked capabilities, each triggered in fewer than 2% of sessions:
Insurance eligibility verification, which requires calls to a third-party payer API with variable response times Appointment rescheduling fee calculations, with complex branching logic across dozens of plan types and provider tiers Medical record release consent workflows, with multi-step conditional logic and regulatory references The agent's primary function is answering patient appointment availability queries, which account for 95% of traffic. The team must reduce per-session context cost without degrading task success rate on the dominant use case, and the solution must stay within the existing Databricks agent framework without introducing additional hosted components to manage.
Which loading strategy should the context engineer use for the three rarely invoked capabilities?

• A. Package each rarely-invoked capability as an Agent Skill so its instruction block is loaded dynamically only when a user query triggers the matching intent, removing those tokens from the baseline prompt.
• B. Enable server-side prompt caching for the full system prompt so the token cost of the three capability blocks is amortized after the initial session, reducing effective per-session billing over time.
• C. Compress the three capability instruction blocks using summarization and retain them in the system prompt, reducing token count while keeping all instructions globally available for every session.
• D. Move the three capability instruction blocks into a retrieval-augmented index and inject the top-ranked block into the user message turn at query time, keeping the system prompt shorter across sessions.

A context engineer is building a retrieval-augmented generation agent on Databricks to answer questions about a large collection of legal contracts. Each contract is a structured PDF averaging 40 pages, with clearly defined sections such as "Definitions," "Obligations," and "Termination Clauses." The embedding model in use has a 512-token context window. User queries are highly targeted, such as "What are the termination conditions in the indemnification clause?", and require precise, clause-level retrieval rather than broad document summaries.
Which chunking strategy should the context engineer use?

• A. Use structure-aware chunking that splits documents at section boundaries, then further subdivides sections exceeding 400 tokens to stay within the embedding model's context window.
• B. Embed each contract section as a single chunk without further subdivision, preserving full section context even when sections exceed the embedding model's context window.
• C. Split each contract into fixed-size chunks of 512 tokens with 50-token overlaps, ignoring document structure, keeping chunks within the embedding model's context window.
• D. Apply paragraph-level chunking across all contracts, splitting each section into individual paragraphs, to maximize retrieval granularity for targeted clause queries.

A context engineer is developing an agent to support legal teams reviewing multi-part pharmaceutical trial protocols. Each protocol document includes a narrative background section, nested dosage tables with footnote qualifiers, cross-referenced section identifiers, and figure captions describing study design diagrams.
The agent must answer precise questions such as which protocol section governs a specific dosage threshold and what footnote conditions apply to that threshold.
Available data sources include:
A PDF binary store in Unity Catalog Volumes.
A Delta table of plain-text chunks extracted from the protocols, each tagged with page number and document identifier, indexed in a Databricks AI Search index.
A Delta table of protocol structure metadata at the page level, containing table summaries, figure captions, and section hierarchy, accessible through Unity Catalog functions.
Which context elements should the context engineer include to answer structural and footnote-level questions accurately?

• A. The structure metadata Delta table loaded entirely into the prompt as a hierarchy, combined with the Databricks AI Search index, so the model can resolve table and footnote references from the full metadata.
• B. The PDF binary store in Unity Catalog Volumes and the structure metadata Delta table, using document identifiers to locate source files and extract table content through a preprocessing step at query time.
• C. The Databricks AI Search index over plain-text chunks alone, relying on semantic similarity to surface table and footnote content without consulting the structure metadata Delta table.
• D. The Databricks AI Search index over plain-text chunks to retrieve relevant passages, then a scoped lookup into the structure metadata Delta table for table summaries and figure context on the matched pages.

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

• A. 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.
• B. 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%.
• C. 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.
• D. 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.
• E. 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.