Free Databricks-Generative-AI-Engineer-Associate Actual Exam Questions - Question 12 Discussion
questions about specific showtimes for movies currently playing at their local theater. They already
have the location of the user provided by location services to their agent, and a Delta table which is
continually updated with the latest showtime information by location. They want to implement this
new capability In their RAG application.
Which option will do this with the least effort and in the most performant way?
C imo, embedding the Delta table content into a vector index seems like overkill for this use case. Showtimes are structured data, so turning them into text and embeddings just adds unnecessary complexity and potential latency. Also, vector search might not guarantee up-to-date info if the embeddings aren’t refreshed frequently.
D could add extra overhead maintaining another database, which seems unnecessary given the Delta table is already being updated continuously. Direct access or a feature store seems more straightforward if performance holds up.
B/D? B feels most direct and avoids extra syncing or embedding delays.
B seems simplest since it avoids syncing issues and extra infrastructure. Direct SQL queries should give fresh showtimes instantly without embedding or external DB delays.
B/D? Querying the Delta table directly with text-to-SQL (B) seems straightforward and real-time, so no lag from syncing or embedding updates. Plus, it avoids extra overhead of maintaining an external DB like in D. On the other hand, D’s external DB could add complexity and delay because you’d rely on periodic writes, which might not be ideal if showtimes change often during the day. So from a performance and freshness perspective, B looks better unless the SQL queries get too complex or the LLM fails to parse them well.
Maybe A makes the most sense here since Feature Serving Endpoints are built for fast, low-latency querying and sync nicely with Delta tables. This should avoid delays or inconsistencies that might happen if you rely on text-to-SQL translations in B, which can be hit or miss depending on how users phrase their questions. Plus, it keeps everything within the Databricks ecosystem, so less chance of extra overhead or data staleness compared to D’s external database sync. C feels more complex and likely slower since embedding an entire Delta table into vectors seems like overkill for straightforwar
Maybe B is best here since it avoids extra infrastructure and directly queries fresh data. While text-to-SQL might fail sometimes, it's probably the quickest to implement and keeps performance high with Delta’s native SQL support.
A. Using a Feature Serving Endpoint seems like the cleanest approach since it’s designed for low-latency access and syncs directly with the Delta table’s online store. This avoids the complexity and potential inaccuracies of text-to-SQL parsing in B or the overhead of embeddings in C. Plus, it’s more efficient than continually moving data out to MySQL as in D. It’s a bit more setup initially but should pay off with better performance and simpler query logic during runtime.
C imo is interesting because using embeddings can make the retrieval really flexible and handle natural language queries better than strict SQL, especially if the user asks in varied ways. It might add some overhead to keep the embeddings updated, but since the showtimes data is continually updated, it could still stay fresh enough. Also, it avoids depending on the accuracy of a text-to-SQL model or syncing complexities from other endpoints, making it a neat balance between performance and ease of use.
Maybe B makes the most sense since it skips extra syncing or embedding steps and just queries the Delta table directly, which should be faster and simpler to maintain.
B, not A seems simpler and more direct with the text-to-SQL approach for query flexibility.