Databricks GenAI Engineer Associate
Section 1 · 14%Design Applications

Design applications

Prompts that return a set format, picking model tasks and chain parts, ordering tools for multi-step reasoning, and when an Agent Bricks agent beats building your own. Mostly reasoning from requirements; the Databricks part is Agent Bricks.

PracticeS1 practice bank →

18 items, practice or timed exam mode.

Teaching cards8 cards

One-liner, how it works, must-know facts, traps and a quick check for each.

Walk the guide, line by line

This section tests whether you can turn a business request into a design: what goes in, what must come out, which model task and which parts sit between. The biggest way people lose marks is picking an impressive tool (an agent, a bigger model) when the question's stated constraint points at a simpler, fixed design. Each row is one line of the official guide. Read across: plain words, what a question looks like, the answer, and the trap.

Guide lineIn plain wordsA question looks likeThe answerThe trap
1.1 Design a prompt that elicits a specifically formatted responseWhen code reads the model's answer, you must make the answer arrive in a set shape, such as JSON with named fields. You do this either by setting a request option that enforces the shape, or, if you can only edit the prompt, by showing the exact format and the allowed values.A support tool parses the model reply into a ticket record and breaks whenever a field is renamed. The team controls the request sent to a Foundation Model API chat endpoint.Send the schema in the response_format request field with type json_schema and strict set, because the platform then holds the model to your field names and types. Use json_object only when the structure is not known in advance, since it promises valid JSON and nothing more. Keep the schema flat; the documented limit is 64 keys, and pattern, anyOf, oneOf and $ref are not supported.
Try it: Call a pay-per-token chat endpoint twice, once with a plain instruction and once with a json_schema response format, and compare the replies.
Writing 'reply in JSON' in the system prompt looks fine but only asks politely, so fields still drift. json_object is also tempting, but it does not enforce your fields.
Runner-up wins when: A prompt with a filled example and the allowed labels wins when the stem says you cannot change request fields, for example a UI where only the prompt text is editable.
1.2 Select model tasks to accomplish a given business requirementName the language task first (classify, extract, summarize, translate, generate), then pick the tool built for that task. Databricks offers ready-made AI Functions you call from SQL for the common tasks.A retailer wants each incoming email put into one of five fixed queues, directly from a SQL table of emails, with no prompt writing.A fixed label set is classification, and the matching function is ai_classify. Pulling named fields is extraction (ai_extract), a shorter version of the same text is summarization (ai_summarize). Use the general ai_query only when no task-specific function fits and you need your own prompt or model. AI Functions do not run on Classic SQL warehouses.
Try it: Run ai_classify on three short sentences in a SQL notebook with a list of two labels.
Choosing ai_query with a hand-written prompt works but adds prompt and model decisions the stem did not ask for. Another slip is calling invoice-total extraction 'classification'.
Runner-up wins when: ai_query wins when the stem needs a custom prompt, a specific served model, or output the task-specific functions cannot produce.
1.3 Select chain components for a desired model input and outputBefore choosing any model, write down exactly what the system receives, what it must hand back, in what shape, how fast, and how often. That description is the spec every later choice is checked against.A bank asks for an assistant that helps relationship managers. The question asks which description of the pipeline is the most useful starting point.The best description names the real inputs (fields, documents, user text), the exact output a person or system consumes (fields, allowed values, length) and constraints such as latency and whether work is batch or per request. Batch versus real time already separates an ai_query job from a serving endpoint. If an input does not exist in any data source, prompting cannot create it; you need a source or a tool.An option that names a model or vendor but no inputs and outputs is a technology choice, not a description. A vague output such as 'a helpful answer' loses to explicit fields.
1.4 Translate business use case goals into a description of the desired inputs and outputs for the AI pipelineA chain is a fixed sequence of parts: a prompt template, optionally a retriever that fetches documents, the language model, and an output parser. You add a part only when the input or output needs it.Answers must come from the company's private policy documents and must cite which document was used. The flow is the same on every request.Add a retriever over a search index for the private documents, pass the chunk text and its source id into the prompt template, and let the model answer. The flow never changes between requests, so a chain is the right shape. Add an output parser or structured outputs if code consumes the result.Fine-tuning the model on the policies looks like a way to teach it facts, but it cannot cite sources and goes stale when a policy changes.
Runner-up wins when: A single prompt template plus the model wins when the behaviour is static and needs no private data.
1.5 Define and order tools that gather knowledge or take actions for multi-stage reasoningA tool is a function the model can call to get knowledge or take an action. For work that needs several steps, you define the tools and decide the order in which they must run, because a later step often needs the result of an earlier one.A request to refund an order needs the order looked up, the refund policy checked, and only then the refund issued.Order the tools by dependency: look up the order, retrieve the policy, then run the refund action. Tools that read data come before tools that change it, so a wrong refund is not issued on missing facts. Each tool needs a clear name, description and input schema so the model picks it correctly. Unity Catalog functions and retriever tools are the usual ways to register them.Putting the action tool first, or giving the model one big tool that does everything, hides the order and makes errors hard to trace.
Runner-up wins when: A fixed chain wins when the steps never vary; the model choosing tools only earns its cost when the path depends on the request.
1.6 Determine how and when to use Agent Bricks (Knowledge Assistant, Multiagent Supervisor, Information Extraction) to solve problemsAgent Bricks is the Databricks service for building agents with little code. The Knowledge Assistant answers questions from your documents with citations, the Multiagent Supervisor coordinates several agents or Genie spaces, and Information Extraction turns text into structured fields.A team wants a chat assistant over a folder of manuals, with sources shown, built without writing a retrieval pipeline.That is the Knowledge Assistant: point it at the documents and it builds the retrieval and answers with citations. Choose Information Extraction when the output is structured fields from text. Choose the Multiagent Supervisor when one request must be routed across several specialist agents or Genie spaces.Choosing the Multiagent Supervisor because it sounds the most powerful. With one document source and no routing need, it adds a layer nothing asked for.
Runner-up wins when: A hand-built chain wins when you need custom retrieval logic or code-level control that the managed builders do not expose.

Mind map: Which design for which requirement

People assume the most capable-sounding design is the safe answer, but the question's constraint almost always picks the smallest design that meets it.

What you observeWhat it points toWhat to do (and when the runner-up wins)
Fixed set of labels, data already in a SQL tableA task-specific AI Function such as ai_classifyUse it. If the stem adds a custom prompt or a named model, ai_query wins instead.
Code parses the reply and breaks on missing fieldsStructured outputs through response_formatUse json_schema with strict. If you cannot change request fields, a prompt with an example wins.
Answers from private manuals with sources, no pipeline to buildKnowledge Assistant in Agent BricksUse it. If you need custom retrieval code, a hand-built chain wins.
One request must reach several specialist agentsMultiagent SupervisorUse it. If there is only one source, the Knowledge Assistant is enough.
Same steps on every requestA chain with fixed partsBuild the chain. If the path depends on the request, tools the model chooses between win.

APrompts, tasks and pipeline specs

1.1

Prompts that return a set format

If code reads the answer, enforce the format with structured outputs; if you can only change the prompt, show the exact format and the allowed values.

If you know this from Azure/Claude: Same idea as tool-forced JSON in Claude and structured outputs in Azure OpenAI. On Databricks it is the response_format field on a Foundation Model API chat request.

How it works

  1. Write the schema the downstream code needs: field names, types, allowed values
  2. Send it as response_format with type json_schema (known structure) or json_object (structure not known in advance)
  3. If you can't set API fields, put a filled example and the allowed labels in the prompt, and say 'output only the JSON'
  4. Check finish_reason before parsing

Must know

  • json_schema takes a name, a schema and strict; use it when you know the structure up front.
  • json_object only promises valid JSON, not your fields.
  • Claude models on Databricks support json_schema only, not json_object.
  • Flat, simple schemas give better JSON than deeply nested ones; limit of 64 keys.
  • pattern, anyOf, oneOf and $ref are not supported in the schema.

Traps

  • 'Ask for JSON in the system prompt' is the weaker answer when the stem lets you set request fields.
  • json_object is not schema enforcement: fields can still be missing or renamed.

Quick check: s1-q01 · s1-q11 · s1-q13 · Source: docs: machine-learning/model-serving/structured-outputs

1.2

Pick the model task for the requirement

Name the NLP task first (summarize, classify, extract, translate, generate), then pick the tool built for it.

If you know this from Azure/Claude: Same task taxonomy you used for Azure Language and Foundry models. Databricks-specific: the task-specific AI Functions you call from SQL.

How it works

  1. Rewrite the requirement as 'input text, output what?'
  2. A fixed label set is classification; named fields is extraction; shorter text with the same meaning is summarization
  3. If a task-specific AI Function matches, use it; otherwise use ai_query with your own prompt and model

Must know

  • Task-specific: ai_classify, ai_extract, ai_summarize, ai_translate, ai_mask, ai_analyze_sentiment, ai_fix_grammar, ai_similarity, ai_parse_document.
  • General-purpose: ai_query takes any supported serving endpoint and your own prompt.
  • Databricks recommends task-specific functions to get started: no prompt design or model choice needed.
  • AI Functions do not run on Classic SQL warehouses.
RequirementTaskDatabricks function
Route tickets to one of five queuesClassificationai_classify
Pull vendor and total from invoicesExtractionai_extract
One-line gist of a long noteSummarizationai_summarize
Hide names and emailsMaskingai_mask
Anything with a custom promptGeneralai_query

Traps

  • Summarization and text-to-text generation look alike; a shorter version of the same content is summarization.
  • Pulling an invoice total out of text is extraction, not classification.

Quick check: s1-q02 · Source: docs: large-language-models/ai-functions

1.3

From business goal to pipeline inputs and outputs

Before choosing models, write down exactly what goes in, what must come out, in what shape, how fast and how often.

If you know this from Azure/Claude: The same spec habit as defining an agent's contract in CCA-F. The exam rewards the most concrete input and output description.

How it works

  1. List the inputs the system actually has (fields, documents, user text)
  2. Define the output a person or system consumes: fields, allowed values, length
  3. Add constraints: latency, batch or per request, cost, who can see what
  4. Only then map each step to a component

Must know

  • A good spec names the output schema the downstream system reads.
  • Batch versus real time decides ai_query jobs versus a serving endpoint.
  • Missing input data can't be fixed by prompting; it needs a new source or tool.

Traps

  • Options that name a model or vendor but no inputs and outputs are not a pipeline description.
  • Vague outputs ('a helpful answer') lose to explicit fields and allowed values.

Quick check: s1-q03 · s1-q18 · Source: docs: large-language-models/ai-functions

BChains and tools

1.4

Choose chain components from input and output

A chain is a fixed sequence: prompt template, optional retriever, the LLM, and an output parser. Add a part only when the input or output needs it.

If you know this from Azure/Claude: If you built RAG in Azure (AI Search plus a chat model) or Claude, this is the same pipeline. The exam wording is LangChain-style: retriever, prompt template, output parser.

How it works

  1. Answer depends on private documents: add a retriever over a vector index
  2. Answer must cite sources: pass chunk ids into the prompt template
  3. Code consumes the result: add an output parser or structured outputs
  4. Static behaviour only: a prompt template plus the LLM is enough

Must know

  • Retriever: fetches relevant chunks for the question.
  • Prompt template: fills user input and context into fixed instructions.
  • Output parser: turns model text into the structure the next step reads.
  • Fine-tuning is not a way to add fresh facts; retrieval is.

Traps

  • Fine-tuning to keep answers current is the classic wrong answer; facts change, weights don't.
  • A longer system prompt doesn't replace a retriever when the documents are large or change.

Quick check: s1-q04 · s1-q17 · Source: docs: generative-ai/tutorials/ai-cookbook/quality-data-pipeline-rag

1.5

Define and order tools for multi-stage reasoning

Split tools into ones that gather knowledge and ones that take actions; gather and check before you act.

If you know this from Azure/Claude: Same as CCA-F tool design: clear names, precise descriptions, read before write. Databricks-specific: Unity Catalog functions use their COMMENT as the tool description, and MCP servers are now the recommended way to add tools.

How it works

  1. List what the agent must know (look-ups, retrieval, Genie queries)
  2. List what it must do (create ticket, issue refund)
  3. Order: identify, then gather facts and rules, then act, then confirm
  4. Write precise descriptions so the model picks the right tool

Must know

  • For a Unity Catalog function tool, the function COMMENT and each parameter COMMENT tell the agent when and how to call it.
  • UCFunctionToolkit exposes UC functions as tools across agent libraries.
  • Databricks now recommends MCP servers for agent tools: Databricks-provided, external, or custom.
  • Access to Databricks-provided and registered MCPs is controlled through Unity Catalog permissions.

Traps

  • When an agent picks the wrong tool, fix the descriptions before adding more tools or a bigger model.
  • Acting before checking policy (refund first, look up rules later) is the wrong order.

Quick check: s1-q05 · s1-q14 · s1-q15 · Source: docs: generative-ai/agent-framework/create-custom-tool · docs: generative-ai/agent-framework/agent-tool

CAgent Bricks: when to use which

1.6

Agent Bricks Knowledge Assistant

A no-code question-and-answer agent over your documents that answers with citations.

If you know this from Azure/Claude: New for you: like an Azure 'chat with your data' setup or a Claude RAG bot, but configured in the UI: point it at sources, add instructions, deploy an endpoint.

How it works

  1. Add up to 10 knowledge sources: UC volumes, UC tables or vector search indexes
  2. Write instructions for response style
  3. Improve quality with example questions and SME guidelines
  4. Query the agent endpoint from apps, AI Playground, curl or Python

Must know

  • Volumes: txt, pdf, md, ppt/pptx, doc/docx. Files over 100 MB, or documents over 500 pages, are skipped.
  • A UC table source must be a streaming table or have Change Data Feed enabled.
  • Responses cite sources ('View sources').
  • Needs serverless compute and Unity Catalog.
  • Current docs label Knowledge Assistant legacy and recommend Genie Agents for new low-code agents; the March 2026 exam guide still names it.

Traps

  • Knowledge Assistant answers questions; it does not fill a table with fields. That is Information Extraction.
  • A UC table without Change Data Feed (and not a streaming table) can't be a source.

Quick check: s1-q06 · s1-q10 · s1-q16 · Source: docs: agents/agent-bricks/knowledge-assistant

1.7

Agent Bricks Supervisor Agent (Multi-Agent Supervisor)

One entry point that delegates each request to the right subagent or tool and combines the results.

If you know this from Azure/Claude: The coordinator-subagent pattern from CCA-F, as a managed product. In Azure terms, a connected-agents set-up you configure rather than code.

How it works

  1. Add subagents and tools: Genie Agents (formerly Genie spaces), Knowledge Assistant and other endpoints, UC functions, MCP servers
  2. Write clear descriptions so routing works
  3. Test in the configuration page or AI Playground
  4. Let SMEs add labeled questions and guidelines

Must know

  • Up to 50 agents and tools per supervisor.
  • Each end user needs access to each subagent (CAN QUERY on endpoints, SELECT on tables).
  • If a user lacks access to some subagents, the supervisor steers away from them; with no access at all, the conversation ends.
  • Includes built-in web search and a sandboxed code tool with no internet access.
  • Docs now label it legacy; for code-based orchestration they point to the Agent Bricks CLI.

Traps

  • Use a supervisor when one question spans several sources or agents, not for a single document set.
  • The supervisor doesn't bypass permissions: users still need access to each subagent.

Quick check: s1-q08 · s1-q09 · Source: docs: agents/agent-bricks/multi-agent-supervisor

1.8

Agent Bricks Information Extraction

Turn documents and text into structured fields with a schema you define, then run it at scale with ai_extract.

If you know this from Azure/Claude: New for you as a product, but the same job as Azure Content Understanding or Document Intelligence field extraction.

How it works

  1. Point it at a UC volume (text, PDFs, images, tables) or a UC table column
  2. Generate a schema from a plain description, or define fields and descriptions yourself
  3. Refine with feedback or by editing field descriptions; evaluate against a labeled table
  4. Run via SQL ai_extract, a scheduled Lakeflow pipeline or the REST endpoint

Must know

  • Built on the ai_extract AI Function.
  • Evaluation gives per-field accuracy, precision, recall and F1 against ground truth.
  • Limits: 128k-token maximum context; union schema types not supported.
  • Field descriptions act as extraction hints.
NeedAgent Bricks choice
Answer questions over documents, with citationsKnowledge Assistant
Fields from many documents into a tableInformation Extraction
One question spans Genie data, documents and toolsSupervisor Agent

Traps

  • Extraction for chat Q&A is the wrong tool; Information Extraction produces rows, not conversations.
  • Free-text summaries are not structured fields.

Quick check: s1-q07 · s1-q12 · Source: docs: agents/agent-bricks/info-extraction