Databricks Certified Generative AI Engineer Associate Quick Reference

Exam identity and high-yield focus

This independent Quick Reference supports candidates preparing for the Databricks Certified Generative AI Engineer Associate exam, official code GenAI Engineer, from Databricks.

Use it to review the practical decisions behind generative AI applications on Databricks: RAG design, Vector Search, embeddings, prompt engineering, MLflow, Model Serving, Unity Catalog governance, evaluation, and production troubleshooting.

Core Databricks GenAI architecture

    flowchart LR
	    A[Source documents / Delta tables / files] --> B[Parse and clean]
	    B --> C[Chunk with metadata]
	    C --> D[Embed chunks]
	    D --> E[Databricks Vector Search index]
	    U[User question] --> Q[Query rewrite / embed query]
	    Q --> E
	    E --> R[Retrieved context]
	    R --> P[Prompt template]
	    U --> P
	    P --> M[Foundation model or served model]
	    M --> O[Answer + citations]
	    O --> V[Evaluate, log, monitor]
	    V --> G[MLflow, Unity Catalog, inference logs]

Exam-ready mental model

Service-selection matrix

RAG design reference

RAG pipeline checklist

Chunking choices

Recommended chunk table schema

Retrieval tuning

Delta Sync vs Direct Vector Access

Prompt engineering quick reference

Prompt components

Grounded RAG prompt pattern

System:
You are a Databricks RAG assistant. Use only the provided CONTEXT.
Do not use outside knowledge. If the answer is not supported by CONTEXT,
say "I do not know based on the provided context."

User question:
{question}

CONTEXT:
{context}

Return:
- answer
- citations using source_uri and section

LLM parameter decisions

Prompting traps

RAG, fine-tuning, or prompting?

    flowchart TD
	    A[Need better GenAI behavior] --> B{Is the issue missing or changing knowledge?}
	    B -->|Yes| C[Use RAG]
	    B -->|No| D{Is the issue output style, format, or task pattern?}
	    D -->|Simple| E[Prompt engineering]
	    D -->|Persistent pattern with examples| F[Fine-tuning]
	    C --> G{Need governed enterprise data?}
	    G -->|Yes| H[Unity Catalog + Delta + Vector Search]
	    G -->|No| I[External source with governed ingestion]

Databricks implementation patterns

Vector Search query pattern

from databricks.vector_search.client import VectorSearchClient

vsc = VectorSearchClient()

index = vsc.get_index(
    endpoint_name="vector_search_endpoint",
    index_name="catalog.schema.chunk_index"
)

results = index.similarity_search(
    query_text="How do I request access to the finance dashboard?",
    columns=["chunk_id", "chunk_text", "source_uri", "section"],
    num_results=5
)

Exam points:

• Use query_text when the index manages query embedding.
• Use a query vector only when you are managing embeddings yourself.
• Return source metadata needed for citations.
• Apply filters when user role, document type, date, or product scope matters.

Minimal retrieval formatting pattern

def format_docs(docs):
    return "\n\n".join(
        f"Source: {d.get('source_uri')} | Section: {d.get('section')}\n{d.get('chunk_text')}"
        for d in docs
    )

Exam points:

• Do not pass raw objects to the prompt if the model needs readable context.
• Include metadata for traceability.
• Keep formatting consistent for evaluation.

LangChain-style RAG chain pattern

from operator import itemgetter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda, RunnablePassthrough

prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer only from the provided context. Cite sources. If unsupported, say you do not know."),
    ("user", "Question: {question}\n\nContext:\n{context}")
])

rag_chain = (
    {
        "question": itemgetter("question"),
        "context": itemgetter("question") | RunnableLambda(retrieve) | RunnableLambda(format_docs),
    }
    | prompt
    | chat_model
    | StrOutputParser()
)

Exam points:

• itemgetter("question") extracts the user input field.
• Retrieval should happen before prompt construction.
• Output parsing should match the expected serving response.
• Package custom functions, dependencies, and configuration before serving.

Model Serving call pattern

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DATABRICKS_TOKEN"],
    base_url=f"{os.environ['DATABRICKS_HOST']}/serving-endpoints"
)

response = client.chat.completions.create(
    model="serving-endpoint-name",
    messages=[
        {"role": "system", "content": "Answer using only the provided context."},
        {"role": "user", "content": "Question and context go here."}
    ],
    temperature=0.1
)

Exam points:

• Treat the serving endpoint name as the model target.
• Do not hardcode tokens in notebooks, chains, or app code.
• Keep parameters aligned with the endpoint and provider capabilities.
• Use deterministic settings for evaluation where practical.

MLflow packaging pattern

import mlflow

mlflow.set_registry_uri("databricks-uc")

with mlflow.start_run():
    mlflow.log_param("retriever_top_k", 5)
    mlflow.log_param("prompt_version", "rag_prompt_v3")
    mlflow.log_metric("eval_groundedness", 0.87)

    # Log the chain/model with its dependencies and input example.
    # Register to Unity Catalog for governed deployment.

Exam points:

• Track prompt version, model endpoint, retriever config, chunking config, and evaluation dataset.
• Register production artifacts in Unity Catalog when governance is required.
• Include input examples and signatures so serving can validate requests.
• Logging the notebook alone is not enough for reproducible deployment.

Unity Catalog and governance reference

Security and privacy checklist

• Use least privilege for data, indexes, models, functions, and serving endpoints.
• Keep user identity and authorization in mind for retrieval filtering.
• Do not allow a user to retrieve chunks they could not access directly.
• Store sensitive prompts/responses only when logging policy allows it.
• Redact or avoid collecting sensitive data in evaluation datasets when possible.
• Use service principals or supported machine credentials for production jobs.
• Keep credentials out of prompt templates, notebooks, source code, and MLflow params.
• Validate model outputs before using them in downstream systems.
• Treat user input and retrieved context as untrusted text.

Prompt injection and tool safety

Safer tool-calling principles

Evaluation quick reference

RAG evaluation metrics

Evaluation dataset design

Offline vs online evaluation

LLM-as-judge traps

Deployment and production readiness

Serving readiness checklist

Batch vs real-time GenAI

Troubleshooting reference

Common exam traps

Fast review checklist

Before exam day, be able to explain:

• When to choose RAG, prompt engineering, fine-tuning, or a different model.
• How Delta tables, chunks, embeddings, and Vector Search indexes fit together.
• Why chunk metadata is essential for citations, filtering, refresh, and debugging.
• The difference between Delta Sync and Direct Vector Access indexes.
• How to build a grounded prompt with refusal behavior.
• How temperature, top-k, chunk size, and max tokens affect quality and latency.
• How MLflow supports tracking, evaluation, packaging, and deployment.
• How Unity Catalog governs data, models, indexes, and functions.
• How to evaluate answer correctness, groundedness, context relevance, and safety.
• How to troubleshoot serving failures, bad retrieval, hallucinations, and stale answers.

Practical next step

Use this Quick Reference as a final checklist, then practice with scenario-based questions that force you to choose the right Databricks service, RAG design, evaluation method, governance control, or deployment fix under exam-style constraints.