Pass Your Next Databricks-Generative-AI-Engineer-Associate Certification Exam Easily & Hassle Free [Q43-Q67]

Rate this post

Pass Your Next Databricks-Generative-AI-Engineer-Associate Certification Exam Easily & Hassle Free

Free Databricks Databricks-Generative-AI-Engineer-Associate Exam Question Practice Exams

Databricks Databricks-Generative-AI-Engineer-Associate Exam Overview:

Certification Vendor:	Databricks
Exam Name:	Databricks Certified Generative AI Engineer Associate
Exam Number:	Databricks-Generative-AI-Engineer-Associate
Real Exam Qty:	45-60
Certificate Validity Period:	2 years
Exam Duration:	90 minutes
Exam Format:	Multiple select, Multiple choice
Available Languages:	English
Related Certifications:	Databricks Certified Data Engineer Associate Databricks Certified Machine Learning Associate
Exam Price:	USD 200
Recommended Training:	Databricks Academy – Generative AI Courses Mosaic AI Documentation
Exam Registration:	Databricks Certification Portal
Sample Questions:	Databricks Databricks-Generative-AI-Engineer-Associate Sample Questions
Exam Way:	Online proctored exam
Pre Condition:	No strict prerequisites, but experience with Python, machine learning fundamentals, and Databricks platform is recommended.
Official Syllabus URL:	https://www.databricks.com/learn/certification

QUESTION 43
A Generative Al Engineer needs to design an LLM pipeline to conduct multi-stage reasoning that leverages external tools. To be effective at this, the LLM will need to plan and adapt actions while performing complex reasoning tasks.
Which approach will do this?

Implement a framework like ReAct which allows the LLM to generate reasoning traces and perform task-specific actions that leverage external tools if necessary.

Use a Chain-of-Thought (CoT) prompting technique to guide the LLM through a series of reasoning steps, then manually input the results from external tools for the final answer.

Encourage the LLM to make multiple API calls in sequence without planning or structuring the calls, allowing the LLM to decide when and how to use external tools spontaneously.

Tram the LLM to generate a single, comprehensive response without interacting with any external tools, relying solely on its pre-trained knowledge.

QUESTION 44
A Generative AI Engineer has a provisioned throughput model serving endpoint as part of a RAG application and would like to monitor the serving endpoint’s incoming requests and outgoing responses. The current approach is to include a micro-service in between the endpoint and the user interface to write logs to a remote server.
Which Databricks feature should they use instead which will perform the same task?

Vector Search

Lakeview

DBSQL

Inference Tables

QUESTION 45
A Generative AI Engineer is building a compound AI system for an organization. The goal is to automate the processing of incoming customer event reports against a coding system and corporate-guidelines documentation. The system must handle three distinct user-request types: answering questions from guidelines documents, extracting specific event codes from reviewers’ notes, and routing ambiguous requests to the appropriate specialized handler. All three capabilities must operate under a single entry point that interprets user intent and delegates accordingly.
Which Agent Brick should serve as the top-level orchestrator in this architecture?

Multi-Agent Supervisor, because it can be used without Knowledge Assistant and Information Extraction agents.

Knowledge Assistant, because the chatbot interface can handle multi-turn conversations.

Knowledge Assistant, because it can be configured with multiple vector indexes to handle all three request types simultaneously.

Multi-Agent Supervisor, because it interprets incoming requests and delegates tasks to specialized sub- agents.

QUESTION 46
A Generative Al Engineer is creating an LLM-based application. The documents for its retriever have been chunked to a maximum of 512 tokens each. The Generative Al Engineer knows that cost and latency are more important than quality for this application. They have several context length levels to choose from.
Which will fulfill their need?

context length 514; smallest model is 0.44GB and embedding dimension 768

context length 2048: smallest model is 11GB and embedding dimension 2560

context length 32768: smallest model is 14GB and embedding dimension 4096

context length 512: smallest model is 0.13GB and embedding dimension 384

QUESTION 47
A Generative AI Engineer is deploying an agent using Mosaic AI Model Serving. The agent needs to access various Databricks resources, including Vector Search, Databricks SQL, and Functions. They need to find the easiest and best-practice way to authenticate the deployed agent to access these resources.
What approach should they choose?

Log the authentication token while logging the agent; this token will be automatically used for authentication.

Set appropriate permissions on the Model Serving endpoint for the agent, as these permissions will be used when connecting to other resources.

Embed authentication credentials within the agent’s code to access the required resources.

Define resource dependencies while logging the agent and deploy it with the Agent Framework.

QUESTION 48
A Generative AI Engineer is experimenting with using parameters to configure an agent in Mosaic Agent Framework. However, they are struggling to get the agent to respond with relevant information with this configuration:
config = {“prompt_template”: “You are a trivia bot. Generate a question based on the user’s input: {user_input}”, “input_vars”: [“user_input”], “parameters”: {“temperature”: 0.01, “max_tokens”: 500}} Which error is causing the problem?

The prompt does not parse the user’s input vars

The prompt does not set the retriever schema

The prompt does not list available agents for the LLM to call

The prompt is not wrapped in ChatModel

QUESTION 49
A Generative AI Engineer is developing a patient-facing healthcare-focused chatbot. If the patient’s question is not a medical emergency, the chatbot should solicit more information from the patient to pass to the doctor’ s office and suggest a few relevant pre-approved medical articles for reading. If the patient’s question is urgent, direct the patient to calling their local emergency services.
Given the following user input:
“I have been experiencing severe headaches and dizziness for the past two days.” Which response is most appropriate for the chatbot to generate?

Here are a few relevant articles for your browsing. Let me know if you have questions after reading them.

Please call your local emergency services.

Headaches can be tough. Hope you feel better soon!

Please provide your age, recent activities, and any other symptoms you have noticed along with your headaches and dizziness.

QUESTION 50
A Generative Al Engineer is deciding between using LSH (Locality Sensitive Hashing) and HNSW (Hierarchical Navigable Small World) for indexing their vector database Their top priority is semantic accuracy Which approach should the Generative Al Engineer use to evaluate these two techniques?

Compare the cosine similarities of the embeddings of returned results against those of a representative sample of test inputs

Compare the Bilingual Evaluation Understudy (BLEU) scores of returned results for a representative sample of test inputs

Compare the Recall-Onented-Understudy for Gistmg Evaluation (ROUGE) scores of returned results for a representative sample of test inputs

Compare the Levenshtein distances of returned results against a representative sample of test inputs

The task is to choose between LSH and HNSW for a vector database index, prioritizing semantic accuracy. The evaluation must assess how well each method retrieves semantically relevant results. Let’s evaluate the options.
Option A: Compare the cosine similarities of the embeddings of returned results against those of a representative sample of test inputs Cosine similarity measures semantic closeness between vectors, directly assessing retrieval accuracy in a vector database. Comparing returned results’ embeddings to test inputs’ embeddings evaluates how well LSH or HNSW preserves semantic relationships, aligning with the priority.
Databricks Reference: “Cosine similarity is a standard metric for evaluating vector search accuracy” (“Databricks Vector Search Documentation,” 2023).
Option B: Compare the Bilingual Evaluation Understudy (BLEU) scores of returned results for a representative sample of test inputs BLEU evaluates text generation (e.g., translations), not vector retrieval accuracy. It’s irrelevant for indexing performance.
Databricks Reference: “BLEU applies to generative tasks, not retrieval” (“Generative AI Cookbook”).
Option C: Compare the Recall-Oriented-Understudy for Gisting Evaluation (ROUGE) scores of returned results for a representative sample of test inputs ROUGE is for summarization evaluation, not vector search. It doesn’t measure semantic accuracy in retrieval.
Databricks Reference: “ROUGE is unsuited for vector database evaluation” (“Building LLM Applications with Databricks”).
Option D: Compare the Levenshtein distances of returned results against a representative sample of test inputs Levenshtein distance measures string edit distance, not semantic similarity in embeddings. It’s inappropriate for vector-based retrieval.
Databricks Reference: No specific support for Levenshtein in vector search contexts.
Conclusion: Option A (cosine similarity) is the correct approach, directly evaluating semantic accuracy in vector retrieval, as recommended by Databricks for Vector Search assessments.

QUESTION 51
A Generative AI Engineer is designing a RAG application for answering user questions on technical regulations as they learn a new sport.
What are the steps needed to build this RAG application and deploy it?

Ingest documents from a source – > Index the documents and saves to Vector Search – > User submits queries against an LLM – > LLM retrieves relevant documents – > Evaluate model – > LLM generates a response – > Deploy it using Model Serving

Ingest documents from a source – > Index the documents and save to Vector Search – > User submits queries against an LLM – > LLM retrieves relevant documents – > LLM generates a response – > Evaluate model – > Deploy it using Model Serving

Ingest documents from a source – > Index the documents and save to Vector Search – > Evaluate model
– > Deploy it using Model Serving

User submits queries against an LLM – > Ingest documents from a source – > Index the documents and save to Vector Search – > LLM retrieves relevant documents – > LLM generates a response – > Evaluate model – > Deploy it using Model Serving

QUESTION 52
A Generative AI Engineer is building a Databricks-hosted assistant that must (1) query Unity Catalog tables with row and column permissions enforced, and (2) avoid managing any external infrastructure. The team wants the LLM to use governed data access through tools exposed via MCP.
Which MCP server choice meets these constraints?

Use a managed Databricks MCP server integrated with Unity Catalog.

Use an external community MCP server for SQL and pass Unity Catalog tokens in prompts.

Run a custom MCP server on a self-managed VM that proxies the Unity Catalog API.

Expose JDBC directly to the model and enforce permissions in application code.

QUESTION 53
A Generative Al Engineer needs to design an LLM pipeline to conduct multi-stage reasoning that leverages external tools. To be effective at this, the LLM will need to plan and adapt actions while performing complex reasoning tasks.
Which approach will do this?

Tram the LLM to generate a single, comprehensive response without interacting with any external tools, relying solely on its pre-trained knowledge.

Implement a framework like ReAct which allows the LLM to generate reasoning traces and perform task-specific actions that leverage external tools if necessary.

Encourage the LLM to make multiple API calls in sequence without planning or structuring the calls, allowing the LLM to decide when and how to use external tools spontaneously.

Use a Chain-of-Thought (CoT) prompting technique to guide the LLM through a series of reasoning steps, then manually input the results from external tools for the final answer.

The task requires an LLM pipeline for multi-stage reasoning with external tools, necessitating planning, adaptability, and complex reasoning. Let’s evaluate the options based on Databricks’ recommendations for advanced LLM workflows.
Option A: Train the LLM to generate a single, comprehensive response without interacting with any external tools, relying solely on its pre-trained knowledge This approach limits the LLM to its static knowledge base, excluding external tools and multi-stage reasoning. It can’t adapt or plan actions dynamically, failing the requirements.
Databricks Reference: “External tools enhance LLM capabilities beyond pre-trained knowledge” (“Building LLM Applications with Databricks,” 2023).
Option B: Implement a framework like ReAct which allows the LLM to generate reasoning traces and perform task-specific actions that leverage external tools if necessary ReAct (Reasoning + Acting) combines reasoning traces (step-by-step logic) with actions (e.g., tool calls), enabling the LLM to plan, adapt, and execute complex tasks iteratively. This meets all requirements: multi-stage reasoning, tool use, and adaptability.
Databricks Reference: “Frameworks like ReAct enable LLMs to interleave reasoning and external tool interactions for complex problem-solving” (“Generative AI Cookbook,” 2023).
Option C: Encourage the LLM to make multiple API calls in sequence without planning or structuring the calls, allowing the LLM to decide when and how to use external tools spontaneously Unstructured, spontaneous API calls lack planning and may lead to inefficient or incorrect tool usage. This doesn’t ensure effective multi-stage reasoning or adaptability.
Databricks Reference: Structured frameworks are preferred: “Ad-hoc tool calls can reduce reliability in complex tasks” (“Building LLM-Powered Applications”).
Option D: Use a Chain-of-Thought (CoT) prompting technique to guide the LLM through a series of reasoning steps, then manually input the results from external tools for the final answer CoT improves reasoning but relies on manual tool interaction, breaking automation and adaptability. It’s not a scalable pipeline solution.
Databricks Reference: “Manual intervention is impractical for production LLM pipelines” (“Databricks Generative AI Engineer Guide”).
Conclusion: Option B (ReAct) is the best approach, as it integrates reasoning and tool use in a structured, adaptive framework, aligning with Databricks’ guidance for complex LLM workflows.

QUESTION 54
A team uses Mosaic AI Vector Search to retrieve documents for their Retrieval-Augmented Generation (RAG) pipeline. The search query returns five relevant documents, and the first three are added to the prompt as context. Performance evaluation with Agent Evaluation shows that some lower-ranked retrieved documents have higher context relevancy scores than higher-ranked documents. Which option should the team consider to optimize this workflow?

Use a reranker to order the documents based on the relevance scores.

Modify the prompt to instruct the LLM to order the documents based on the relevance scores.

Use a different embedding model for computing document embeddings.

Increase the number of documents added to the prompt to improve context relevance.

QUESTION 55
A Generative AI Engineer is deploying an agent using Mosaic AI Model Serving. The agent needs to access various Databricks resources, including Vector Search, Databricks SQL, and Functions. They need to find the easiest and best-practice way to authenticate the deployed agent to access these resources.
What approach should they choose?

Embed authentication credentials within the agent’s code to access the required resources.

Log the authentication token while logging the agent; this token will be automatically used for authentication.

Set appropriate permissions on the Model Serving endpoint for the agent, as these permissions will be used when connecting to other resources.

Define resource dependencies while logging the agent and deploy it with the Agent Framework.

QUESTION 56
Databricks offers a number of built-in AI judges that provide metrics and rationale for different types of quality issues a Generative AI application may have.
Which of the following pairs of judges both require a ground-truth label in the evaluation dataset field expected_response to execute?

context_sufficiency, correctness.

correctness, groundedness.

guideline_adherence, chunk_relevance.

relevance_to_query, chunk_relevance.

QUESTION 57
A Generative AI Engineer is building a Generative AI system that suggests the best matched employee team member to newly scoped projects. The team member is selected from a very large team. The match should be based upon project date availability and how well their employee profile matches the project scope. Both the employee profile and project scope are unstructured text.
How should the Generative Al Engineer architect their system?

Create a tool for finding available team members given project dates. Embed all project scopes into a vector store, perform a retrieval using team member profiles to find the best team member.

Create a tool for finding team member availability given project dates, and another tool that uses an LLM to extract keywords from project scopes. Iterate through available team members’ profiles and perform keyword matching to find the best available team member.

Create a tool to find available team members given project dates. Create a second tool that can calculate a similarity score for a combination of team member profile and the project scope. Iterate through the team members and rank by best score to select a team member.

Create a tool for finding available team members given project dates. Embed team profiles into a vector store and use the project scope and filtering to perform retrieval to find the available best matched team members.

Problem Context: The problem involves matching team members to new projects based on two main factors:
Availability: Ensure the team members are available during the project dates.
Profile-Project Match: Use the employee profiles (unstructured text) to find the best match for a project’s scope (also unstructured text).
The two main inputs are the employee profiles and project scopes, both of which are unstructured. This means traditional rule-based systems (e.g., simple keyword matching) would be inefficient, especially when working with large datasets.
Explanation of Options: Let’s break down the provided options to understand why D is the most optimal answer.
Option A suggests embedding project scopes into a vector store and then performing retrieval using team member profiles. While embedding project scopes into a vector store is a valid technique, it skips an important detail: the focus should primarily be on embedding employee profiles because we’re matching the profiles to a new project, not the other way around.
Option B involves using a large language model (LLM) to extract keywords from the project scope and perform keyword matching on employee profiles. While LLMs can help with keyword extraction, this approach is too simplistic and doesn’t leverage advanced retrieval techniques like vector embeddings, which can handle the nuanced and rich semantics of unstructured data. This approach may miss out on subtle but important similarities.
Option C suggests calculating a similarity score between each team member’s profile and project scope. While this is a good idea, it doesn’t specify how to handle the unstructured nature of data efficiently. Iterating through each member’s profile individually could be computationally expensive in large teams. It also lacks the mention of using a vector store or an efficient retrieval mechanism.
Option D is the correct approach. Here’s why:
Embedding team profiles into a vector store: Using a vector store allows for efficient similarity searches on unstructured data. Embedding the team member profiles into vectors captures their semantics in a way that is far more flexible than keyword-based matching.
Using project scope for retrieval: Instead of matching keywords, this approach suggests using vector embeddings and similarity search algorithms (e.g., cosine similarity) to find the team members whose profiles most closely align with the project scope.
Filtering based on availability: Once the best-matched candidates are retrieved based on profile similarity, filtering them by availability ensures that the system provides a practically useful result.
This method efficiently handles large-scale datasets by leveraging vector embeddings and similarity search techniques, both of which are fundamental tools in Generative AI engineering for handling unstructured text.
Technical Reference:
Vector embeddings: In this approach, the unstructured text (employee profiles and project scopes) is converted into high-dimensional vectors using pretrained models (e.g., BERT, Sentence-BERT, or custom embeddings). These embeddings capture the semantic meaning of the text, making it easier to perform similarity-based retrieval.
Vector stores: Solutions like FAISS or Milvus allow storing and retrieving large numbers of vector embeddings quickly. This is critical when working with large teams where querying through individual profiles sequentially would be inefficient.
LLM Integration: Large language models can assist in generating embeddings for both employee profiles and project scopes. They can also assist in fine-tuning similarity measures, ensuring that the retrieval system captures the nuances of the text data.
Filtering: After retrieving the most similar profiles based on the project scope, filtering based on availability ensures that only team members who are free for the project are considered.
This system is scalable, efficient, and makes use of the latest techniques in Generative AI, such as vector embeddings and semantic search.

QUESTION 58
A Generative Al Engineer is deciding between using LSH (Locality Sensitive Hashing) and HNSW (Hierarchical Navigable Small World) for indexing their vector database Their top priority is semantic accuracy Which approach should the Generative Al Engineer use to evaluate these two techniques?

Compare the cosine similarities of the embeddings of returned results against those of a representative sample of test inputs

Compare the Recall-Onented-Understudy for Gistmg Evaluation (ROUGE) scores of returned results for a representative sample of test inputs

Compare the Bilingual Evaluation Understudy (BLEU) scores of returned results for a representative sample of test inputs

Compare the Levenshtein distances of returned results against a representative sample of test inputs

QUESTION 59
A Generative AI Engineer has been asked to build an LLM-based question-answering application. The application should take into account new documents that are frequently published. The engineer wants to build this application with the least cost and least development effort and have it operate at the lowest cost possible.
Which combination of chaining components and configuration meets these requirements?

For the application a prompt, a retriever, and an LLM are required. The retriever output is inserted into the prompt which is given to the LLM to generate answers.

The LLM needs to be frequently with the new documents in order to provide most up-to-date answers.

For the question-answering application, prompt engineering and an LLM are required to generate answers.

For the application a prompt, an agent and a fine-tuned LLM are required. The agent is used by the LLM to retrieve relevant content that is inserted into the prompt which is given to the LLM to generate answers.

QUESTION 60
A Generative AI Engineer is designing a chatbot for a gaming company that aims to engage users on its platform while its users play online video games.
Which metric would help them increase user engagement and retention for their platform?

Randomness

Diversity of responses

Lack of relevance

Repetition of responses

QUESTION 61
A Generative Al Engineer is ready to deploy an LLM application written using Foundation Model APIs. They want to follow security best practices for production scenarios Which authentication method should they choose?

Use an access token belonging to service principals

Use a frequently rotated access token belonging to either a workspace user or a service principal

Use OAuth machine-to-machine authentication

Use an access token belonging to any workspace user

The task is to deploy an LLM application using Foundation Model APIs in a production environment while adhering to security best practices. Authentication is critical for securing access to Databricks resources, such as the Foundation Model API. Let’s evaluate the options based on Databricks’ security guidelines for production scenarios.
* Option A: Use an access token belonging to service principals
* Service principals are non-human identities designed for automated workflows and applications in Databricks. Using an access token tied to a service principal ensures that the authentication is scoped to the application, follows least-privilege principles (via role-based access control), and avoids reliance on individual user credentials. This is a security best practice for production deployments.
* Databricks Reference:”For production applications, use service principals with access tokens to authenticate securely, avoiding user-specific credentials”(“Databricks Security Best Practices,”
2023). Additionally, the “Foundation Model API Documentation” states:”Service principal tokens are recommended for programmatic access to Foundation Model APIs.”
* Option B: Use a frequently rotated access token belonging to either a workspace user or a service principal
* Frequent rotation enhances security by limiting token exposure, but tying the token to a workspace user introduces risks (e.g., user account changes, broader permissions). Including both user and service principal options dilutes the focus on application-specific security, making this less ideal than a service-principal-only approach. It also adds operational overhead without clear benefits over Option A.
* Databricks Reference:”While token rotation is a good practice, service principals are preferred over user accounts for application authentication”(“Managing Tokens in Databricks,” 2023).
* Option C: Use OAuth machine-to-machine authentication
* OAuth M2M (e.g., client credentials flow) is a secure method for application-to-service communication, often using service principals under the hood. However, Databricks’ Foundation Model API primarily supports personal access tokens (PATs) or service principal tokens over full OAuth flows for simplicity in production setups. OAuth M2M adds complexity (e.g., managing refresh tokens) without a clear advantage in this context.
* Databricks Reference:”OAuth is supported in Databricks, but service principal tokens are simpler and sufficient for most API-based workloads”(“Databricks Authentication Guide,” 2023).
* Option D: Use an access token belonging to any workspace user
* Using a user’s access token ties the application to an individual’s identity, violating security best practices. It risks exposure if the user leaves, changes roles, or has overly broad permissions, and it’s not scalable or auditable for production.
* Databricks Reference:”Avoid using personal user tokens for production applications due to security and governance concerns”(“Databricks Security Best Practices,” 2023).
Conclusion: Option A is the best choice, as it uses a service principal’s access token, aligning with Databricks’ security best practices for production LLM applications. It ensures secure, application-specific authentication with minimal complexity, as explicitly recommended for Foundation Model API deployments.

QUESTION 62
Which of the following statements accurately identifies differences between the evaluation phase and the monitoring phase in the Generative AI application lifecycle within Databricks?

The evaluation phase uses Mosaic AI Agent Evaluation and an evaluation dataset to assess an agent’s performance metrics and traces, while the monitoring phase relies on inference tables as source data for creating a metrics profile.

The evaluation phase logs and traces live API calls in production, while the monitoring phase runs metrics on inference tables containing those traces.

The evaluation phase ensures the agent’s responses comply with business rules in production, whereas the monitoring phase is focused on SLA and performance metrics.

The evaluation phase uses all inference history to assess agent performance and readiness for production, while the monitoring phase uses only new inference-table records to monitor performance.

QUESTION 63
A Generative AI Engineer just deployed an LLM application at a digital marketing company that assists with answering customer service inquiries.
Which metric should they monitor for their customer service LLM application in production?

Number of customer inquiries processed per unit of time

Energy usage per query

Final perplexity scores for the training of the model

HuggingFace Leaderboard values for the base LLM

QUESTION 64
A Generative Al Engineer needs to design an LLM pipeline to conduct multi-stage reasoning that leverages external tools. To be effective at this, the LLM will need to plan and adapt actions while performing complex reasoning tasks.
Which approach will do this?

Tram the LLM to generate a single, comprehensive response without interacting with any external tools, relying solely on its pre-trained knowledge.

Implement a framework like ReAct which allows the LLM to generate reasoning traces and perform task-specific actions that leverage external tools if necessary.

Encourage the LLM to make multiple API calls in sequence without planning or structuring the calls, allowing the LLM to decide when and how to use external tools spontaneously.

Use a Chain-of-Thought (CoT) prompting technique to guide the LLM through a series of reasoning steps, then manually input the results from external tools for the final answer.

The task requires an LLM pipeline for multi-stage reasoning with external tools, necessitating planning, adaptability, and complex reasoning. Let’s evaluate the options based on Databricks’ recommendations for advanced LLM workflows.
* Option A: Train the LLM to generate a single, comprehensive response without interacting with any external tools, relying solely on its pre-trained knowledge
* This approach limits the LLM to its static knowledge base, excluding external tools and multi- stage reasoning. It can’t adapt or plan actions dynamically, failing the requirements.
* Databricks Reference:”External tools enhance LLM capabilities beyond pre-trained knowledge” (“Building LLM Applications with Databricks,” 2023).
* Option B: Implement a framework like ReAct which allows the LLM to generate reasoning traces and perform task-specific actions that leverage external tools if necessary
* ReAct (Reasoning + Acting) combines reasoning traces (step-by-step logic) with actions (e.g., tool calls), enabling the LLM to plan, adapt, and execute complex tasks iteratively. This meets all requirements: multi-stage reasoning, tool use, and adaptability.
* Databricks Reference:”Frameworks like ReAct enable LLMs to interleave reasoning and external tool interactions for complex problem-solving”(“Generative AI Cookbook,” 2023).
* Option C: Encourage the LLM to make multiple API calls in sequence without planning or structuring the calls, allowing the LLM to decide when and how to use external tools spontaneously
* Unstructured, spontaneous API calls lack planning and may lead to inefficient or incorrect tool usage. This doesn’t ensure effective multi-stage reasoning or adaptability.
* Databricks Reference: Structured frameworks are preferred:”Ad-hoc tool calls can reduce reliability in complex tasks”(“Building LLM-Powered Applications”).
* Option D: Use a Chain-of-Thought (CoT) prompting technique to guide the LLM through a series of reasoning steps, then manually input the results from external tools for the final answer
* CoT improves reasoning but relies on manual tool interaction, breaking automation and adaptability. It’s not a scalable pipeline solution.
* Databricks Reference:”Manual intervention is impractical for production LLM pipelines” (“Databricks Generative AI Engineer Guide”).
Conclusion: Option B (ReAct) is the best approach, as it integrates reasoning and tool use in a structured, adaptive framework, aligning with Databricks’ guidance for complex LLM workflows.

QUESTION 65
A Generative AI Engineer I using the code below to test setting up a vector store:

Assuming they intend to use Databricks managed embeddings with the default embedding model, what should be the next logical function call?

vsc.get_index()

vsc.create_delta_sync_index()

vsc.create_direct_access_index()

vsc.similarity_search()

QUESTION 66
A Generative Al Engineer is building a RAG application that answers questions about internal documents for the company SnoPen AI.
The source documents may contain a significant amount of irrelevant content, such as advertisements, sports news, or entertainment news, or content about other companies.
Which approach is advisable when building a RAG application to achieve this goal of filtering irrelevant information?

Keep all articles because the RAG application needs to understand non-company content to avoid answering questions about them.

Include in the system prompt that any information it sees will be about SnoPenAI, even if no data filtering is performed.

Include in the system prompt that the application is not supposed to answer any questions unrelated to SnoPen Al.

Consolidate all SnoPen AI related documents into a single chunk in the vector database.

QUESTION 67
A Generative Al Engineer is responsible for developing a chatbot to enable their company’s internal HelpDesk Call Center team to more quickly find related tickets and provide resolution. While creating the GenAI application work breakdown tasks for this project, they realize they need to start planning which data sources (either Unity Catalog volume or Delta table) they could choose for this application. They have collected several candidate data sources for consideration:
call_rep_history: a Delta table with primary keys representative_id, call_id. This table is maintained to calculate representatives’ call resolution from fields call_duration and call start_time.
transcript Volume: a Unity Catalog Volume of all recordings as a *.wav files, but also a text transcript as *.txt files.
call_cust_history: a Delta table with primary keys customer_id, cal1_id. This table is maintained to calculate how much internal customers use the HelpDesk to make sure that the charge back model is consistent with actual service use.
call_detail: a Delta table that includes a snapshot of all call details updated hourly. It includes root_cause and resolution fields, but those fields may be empty for calls that are still active.
maintenance_schedule – a Delta table that includes a listing of both HelpDesk application outages as well as planned upcoming maintenance downtimes.
They need sources that could add context to best identify ticket root cause and resolution.
Which TWO sources do that? (Choose two.)

call_cust_history

maintenance_schedule

call_rep_history

call_detail

transcript Volume

In the context of developing a chatbot for a company’s internal HelpDesk Call Center, the key is to select data sources that provide the most contextual and detailed information about the issues being addressed. This includes identifying the root cause and suggesting resolutions. The two most appropriate sources from the list are:
* Call Detail (Option D):
* Contents: This Delta table includes a snapshot of all call details updated hourly, featuring essential fields like root_cause and resolution.
* Relevance: The inclusion of root_cause and resolution fields makes this source particularly valuable, as it directly contains the information necessary to understand and resolve the issues discussed in the calls. Even if some records are incomplete, the data provided is crucial for a chatbot aimed at speeding up resolution identification.
* Transcript Volume (Option E):
* Contents: This Unity Catalog Volume contains recordings in .wav format and text transcripts in .txt files.
* Relevance: The text transcripts of call recordings can provide in-depth context that the chatbot can analyze to understand the nuances of each issue. The chatbot can use natural language processing techniques to extract themes, identify problems, and suggest resolutions based on previous similar interactions documented in the transcripts.
Why Other Options Are Less Suitable:
* A (Call Cust History): While it provides insights into customer interactions with the HelpDesk, it focuses more on the usage metrics rather than the content of the calls or the issues discussed.
* B (Maintenance Schedule): This data is useful for understanding when services may not be available but does not contribute directly to resolving user issues or identifying root causes.
* C (Call Rep History): Though it offers data on call durations and start times, which could help in assessing performance, it lacks direct information on the issues being resolved.
Therefore, Call Detail and Transcript Volume are the most relevant data sources for a chatbot designed to assist with identifying and resolving issues in a HelpDesk Call Center setting, as they provide direct and contextual information related to customer issues.

Databricks Databricks-Generative-AI-Engineer-Associate Exam Syllabus Topics:

Topic	Details
Topic 1	Evaluation and Monitoring: This topic is all about selecting an LLM choice and key metrics. Moreover, Generative AI Engineers learn about evaluating model performance. Lastly, the topic includes sub-topics about inference logging and usage of Databricks features.
Topic 2	Application Development: In this topic, Generative AI Engineers learn about tools needed to extract data, Langchain similar tools, and assessing responses to identify common issues. Moreover, the topic includes questions about adjusting an LLM’s response, LLM guardrails, and the best LLM based on the attributes of the application.
Topic 3	Design Applications: The topic focuses on designing a prompt that elicits a specifically formatted response. It also focuses on selecting model tasks to accomplish a given business requirement. Lastly, the topic covers chain components for a desired model input and output.

Ace Databricks-Generative-AI-Engineer-Associate Certification with 94 Actual Questions: https://www.prepawaypdf.com/Databricks/Databricks-Generative-AI-Engineer-Associate-practice-exam-dumps.html

Pass Your Next Databricks-Generative-AI-Engineer-Associate Certification Exam Easily & Hassle Free [Q43-Q67]

Databricks Databricks-Generative-AI-Engineer-Associate Exam Overview:

Databricks Databricks-Generative-AI-Engineer-Associate Exam Syllabus Topics:

admin

Leave a Reply Cancel reply

Databricks Databricks-Generative-AI-Engineer-Associate Exam Overview:

Databricks Databricks-Generative-AI-Engineer-Associate Exam Syllabus Topics:

Related posts:

admin

You might also like

Leave a Reply Cancel reply