Overview
Assembling and Deploying Applications is the second-largest section at 22%, around ten questions, and has the most official objectives: 15. The first group is about packaging: coding a chain as an MLflow pyfunc model with pre- and post-processing, coding a simple chain from requirements, choosing the elements of a RAG application (model flavor, embedding model, retriever, dependencies, input example, signature) and registering the model to Unity Catalog with MLflow.
The second group is retrieval infrastructure: creating and querying a Vector Search index, explaining Mosaic AI Vector Search concepts, and configuring it for embedding count, update frequency, latency and cost. The third group is serving and operations: Foundation Model APIs, batch inference with ai_query(), controlling access from serving endpoints, persistent memory stores, CI/CD practices, integrating managed, external and custom MCP servers, prompt version control, and user interfaces through Databricks Apps, Slack or Teams.
How it's tested
Questions are practical and often include code: an MLflow logging call, a Vector Search client call or a SQL statement with ai_query(). Others describe workload characteristics such as volume, update frequency and latency, and ask for the matching configuration. Read numbers carefully, since they usually point to the endpoint type or sync mode.
-
Complete the deployment code
A logging, registration or index creation snippet is missing a parameter and you choose the correct argument or call.
-
Configure for the workload
Embedding counts, update frequency, latency and budget are given and you choose index type, endpoint type, sync mode or serving mode.
-
Batch or real time
A workload is described and you decide between a serving endpoint, Foundation Model APIs mode or ai_query() over a table.
A team must summarize two million archived support tickets once, and nobody waits on individual results. A real-time serving endpoint called in a loop is tempting because the chain already runs there. But this is an offline batch workload over a table, and ai_query() in SQL scores rows in parallel without custom client code, so it is the better fit.
Objectives 15
Official objectives from the Databricks outline, in outline order.
4.1 Code a chain using a pyfunc model with pre- and post-processingCustom MLflow PythonModel wrapping a chain with extra logic.
- What it means
- An MLflow pyfunc model lets you wrap arbitrary Python, including a chain, in a standard interface. This objective covers writing a PythonModel class whose load_context sets up resources and whose predict method runs pre-processing, the chain and post-processing.
- What to understand
- Pre-processing might clean input, extract fields or format a prompt; post-processing might parse JSON, add citations or redact text. Heavy objects such as clients load once in load_context, not on every predict call. Logging from code with a script file is the current recommended pattern for agents and chains.
- How it shows up
- Code for a custom chain is shown and you choose where a step belongs or which method is missing.
- Common confusion
- Loading clients or models inside predict, which repeats setup on every request.
4.2 Control access to resources from model serving endpointsEndpoint permissions, automatic authentication and secrets.
- What it means
- A served chain often calls other resources: a Vector Search index, an LLM endpoint, a Genie space or a table. This objective covers how the endpoint authenticates to them and who may query the endpoint itself.
- What to understand
- Declaring resources when logging the model enables automatic authentication passthrough with a managed service principal. On-behalf-of-user authorization lets the agent act with the caller's permissions. External credentials belong in Databricks secrets referenced by environment variables, never hard-coded. Endpoint permissions such as Can Query and Can Manage control who calls or changes the endpoint.
- How it shows up
- A deployed chain fails to reach a resource or must respect user permissions and you choose the access mechanism.
- Common confusion
- Putting a personal access token in the model code instead of using declared resources or secrets.
4.3 Code a simple chain according to requirementsPrompt template, model and parser assembled to meet a stated need.
- What it means
- This objective asks you to write or complete a short chain: a prompt template with variables, a chat model pointing at a Databricks endpoint, optionally a retriever, and an output parser, connected so the requirement is met.
- What to understand
- Read the requirement for inputs and outputs, then check the template variables match the inputs, the model points to the right endpoint and the parser returns the requested type. In LangChain expression language, components connect with the pipe operator. Keep the chain minimal and testable before adding retrieval or tools.
- How it shows up
- Requirements and a partial chain are given and you choose the missing component or correct line.
- Common confusion
- Template variables that do not match the input keys, which causes runtime errors.
4.4 Choose the basic elements needed to create a RAG application: model flavor, embedding model, retriever, dependencies, input examples, model signatureThe parts that must be specified when logging a RAG app.
- What it means
- To log and serve a RAG application, MLflow needs a model flavor (such as pyfunc or langchain), the code, its pip dependencies, an input example, and a signature, along with the chain's embedding model and retriever configuration.
- What to understand
- The input example shows the expected request and helps infer the signature. The signature defines input and output schema and is required for Unity Catalog registration. Dependencies must be pinned so serving reproduces the environment. The embedding model used at query time must match the one that built the index.
- How it shows up
- A RAG logging step fails or is incomplete and you choose the missing element.
- Common confusion
- Omitting the signature or input example, which blocks Unity Catalog registration and clear serving contracts.
4.5 Register the model to Unity Catalog using MLflowThree-level model names, versions and aliases.
- What it means
- Registering stores a versioned model in Unity Catalog with governance. You set the registry URI to Unity Catalog, then log with a registered model name in catalog.schema.model form, or register an existing run's model.
- What to understand
- Each registration creates a new version. Aliases such as champion point to a chosen version and replace the older stage concept. Unity Catalog permissions control who can use or manage the model, and lineage links it to data and runs. A model signature is required for Unity Catalog models.
- How it shows up
- A registration snippet is shown and you choose the correct name format or missing setting.
- Common confusion
- Using a two-level or bare model name, or relying on legacy stages instead of aliases.
4.6 Create and query a Vector Search indexEndpoints, Delta Sync and Direct Vector Access indexes, and query calls.
- What it means
- This objective covers creating a Vector Search endpoint, then an index on it, and querying the index with text or vectors, columns to return, the number of results and optional filters.
- What to understand
- A Delta Sync index reads from a Delta table with Change Data Feed and needs a primary key; it can compute embeddings from a text column or use a precomputed embedding column. A Direct Vector Access index is written to through the API. Queries specify query text or a vector, columns, num_results and filters, and can request hybrid keyword and vector search.
- How it shows up
- Index creation or query code is shown and you choose the right parameter or index type.
- Common confusion
- Expecting a Direct Vector Access index to sync from a table automatically.
4.7 Identify how to serve an LLM application that leverages Foundation Model APIsPay-per-token, provisioned throughput and external models.
- What it means
- Foundation Model APIs give access to hosted models from serving endpoints. This objective covers how an application calls them and which mode suits the workload: pay-per-token for development and moderate traffic, provisioned throughput for production guarantees and fine-tuned models.
- What to understand
- Pay-per-token endpoints are ready to use with per-token billing. Provisioned throughput reserves capacity for predictable performance. External models route to third-party providers through the same serving interface and AI Gateway. Applications call endpoints through OpenAI-compatible clients or framework wrappers such as ChatDatabricks.
- How it shows up
- A serving requirement is described and you choose the Foundation Model API mode or calling pattern.
- Common confusion
- Choosing pay-per-token for a workload that needs reserved throughput or a custom fine-tuned model.
4.8 Explain the key concepts and components of Mosaic AI Vector SearchEndpoints, indexes, embeddings, sync and similarity search.
- What it means
- This objective tests understanding of how Vector Search fits together: endpoints provide compute, indexes hold vectors and metadata, embeddings come from a model endpoint or a column, sync keeps indexes current with Delta tables, and approximate nearest neighbor search returns similar items.
- What to understand
- Indexes are Unity Catalog objects with governed access. Managed embeddings call an embedding endpoint during sync and at query time. Filters narrow results by metadata. Hybrid search combines keyword scoring with vector similarity. Endpoint type affects scale, latency and cost.
- How it shows up
- A description of a component is given and you identify it, or you explain how pieces interact.
- Common confusion
- Treating the endpoint and the index as the same object.
4.9 Identify batch inference workloads and apply ai_query() appropriatelyLarge offline scoring with SQL instead of real-time calls.
- What it means
- Batch inference processes many rows at once without a user waiting. The ai_query() SQL function calls a model serving endpoint for each row in a query, so tables can be summarized, classified or enriched at scale from SQL or pipelines.
- What to understand
- Signs of batch work: a large table, scheduled runs, results written back to a table and no interactive user. ai_query() handles parallel calls and works with Foundation Model APIs and custom endpoints. Task-specific AI Functions such as ai_classify cover common tasks with less setup. Real-time endpoints suit interactive requests.
- How it shows up
- A workload is described and you decide whether ai_query() batch inference fits.
- Common confusion
- Looping over rows in Python against a real-time endpoint for a one-off bulk job.
4.10 Configure vector search for a particular solution based on number of embeddings, update frequency, latency, and cost requirementsEndpoint type, sync mode and embedding choices by workload.
- What it means
- Vector Search settings should match the workload. This objective asks you to pick endpoint type, index type, sync mode and embedding approach from the number of vectors, how often data changes, the latency target and budget.
- What to understand
- Standard endpoints favor low latency; storage-optimized endpoints scale to very large vector counts at lower cost with somewhat higher latency. Continuous sync keeps the index fresh at higher cost; triggered sync updates on demand or on schedule. Precomputed embeddings avoid repeated embedding calls. Fewer dimensions and filters reduce cost and latency.
- How it shows up
- Workload numbers are given and you choose the endpoint type or sync mode.
- Common confusion
- Choosing continuous sync for data that changes once a week, paying for freshness nobody needs.
4.11 Configure a persistent datastore to store and retrieve intermediate memory or structured informationShort-term and long-term agent memory in Lakebase or Delta tables.
- What it means
- Agents often need memory across turns or sessions: conversation checkpoints, user preferences or intermediate results. This objective covers choosing and configuring a persistent store so the agent can save and reload that state.
- What to understand
- Lakebase, the Databricks managed Postgres database, suits low-latency reads and writes such as LangGraph checkpoints and long-term memory. Delta tables suit analytical records and larger structured outputs. Keying memory by user or thread ID keeps conversations separate. Serving endpoints are stateless, so memory must live outside them.
- How it shows up
- An agent loses context between requests and you choose the persistent store or configuration.
- Common confusion
- Holding memory in the serving container, which is lost when replicas scale or restart.
4.12 Apply CI/CD best practices such as updating a Vector Search index, promoting prompts across environments, and testing individual components of an agentAutomated testing and promotion of indexes, prompts and agent code.
- What it means
- Generative AI applications have more moving parts than code alone: indexes, prompts, models and tools. This objective covers testing each component, promoting prompts and models from development to production, and keeping indexes in sync as part of an automated workflow.
- What to understand
- Use Git for code and Databricks Asset Bundles to deploy jobs, endpoints and resources consistently across workspaces. Unit test tools and retrievers separately from the full agent. Run evaluation as a quality gate before promotion. Promote prompts by moving aliases in the prompt registry. Trigger index syncs when source tables change.
- How it shows up
- A release process is described and you choose the missing practice or correct order.
- Common confusion
- Testing only the full agent end to end, which hides which component broke.
4.13 Integrate managed, external, and custom MCP servers based on a given application requirementsConnecting agents to tools through the Model Context Protocol.
- What it means
- The Model Context Protocol standardizes how agents discover and call tools. Databricks offers managed MCP servers for features such as Vector Search, Genie spaces and Unity Catalog functions, supports external MCP servers through governed connections, and lets teams host custom MCP servers as Databricks Apps.
- What to understand
- Use a managed server when the tool is a Databricks feature, since it is ready and governed. Use an external server for third-party services, connected securely so credentials stay managed. Build a custom server when you need your own tool logic shared across agents. Unity Catalog permissions still apply to managed tools.
- How it shows up
- A tool requirement is described and you choose managed, external or custom MCP.
- Common confusion
- Building a custom MCP server for Vector Search when a managed server already exposes it.
4.14 Apply prompt version control and manage prompt lifecycleVersioned prompts in the MLflow Prompt Registry with aliases.
- What it means
- Prompts change often and affect behavior as much as code. This objective covers storing prompts in the MLflow Prompt Registry, which keeps versions in Unity Catalog, assigning aliases such as production, loading a prompt by alias in the application, and rolling back when needed.
- What to understand
- Each edit creates a new immutable version with a commit message. Applications load by alias so a prompt can be promoted or rolled back without redeploying code. Evaluation runs link to the prompt version used, making comparisons traceable. Hard-coded prompt strings make history and rollback difficult.
- How it shows up
- A team needs to track, promote or roll back prompts and you choose the registry feature.
- Common confusion
- Editing a prompt in place inside application code, losing version history and easy rollback.
4.15 Develop an appropriate interactive user facing interface for an agent usage scenario (Apps, Slack, Teams, etc.)Delivering agents through Databricks Apps or chat platforms.
- What it means
- Users need a place to talk to the agent. This objective covers choosing and building an interface: a web app hosted on Databricks Apps (for example with Streamlit, Gradio or Dash), or integration with Slack or Microsoft Teams where users already work.
- What to understand
- Databricks Apps run inside the workspace with built-in authentication and access to serving endpoints. Chat platform integrations meet users in their daily tools. Choose by audience: internal analysts may prefer an app, while broad employee use may favor Teams or Slack. The interface should pass user identity when on-behalf-of-user access is needed.
- How it shows up
- An audience and usage pattern are described and you choose the interface.
- Common confusion
- Building a standalone web app when the requirement is to reach users inside their existing chat tool.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
pyfunc PythonModel
Custom MLflow model class with load_context and predict.
- Remember
- Load heavy resources once in load_context.
- Tested as
- Chain packaging questions.
- Trap
- Initializing clients inside predict.
-
Model signature
Input and output schema stored with a model.
- Remember
- Required for Unity Catalog registration.
- Tested as
- RAG logging questions.
- Trap
- Skipping the input example and signature.
-
Unity Catalog model name
catalog.schema.model three-level name.
- Remember
- Use aliases, not stages.
- Tested as
- Registration questions.
- Trap
- Using a bare model name.
-
Declared resources
Indexes and endpoints listed when logging an agent.
- Remember
- Enable automatic authentication passthrough.
- Tested as
- Endpoint access questions.
- Trap
- Hard-coding tokens.
-
Delta Sync index
Vector index that syncs from a Delta table.
- Remember
- Needs Change Data Feed and a primary key.
- Tested as
- Index creation questions.
- Trap
- Expecting it without Change Data Feed.
-
Direct Vector Access index
Vector index written through the API.
- Remember
- No automatic table sync.
- Tested as
- Index type questions.
- Trap
- Assuming it syncs from tables.
-
Standard vs storage-optimized endpoint
Low latency versus very large scale at lower cost.
- Remember
- Match vector count and latency.
- Tested as
- Configuration questions.
- Trap
- Defaulting to one type for every workload.
-
Triggered vs continuous sync
On-demand updates versus near real-time updates.
- Remember
- Continuous costs more.
- Tested as
- Update frequency questions.
- Trap
- Paying for continuous on slow-changing data.
-
Pay-per-token vs provisioned throughput
Shared per-token billing versus reserved capacity.
- Remember
- Provisioned suits production guarantees and fine-tuned models.
- Tested as
- Foundation Model API questions.
- Trap
- Using pay-per-token for strict throughput needs.
-
ai_query()
SQL function that calls a serving endpoint per row.
- Remember
- Use for batch inference over tables.
- Tested as
- Batch workload questions.
- Trap
- Python loops against real-time endpoints.
-
Lakebase
Databricks managed Postgres for low-latency state.
- Remember
- Good for agent memory and checkpoints.
- Tested as
- Memory store questions.
- Trap
- Keeping memory in the serving container.
-
MCP server types
Managed, external and custom servers for agent tools.
- Remember
- Prefer managed for Databricks features.
- Tested as
- Tool integration questions.
- Trap
- Rebuilding managed tools as custom servers.
-
MLflow Prompt Registry
Versioned prompts in Unity Catalog with aliases.
- Remember
- Load prompts by alias for promotion and rollback.
- Tested as
- Prompt lifecycle questions.
- Trap
- Hard-coding prompt strings.
-
Databricks Apps
Workspace-hosted web apps with built-in authentication.
- Remember
- Common front end for agents.
- Tested as
- User interface questions.
- Trap
- Ignoring where users already work.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Vector Search index types
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Delta Sync, managed embeddings | Syncs a text column and computes vectors | Least code | Forgetting Change Data Feed |
| Delta Sync, self-managed embeddings | Syncs a precomputed vector column | You control embedding | Mismatched query embedding model |
| Direct Vector Access | Vectors written via API | No table sync | Expecting automatic updates |
Serving and inference modes
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Pay-per-token | Shared hosted endpoints billed per token | Fast start, variable load | Using it where reserved capacity is required |
| Provisioned throughput | Reserved capacity for a model | Predictable performance | Paying for idle capacity in development |
| External models | Third-party providers through serving | Central governance via AI Gateway | Calling providers directly with raw keys |
| ai_query() batch | Row-wise inference from SQL | Offline, high volume | Using it for interactive chat |
MCP server options
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Managed MCP | Databricks-hosted servers for platform features | Ready and governed | Rebuilding them |
| External MCP | Third-party servers via secure connections | Managed credentials | Embedding secrets in code |
| Custom MCP | Your own server hosted on Databricks Apps | Custom shared tools | Building one when managed fits |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Stages over aliases
- What candidates pick
- Promote the model by moving it to the Production stage.
- Why it looks right
- Stages were the long-standing workspace registry pattern.
- Why it's wrong
- Unity Catalog models use aliases such as champion to mark the version in use; stages belong to the legacy workspace registry.
Clue to watch for The model is registered in Unity Catalog.
-
Direct Vector Access for table sync
- What candidates pick
- Choose Direct Vector Access so the index stays in step with a Delta table.
- Why it looks right
- Direct sounds like the most current option.
- Why it's wrong
- Direct Vector Access indexes are updated through API writes; Delta Sync is the type that tracks a source table.
Clue to watch for The source data already lives in a Delta table.
-
Continuous sync everywhere
- What candidates pick
- Use continuous sync for a policy library updated monthly.
- Why it looks right
- Fresh data seems always better.
- Why it's wrong
- Continuous sync runs constantly and costs more; triggered sync after each monthly update meets the need.
Clue to watch for Update frequency is low and cost matters.
-
Endpoint loop for batch
- What candidates pick
- Call the chat endpoint from a Python loop over five million rows.
- Why it looks right
- The endpoint already works.
- Why it's wrong
- ai_query() runs inference in parallel from SQL over a table, which is simpler and better suited to offline volume.
Clue to watch for No user waits and results go back to a table.
-
Token in code
- What candidates pick
- Embed a personal access token so the endpoint can query the index.
- Why it looks right
- It works quickly in testing.
- Why it's wrong
- Tokens in code leak and tie the app to one person; declared resources or secrets give managed authentication.
Clue to watch for The deployed chain must reach another Databricks resource.
-
Custom MCP for platform tools
- What candidates pick
- Build a custom MCP server to expose a Genie space.
- Why it looks right
- Custom gives full control.
- Why it's wrong
- Databricks provides managed MCP servers for Genie, Vector Search and Unity Catalog functions, which are governed and need no hosting.
Clue to watch for The tool is a built-in Databricks feature.
Answer framework
For an Assembling and Deploying scenario, move from packaging through infrastructure to serving and operations.
- Package the chain or agent with the right flavor, code, pinned dependencies, input example and signature, then register it to Unity Catalog with a three-level name.
- Configure retrieval: Delta Sync or Direct Vector Access index, managed or self-managed embeddings, endpoint type and sync mode from vector count, freshness, latency and budget.
- Choose serving: pay-per-token, provisioned throughput or external models for real-time use, and ai_query() for batch scoring over tables.
- Secure and connect: declare resources or use on-behalf-of-user access, keep secrets out of code, add memory in Lakebase or Delta, and prefer managed MCP servers.
- Operate the release: version prompts with aliases, test components separately, gate promotion on evaluation, deploy with bundles and deliver through the right interface.
Practice question
Want more like this? The Databricks GenAI Assoc practice test has questions for every domain.
Checklist
0 of 14
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
This section rewards hands-on familiarity, so plan workspace time. Start by logging a simple chain as a pyfunc model with an input example and signature, register it to Unity Catalog under a three-level name, and set an alias. Deploy it with Agent Framework and note how declared resources handle authentication.
Next, create a Vector Search endpoint and a Delta Sync index on a chunk table with Change Data Feed enabled. Query it with filters and with hybrid search. Read the documentation comparing standard and storage-optimized endpoints and triggered versus continuous sync, and write a one-line rule for each choice.
Then run ai_query() over a small table against a Foundation Model API endpoint, and compare that with calling the endpoint interactively. Read the pages on pay-per-token and provisioned throughput.
Finally, cover the newer objectives: register a prompt in the MLflow Prompt Registry and load it by alias, connect an agent to a managed MCP server, review Lakebase for memory, and look at a Databricks Apps chat template. Short, focused labs on each objective will cover this broad section efficiently.
FAQ
How much of the Databricks GenAI Associate exam is Assembling and Deploying Applications?
Assembling and Deploying Applications is 22% of the exam, about ten scored questions, and has 15 official objectives, the most of any section.
Why does my model need a signature?
Unity Catalog requires a signature for registered models. It defines the input and output schema that serving and other users rely on.
When should I use ai_query()?
For batch inference over tables, such as summarizing or classifying many rows on a schedule, where no user waits for each response.
What is the difference between Delta Sync and Direct Vector Access indexes?
Delta Sync keeps an index aligned with a Delta table using its change feed. Direct Vector Access is updated by writing vectors through the API.
Where should an agent keep memory?
In an external persistent store such as Lakebase for low-latency state or Delta tables for structured records, because serving endpoints are stateless.
What are managed MCP servers?
Databricks-hosted MCP servers that expose platform features such as Vector Search, Genie spaces and Unity Catalog functions to agents with governance applied.
How should prompts be promoted to production?
Store them in the MLflow Prompt Registry, evaluate the new version, then move the production alias to it so applications pick it up without a code change.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 4 knowledge
You have covered pyfunc chains, Unity Catalog registration, Vector Search, Foundation Model APIs, ai_query(), memory, CI/CD, MCP and interfaces. Test whether you can match configurations to workloads.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the Databricks GenAI Assoc AI tutor Get any concept explained your way