4.20 Select Embedding Context Length

Embedding context length must cover the maximum chunk size.

If chunks are at most 512 tokens and cost and latency matter, select the smallest embedding configuration that supports at least 512 tokens.

Avoid

• Silent truncation
• Oversized context windows with no retrieval benefit
• Choosing based on the generation model’s parameter count

Memory Rule

Embedding context must fit the chunk, not exceed it without a reason.

4.21 Use Model Cards and Metadata

Review:

• Intended task
• Context window
• Evaluation results
• License
• Deployment restrictions
• Architecture
• Size
• Performance tradeoffs

Exam Trap

A higher benchmark score does not override a license or deployment restriction.

4.22 Use MLflow Tracing During Development

MLflow tracing helps inspect:

• Agent spans
• Tool calls
• Tool inputs
• Tool errors
• Retriever calls
• Model calls
• Latency
• Output
• Execution sequence

Debugging Rule

If the wrong tool was called:

1. Inspect the tool-selection trace.
2. Review descriptions and schemas.
3. Refine routing logic.
4. Re-run failing cases.
5. Keep them in a regression suite.

4.23 Evaluation Versus Monitoring

Memory Rule

Evaluate before release. Monitor after release.

They complement each other. Neither replaces the other.

4.24 Use Genie Spaces in Multi-Agent Systems

For structured analytics questions:

• Route the request to an approved Genie Space or conversational API.
• Keep other tasks with their relevant specialist agents.
• Preserve governed access.

Avoid

• Embedding every database row in a prompt
• Giving all agents unrestricted database credentials
• Using a PDF retriever for structured analytics

Domain 4 — Assembling and Deploying Applications

4.25 Package with a pyfunc Model

A pyfunc wrapper can package:

• Preprocessing
• Retrieval logic
• Prompt assembly
• Model invocation
• Post-processing
• Output formatting

Why It Matters

The served behavior stays consistent across clients.

Exam Trap

Do not ask each client application to reproduce preprocessing independently. That creates drift.

4.26 Know the Core RAG Components

A deployable RAG application usually needs:

4.27 Register Models in Unity Catalog with MLflow

Use MLflow to log and register deployable models in Unity Catalog.

Benefits:

• Versioning
• Permissions
• Discoverability
• Lifecycle management
• Governance
• Controlled promotion

Exam Trap

A notebook in a shared folder is not a governed model registry.

4.28 Understand Mosaic AI Vector Search

Vector Search supports semantic retrieval using embeddings.

Core concepts:

Configuration Factors

Choose the index and endpoint configuration based on:

• Number of embeddings
• Update frequency
• Query rate
• Latency target
• Cost
• Accuracy requirements
• Metadata filtering requirements
• Whether reranking is justified

Exam Mindset

Do not turn on every feature automatically. Measure tradeoffs.

4.29 Use ai_query() for Batch Inference

Use ai_query() when many rows in a table need model inference or enrichment.

Suitable examples:

• Classify every support ticket.
• Summarize every incoming note.
• Extract a normalized field from each record.
• Generate enrichment columns in a reproducible pipeline.

Not suitable:

• Multi-turn interactive conversations
• Dynamic tool-using agents
• User-facing real-time assistants

Memory Rule

Rows in a table = consider ai_query(). Live conversation = served agent.

4.30 Serve Applications Securely

Model Serving endpoints should use:

• Governed identities
• Least-privilege permissions
• Secure backend calls
• Usage monitoring
• Appropriate rate limits
• No browser-exposed long-lived credentials

Avoid

• Personal access tokens in JavaScript
• Credentials in prompts
• Public endpoints protected only by an obscure URL
• Broad workspace-admin permissions

4.31 Use Foundation Model APIs Appropriately

Foundation Model APIs provide access to supported models for application inference.

Typical production pattern:

1. A user interacts with an application.
2. The authenticated backend receives the request.
3. The backend invokes a served chain or model workflow.
4. The workflow may call Foundation Model APIs.
5. The endpoint logs usage and response behavior.

4.32 Store Agent Memory Persistently

Use a governed persistent datastore for:

• Intermediate state
• Conversation summaries
• Structured facts
• Workflow checkpoints
• User-authorized memory

Retrieve only relevant state for the current interaction.

Avoid

• Keeping state only in process memory
• Appending all history forever
• Browser local storage as the system of record
• Duplicating every prior tool result in every prompt

Memory Rule

Persist selectively. Retrieve minimally.

4.33 Apply CI/CD to Agents

A production release may include:

• Application code
• Tool definitions
• Model version
• Prompt version
• Retrieval source schema
• Vector Search index
• Datastore schema
• Evaluation dataset
• Monitoring configuration

Strong CI/CD Pattern

1. Test components independently.
2. Validate prompts in development.
3. Run automated tests in staging.
4. Refresh dependent indexes when sources change.
5. Promote only approved versions.
6. Use aliases for controlled activation.
7. Preserve rollback.

Exam Trap

Deploying new code while leaving a stale index can break the application even if the code itself is correct.

4.34 Use Prompt Registry Versions and Aliases

MLflow Prompt Registry supports prompt lifecycle management.

Use:

• Versioned prompts
• Evaluation before promotion
• Aliases such as approved production pointers
• Rollback to prior versions
• History preservation

Memory Rule

Version the prompt. Promote the alias. Roll back the alias.

Exam Trap

Overwriting one production prompt file destroys traceability and rollback capability.

4.35 Select MCP Integration Patterns

MCP servers expose tools and resources to agents.

Managed MCP Examples

Managed MCP capabilities may support approved Databricks resources such as:

• AI Search or Vector Search-related retrieval
• Genie Spaces
• Unity Catalog functions

Exam Trap

Do not build a custom server before checking for a managed option.
Do not place external API keys in prompts.

4.36 Build User-Facing Interfaces

Possible interfaces include:

• Databricks Apps
• Slack
• Teams
• Other authenticated applications

Recommended architecture:

User Interface
      |
Authenticated Backend
      |
Served Agent or Chain Endpoint
      |
Governed Tools, Data, Models, and Logs

Memory Rule

The browser is not a secrets vault.

Domain 5 — Governance

4.37 Mask and Minimize Sensitive Data

Send only what the model needs.

Use:

• Masking
• Redaction
• Field selection
• Tokenization or pseudonymization where appropriate
• Authorization-aware retrieval filters
• Least-privilege resource permissions

Example

If a model only needs the order category and status, do not include:

• Full name
• Street address
• Full account record
• Payment details

Exam Trap

A prompt that says “do not reveal sensitive data” is weaker than removing or masking sensitive fields before the model receives them.

4.38 Govern Tools with Least Privilege

Each tool should have only the permissions required for its task.

Examples:

• Read-only shipment lookup
• Restricted catalog search
• Approved Genie Space access
• Scoped Unity Catalog permissions

Avoid:

• Shared admin tokens
• Unrestricted table access
• User-pasted credentials
• Broad permissions added merely to avoid errors

4.39 Review Data Source Licensing

Before ingesting external content, verify that the intended use is allowed.

Review:

• Ingestion rights
• Transformation rights
• Retrieval rights
• Application use
• Redistribution constraints
• Commercial usage constraints

Memory Rule

Publicly reachable does not mean licensed for reuse.

4.40 Remediate Problematic Source Text

When a source contains harmful, misleading, obsolete, or injection-like text:

1. Identify the passage.
2. Quarantine, redact, replace, or annotate it.
3. Exclude unsafe content from retrieval.
4. Preserve source lineage and remediation status.
5. Refresh the index.
6. Re-run retrieval and safety evaluation.

Exam Trap

Increasing overlap makes problematic content appear in more chunks. It amplifies the issue.

Domain 6 — Evaluation and Monitoring

4.41 Build a Complete Evaluation Strategy

A strong evaluation plan covers:

• Correctness
• Groundedness
• Retrieval relevance
• Safety
• Tool selection
• Tool-call validity
• Latency
• Throughput
• Error rate
• Cost
• User experience

4.42 Use MLflow Scorers and Traces Together

Memory Rule

Scorers tell you whether it failed. Traces tell you where it failed.

4.43 Use Inference Tables

Inference tables capture deployed requests and responses in governed Delta tables.

Use them to:

• Investigate hallucinations
• Analyze bad prompts
• Compare versions
• Track latency
• Review production failures
• Build regression datasets
• Support auditing

Exam Trap

Uptime is not enough. A service can be available while returning poor answers.

4.44 Use Agent Monitoring

Agent Monitoring helps track live agent behavior.

Monitor:

• Tool routing
• Tool errors
• Latency
• Response quality
• Safety
• Usage
• Cost
• Regression patterns

A routing-quality review may require sampling traces and scoring whether the correct specialist or tool was selected.

4.45 Use AI Gateway

AI Gateway helps govern and observe model or agent endpoint use.

Important capabilities include:

• Inference tables
• Usage tables
• Rate limiting
• Tracking endpoint consumption

Good Uses

• Detect cost spikes
• Apply enforceable request limits
• Review usage by identity or endpoint
• Analyze request patterns
• Support production governance

Exam Trap

Client-side JavaScript throttling can be bypassed. Rate limits belong at the governed serving layer.

4.46 Choose Metrics for the Scenario

Exam Trap

Do not monitor only response length, UI visits, or infrastructure utilization when the question asks about answer quality.

4.47 Use Ground-Truth and Reference-Free Judges Correctly

Memory Rule

No reliable reference = do not pretend you have ground truth.

4.48 Create Custom Scorers

Use a custom scorer when built-in metrics do not cover a required domain rule.

Examples:

• Required disclaimer present
• Approved source citation included
• Tool-routing decision correct
• Output schema satisfied
• Regulated phrase avoided
• Domain-specific completeness score

A custom scorer should be:

• Repeatable
• Documented
• Versioned
• Tested
• Applied consistently

4.49 Incorporate SME Feedback

Subject-matter experts add domain judgment, but feedback must be calibrated.

Strong workflow:

1. Define a rubric.
2. Review representative examples.
3. Calibrate reviewers.
4. Analyze disagreements.
5. Improve the rubric.
6. Combine SME judgment with automated scorers.
7. Keep difficult cases in the evaluation suite.

Exam Trap

Discarding disputed examples hides valuable edge cases.

4.50 Control Cost

Use:

• Smaller models when quality thresholds are met
• Prompt compression
• Relevant-context retrieval
• Bounded memory
• Rate limits
• Usage tables
• Inference tables
• Monitoring
• Batch processing where appropriate
• Right-sized embedding and generation models

Cost-Spike Investigation

1. Inspect usage.
2. Inspect prompt size.
3. Inspect retrieved context size.
4. Inspect request volume.
5. Inspect model selection.
6. Apply rate limits or optimize context.
7. Compare cost after the change.

5. Service Selection Guide

Databricks Service and Feature Map

6. Architecture Patterns

Pattern 1: Standard Governed RAG Application

Documents
   |
Extraction and Cleaning
   |
Structure-Aware Chunking
   |
Delta Tables in Unity Catalog
   |
Vector Search Index
   |
Retriever + Metadata Filters + Optional Reranking
   |
Prompt Assembly
   |
LLM or Foundation Model API
   |
Output Validation
   |
Model Serving Endpoint
   |
Inference Tables + Tracing + Monitoring

Use when:

• Answers come from enterprise knowledge.
• Citations and grounding matter.
• Content is mostly static or periodically refreshed.

Pattern 2: Static Policy Plus Live Operational Lookup

User Question
   |
Intent and Identifier Extraction
   |
+---------------------------+
|                           |
Policy Retriever        Live Status Tool
|                           |
+-------------+-------------+
              |
        Grounded Response

Use when:

• Some answers come from documents.
• Some facts change frequently.
• Account- or transaction-specific status is required.

Memory rule:

Use RAG for policy; use tools for live facts.

Pattern 3: Multi-Agent Supervisor

User Request
     |
Supervisor Agent
     |
+------------+-------------+----------------+
|            |             |                |
Knowledge   Genie Space   Operational Tool   Custom MCP Tool
Agent       Specialist    Specialist         Specialist
     |
Synthesis and Validation

Use when:

• Requests span several domains.
• Different tools need different permissions.
• Specialist routing is required.

Avoid when:

• A deterministic chain is enough.

Pattern 4: Batch Inference with ai_query()

Delta Table Rows
      |
SQL or Python Pipeline
      |
ai_query()
      |
Enriched Output Columns
      |
Governed Delta Table

Use when:

• Many records need repeatable enrichment.
• The workload is not conversational.

Pattern 5: Prompt Lifecycle and CI/CD

Prompt Draft
   |
Prompt Registry Version
   |
Offline Evaluation
   |
Staging Tests
   |
Approval Gate
   |
Production Alias Update
   |
Monitoring
   |
Rollback Alias if Needed

Use when:

• Prompts change over time.
• Rollback and audit history matter.

Pattern 6: Secure User-Facing Agent

Slack, Teams, or Databricks App
             |
Authenticated Backend
             |
Serving Endpoint
             |
Governed Tools and Data
             |
AI Gateway + Inference Tables + Tracing

Avoid:

• Browser tokens
• Prompt-embedded credentials
• Public data copies
• Shared admin credentials

7. Exam Traps

Retrieval and Data Traps

Model and Prompt Traps

Agent and Tool Traps

Deployment Traps

Monitoring Traps

8. Quick Memory Rules

Memorize these lines.

1. Retrieve before generate. Validate after generate.
2. Live fact = live lookup. Static policy = RAG.
3. Too many vector records = bigger chunks and less overlap.
4. Scanned image text = OCR = pytesseract.
5. HTML text extraction = Beautiful Soup.
6. Small child chunks match; large parent chunks provide context.
7. Reranking happens after retrieval.
8. A missing-evidence problem is not solved by a larger LLM.
9. Use the smallest model that meets the measured quality target.
10. Embedding context length must fit chunk size.
11. Retrieved text is evidence, never authority.
12. Resolve identifiers before dependent tool calls.
13. Validate tool arguments before execution.
14. Fixed flow = chain. Dynamic tool routing = agent.
15. Document Q&A = Knowledge Assistant.
16. Structured extraction = Information Extraction.
17. Specialist coordination = Multiagent Supervisor.
18. Rows in a table = consider ai_query().
19. Interactive conversation = served agent or chain.
20. Version the prompt. Promote the alias. Roll back the alias.
21. Managed MCP first; external MCP when published; custom MCP only when needed.
22. The browser is not a secrets vault.
23. Evaluate before release. Monitor after release.
24. Scorers tell you whether it failed. Traces tell you where it failed.
25. Publicly reachable does not mean licensed for reuse.
26. Persist memory selectively. Retrieve minimally.
27. A stale Vector Search index can break a correct application release.
28. Use AI Gateway for usage visibility and enforceable rate limits.
29. No reliable reference = do not pretend you have ground truth.
30. Keep difficult SME disagreements; they reveal edge cases.

9. Final Revision Notes

Highest-Priority Review Topics

Spend the most revision time on:

1. Application Development
2. Assembling and Deploying Applications
3. Data Preparation
4. Design Applications
5. Evaluation and Monitoring
6. Governance

Last-Hour Service Comparisons

Chain Versus Agent

Knowledge Assistant Versus Information Extraction

Vector Search Versus ai_query()

Inference Tables Versus MLflow Traces

Prompt Registry Versus Hard-Coded Prompts

Managed Versus External Versus Custom MCP

How to Eliminate Wrong Answers Quickly

When reading a scenario:

1. Identify the required fact: static, dynamic, or derived.
2. Identify the workload: interactive, batch, retrieval, extraction, or multi-agent.
3. Identify the strongest constraint: latency, cost, governance, freshness, rollback, or quality.
4. Eliminate answers that:
   • Guess live facts
   • Expose credentials
   • Grant broad permissions
   • Skip evaluation
   • Skip source cleaning
   • Ignore index refresh
   • Overwrite versions
   • Use an unnecessarily complex architecture
5. Choose the simplest governed solution that satisfies the stated constraint.

10. Exam-Day Checklist

Before the Exam

• Re-check the current official exam guide two weeks before the exam.
• Confirm the exam format and technical requirements.
• Review the six domain weights.
• Memorize the quick memory rules.
• Practice identifying the strongest constraint in each scenario.
• Review multiple-selection questions carefully: select every required action and no extras.

During the Exam

• Read the final sentence first: identify exactly what the question asks.
• Note words such as:
  • MOST appropriate
  • FIRST
  • TWO actions
  • lowest latency
  • least maintenance
  • preserve rollback
  • authoritative
  • current
  • governed
• Eliminate answers that:
  • Depend on guesses
  • Use stale data for live facts
  • Put secrets in prompts or browsers
  • Bypass Unity Catalog governance
  • Replace measurement with assumptions
  • Add complexity without a requirement
• For multi-select questions, verify that each chosen action independently addresses the scenario.
• Do not spend too long on one question. Mark uncertain items and return later.
• Reserve time to review questions involving:
  • Chunk size and overlap
  • Vector Search configuration
  • Prompt lifecycle aliases
  • MCP selection
  • Tool-call validation
  • Inference tables and AI Gateway
  • Ground-truth judges
  • SME feedback

Final Confidence Check

Before submitting, ask:

1. Did I choose the authoritative source?
2. Did I retrieve before generating?
3. Did I choose a live lookup for live data?
4. Did I respect least privilege?
5. Did I protect secrets?
6. Did I consider latency, cost, and quality tradeoffs?
7. Did I preserve versioning and rollback?
8. Did I choose evaluation before release and monitoring after release?
9. Did I choose the simplest production-ready architecture?
10. Did I follow the exact wording of the question?

Appendix A — One-Page Rapid Review

Appendix B — Official Reference Links

• Databricks Certified Generative AI Engineer Associate certification page
• Databricks Certified Generative AI Engineer Associate Exam Guide — March 2026

End of course