AI-102 Designing and Implementing a Microsoft Azure AI Solution Questions and Answers

You can use the Speech service to voice-enable a chat bot.

The Direct Line Speech channel uses the text-to-speech service, which has neural and standard voices.

You'll need to make a small configuration change so that your bot can communicate with the Direct Line Speech channel using web sockets.

"When an AI application relies on personal data, such as a facial recognition system that takes images of people to recognize them; you should make it clear to the user how their data is used and retained, and who has access to it." from: https://docs.microsoft.com/en-us/learn/paths/prepare-for-ai-engineering/

This scenario is about improving the accuracy of QnA Maker responses when user phrasing is different but semantically the same.

Uploaded document contains: “What is your warranty period?”

Users ask: “How long is the warranty coverage?”

QnA Maker fails because it does not automatically equate these two phrasings.

Both must map to the same answer.

Problem

Add alternative phrasing to the question and answer (QnA) pair.

In QnA Maker, you can add synonyms or paraphrases for a question.

Example: Add “How long is the warranty coverage?” as an alternative phrasing to the existing QnA pair.

This ensures the system treats both phrasings as the same question.

Retrain the model.

After modifying the knowledge base with new alternatives, you must retrain the model.

This step incorporates the updates into the QnA Maker service.

Republish the model.

To make the changes live and accessible by the chatbot endpoint, the retrained model must be republished.

Without republishing, the chatbot will still use the old knowledge base.

Correct Sequence of Actions

Add a new QnA pair → Not needed, because we want both questions to map to the same existing answer, not duplicate answers.

Add additional questions to the document → That’s not required when QnA Maker already supports adding alternative phrasing within the portal or JSON editor.

Actions That Are Not Required

Add alternative phrasing to the question and answer (QnA) pair.

Retrain the model.

Republish the model.

Final Answer (Sequence)

QnA Maker – Add alternative phrasing

Train and publish a QnA Maker knowledge base

Microsoft References

API Endpoint SelectionThe constraint states that the content of the text must remain within the Americas Azure geography.

"api.cognitive.microsofttranslator.com": This is the global endpoint, which doesn't guarantee data residency in a specific geography.

"api-apc.cognitive.microsofttranslator.com": This endpoint refers to the Asia Pacific geography.

"api-nam.cognitive.microsofttranslator.com": This endpoint refers to the North and South America (NAM) geography.

Therefore, to meet the data residency requirement for the Americas, you must select "api-nam.cognitive.microsofttranslator.com".

2. Path/Query String SelectionThe requirement is to translate the text to a single language. The input text can be in "one of many languages," meaning the source language isn't fixed and should be detected automatically. The language to translate to is implied to be English (en) based on the options available and common translation scenarios.

"/translate?from=en": This is incorrect because it specifies the source language as English, which contradicts the "text can be in one of many languages" requirement (implying automatic source language detection).

"/translate?suggestedFrom=en": This is not the standard way to initiate a translation request and seems to suggest a source language, which is unnecessary if auto-detection is desired/possible.

"/translate?to=en": This is the correct and standard way to request a translation where the source language is automatically detected, and the target language is English (en). This fulfills the translation requirement.

"/detect?to=en" / "/detect?from=en": These endpoints are used for language detection and not for the translation itself. The prompt explicitly asks to develop code to translate the text.

You are developing an app that uses the Azure AI Speech service, and you must ensure the app can authenticate using a Microsoft Entra ID (Azure AD) token, rather than the standard key-based authentication.

According to the official Microsoft documentation:

“To authenticate with a Microsoft Entra token, the Speech resource must have a custom subdomain and use a private endpoint. The Speech service uses custom subdomains with private endpoints only.”

— Microsoft Learn: Azure AI Speech service - Role-based access control

Therefore, two prerequisites must be configured for Entra ID token-based authentication:

1. Create (Certify) a Custom Subdomain (Option D)

When you create an Azure AI Speech resource, you can specify a custom subdomain name (e.g., contoso.cognitiveservices.azure.com).

The custom subdomain ensures that each Speech endpoint has a unique URL.

Microsoft Entra token authentication depends on this subdomain for token validation.

Without a custom subdomain, Entra ID tokens cannot be used for authentication.

Hence, this is required.

2. Create a Private Endpoint (Option B)

For Microsoft Entra ID authentication, the Speech resource must be secured within a private endpoint.

Private endpoints provide a secure, private connection from your virtual network to the Azure AI Speech resource.

The Speech service only supports Entra ID token authentication when the resource is configured with a private endpoint.

Hence, this is required.

Why Not the Other Options:

A. Create a Conditional Access – Conditional Access policies restrict user access but do not configure token authentication for services.

C. Request an X.509 certificate – Certificates are not used for Speech service authentication.

E. Enable a virtual network service endpoint – The Speech service uses private endpoints, not service endpoints, for Entra ID token authentication.

Box 1: No

Example: Greet a user whose name is stored in `user.name`

- ${ welcomeUser(user.name) }

Example: Greet a user whose name you don't know:

- ${ welcomeUser() }

Box 2: No

Greet(User) is a Send a response action.

Box 3: Yes

Comprehensive Detailed ExplanationA custom neural voice (professional voice) project in Azure AI Speech requires that you follow Responsible AI and consent steps before any model training. The correct workflow in Speech Studio / Azure AI Foundry is:

Create a custom voice project – This is the container that will hold the voice talent consent, your training datasets, models, and deployments. Each project is scoped to a locale and other attributes. Microsoft Learn

Collect and upload consent – Microsoft requires explicit authorization from the voice talent. In practice, you add the voice talent consent to the project. The platform requires the verbal consent recording (WAV); many guidance and exam items also include the signed consent document (PDF) as part of consent capture to meet Responsible AI expectations. The consent step is performed before uploading training data.

Upload the voice talent’s verbal consent as a WAV file – The consent audio verifies that the person who granted consent is the same as the speaker in your training data. The documentation shows consent is a recorded statement uploaded to the project. Microsoft Learn

Analyze the quality of the audio data and fix issues – After data upload, Speech Studio runs validation and provides a per-utterance analysis (format checks, sampling rate, script match, pronunciation/noise scoring). You must resolve issues and run Analyze data before the dataset can be used for training. Microsoft Learn

Train the model using a neural training method – Start model training from the project and choose Neural as the training type for custom neural voice. Microsoft Learn

Why not “upload speech samples as WMA/MP3 files”?

For the standard, recommended Individual utterances + matching transcript data type used to fine-tune a professional neural voice, the audio files must be WAV/RIFF PCM; the docs explicitly reference “.wav” throughout data checks and corrections. WMA isn’t supported, and MP3 isn’t accepted for this core data type. (Long audio / audio-only workflows can accept MP3 for preprocessing, but the canonical training dataset for custom neural voice is WAV.)

Create a project for professional voice (Speech Studio/Azure AI Foundry): Project contains consent, datasets, models, endpoints. Microsoft Learn

Add voice talent consent to the professional voice project: Upload the recorded consent statement for the voice talent. Microsoft Learn

Professional voice fine-tuning data – required formats: Individual utterances + transcript require WAV/RIFF PCM; guidance on sample rate and transcript format. Microsoft Learn

Add a professional voice training dataset & resolve data issues: Data validation, pronunciation/noise checks, and the Analyze data step prior to training. Microsoft Learn

Train your professional voice model: Start training and select Neural method. Microsoft Learn

Microsoft Azure AI References

Comprehensive Detailed ExplanationYou are asked to construct a URI for the Microsoft Translator API call that:

Translates webpage content into Greek (el).

Returns a transliteration in the Roman alphabet (Latin script).

The base URI given is:

https://api.cognitive.microsofttranslator.com/translate?api-version=3.0

Now, let’s evaluate the required query parameters.

This specifies the target language for translation.

Since the requirement is to translate into Greek, we must include:

to=el

Correct

1. to=el

The source content is from a webpage.

Translator API requires textType=html for web page or HTML-formatted content.

If omitted, the default is plain text.

Correct

2. textType=html

By default, Greek text is written in its native Greek script.

To provide a transliteration in the Roman alphabet, we must set toScript=Latn.

Latn = Latin script.

Correct

3. toScript=Latn

A. toScript=Cyrl

Cyrl = Cyrillic script. Not required here.

B. from=el

This would mean the source language is Greek.

In the requirement, the target is Greek, so this is incorrect.

E. textType=plain

Incorrect, since we are translating HTML webpage content, not plain text.

Incorrect Options

Correct Answer: C. textType=html, D. to=el, F. toScript=Latn

Translator Text API v3.0 Reference – Translate

Language and Script Parameters (to, from, toScript)

Microsoft References

Azure Databricks is an Apache Spark-based analytics platform. → Yes

Azure Analysis Services is used for transactional workloads. → No

Azure Data Factory orchestrates data integration workflows. → Yes

Let’s break down each statement:

Azure Databricks is an Apache Spark-based analytics platform.

True.

Azure Databricks is a fast, easy, and collaborative Apache Spark-based big data analytics platform.

It is designed for data engineering, machine learning, and AI workloads.

Answer: Yes

Azure Analysis Services is used for transactional workloads.

False.

Azure Analysis Services is an analytical service for semantic data modeling, OLAP (online analytical processing), and BI (business intelligence).

Transactional workloads belong to OLTP (online transaction processing) databases such as Azure SQL Database.

Answer: No

Azure Data Factory orchestrates data integration workflows.

True.

Azure Data Factory (ADF) is a cloud-based ETL and data integration service that orchestrates and automates data movement and transformation across on-premises and cloud systems.

Answer: Yes

To generate less deterministic and more creative responses with Azure OpenAI chat completions, increase the Temperature setting. Temperature controls sampling randomness: higher values (e.g., ~0.8–1.0) yield more diverse/creative outputs; lower values (~0–0.2) are more deterministic.

The message being sent in the Messages collection is the user’s prompt, so the correct role is ChatRole.User. The role does not control creativity; it only tells the model who authored the message (system/assistant/user/function). Creativity is governed by parameters such as Temperature (and, to a lesser extent, TopP). PresencePenalty biases against repeating seen tokens/topics but does not primarily increase creativity in the intended way.

So the code should look like:

new ChatCompletionsOptions()

{

Messages =

{

new ChatMessage(ChatRole.User, @""),

},

Temperature = (float)1.0,

MaxTokens = 800,

};

Microsoft Azure AI Solution References

Azure OpenAI Service – Chat Completions parameters (Temperature controls randomness/creativity; higher = more diverse results).

Azure OpenAI Service – Message roles in chat (system, user, assistant, function) and their purposes.

Azure OpenAI Service – Presence/Frequency penalties vs. Temperature (penalties reduce repetition; temperature changes creativity).

Scenario: All planned projects must support English, French, and Portuguese.

If a bot uses multiple LUIS models and QnA Maker knowledge bases (knowledge bases), you can use the Dispatch tool to determine which LUIS model or QnA Maker knowledge base best matches the user input. The dispatch tool does this by creating a single LUIS app to route user input to the correct model.

Box 1: "categories": ["Locations", "Persons", "Organizations"],

Locations, Persons, Organizations are in the outputs.

Scenario: Contoso plans to develop a searchable knowledgebase of all the intellectual property

Note: The categories parameter is an array of categories that should be extracted. Possible category types: "Person", "Location", "Organization", "Quantity", "Datetime", "URL", "Email". If no category is provided, all types are returned.

Box 2: {"name": " entities"}

The include wikis, so should include entities in the outputs.

Note: entities is an array of complex types that contains rich information about the entities extracted from text, with the following fields

name (the actual entity name. This represents a "normalized" form)

wikipediaId

wikipediaLanguage

wikipediaUrl (a link to Wikipedia page for the entity)

etc.

When many utterances differ only by airport names or codes, you don’t want to list them all.

A Pattern.any entity acts as a placeholder for free-form input inside patterns, allowing the model to accept any word/phrase in that slot.

Machine-learning entities require lots of labeled utterances.

List entities work for fixed sets (e.g., specific known airport codes), but this scenario implies dynamic airport data.

Regex entities are for structured formats (like postal codes).

Correct Answer: A

Provision the Language service resource in Azure.

Deploy a Docker container to an on-premises server.

Run the container and query the prediction endpoint.

According to the Microsoft documentation, the Language service is a cloud-based service that provides various natural language processing features, such as sentiment analysis, key phrase extraction, named entity recognition, etc. You can provision the Language service resource in Azure by following the steps in Create a Language resource. You will need to provide a name, a subscription, a resource group, a region, and a pricing tier for your resource. You will also get a key and an endpoint for your resource, which you will use to authenticate your requests to the Language service API.

According to the Microsoft documentation, you can also use the Language service as a container on your own premises or in another cloud. This option gives you more control over your data and network, and allows you to use the Language service without an internet connection. You can deploy a Docker container to an on-premises server by following the steps in Deploy Language containers. You will need to have Docker installed on your server, pull the container image from the Microsoft Container Registry, and run the container with the appropriate parameters. You will also need to activate your container with your key and endpoint from your Azure resource.

According to the Microsoft documentation, once you have deployed and activated your container, you can run it and query the prediction endpoint to get sentiment analysis results. The prediction endpoint is a local URL that follows this format: http:// :/text/analytics/v3.1-preview.4/sentiment. You can send HTTP POST requests to this endpoint with your text input in JSON format, and receive JSON responses with sentiment labels and scores for each document and sentence in your input.

Box 1: Azure Blob storage

At the start of the pipeline, you have unstructured text or non-text content (such as images, scanned documents, or JPEG files). Data must exist in an Azure data storage service that can be accessed by an indexer.

Box 2: Computer Vision API

Scenario: Provide users with the ability to search insight gained from the images, manuals, and videos associated with the products.

The Computer Vision Read API is Azure's latest OCR technology (learn what's new) that extracts printed text (in several languages), handwritten text (English only), digits, and currency symbols from images and multi-page PDF documents.

Box 3: Translator API

Scenario: Product descriptions, transcripts, and all text must be available in English, Spanish, and Portuguese.

Box 4: Azure Files

Scenario: Store all raw insight data that was generated, so the data can be processed later.

Comprehensive Detailed ExplanationThe requirement is to build an Adaptive Card for the chatbot that supports multilingual product display and meets accessibility requirements.

Product Name Display

The product JSON stores localized names like "name": { "en": "...", "es": "...", "pt": "..." }.

To dynamically render based on the current language, you must use name[language].

This ensures the product name shown in the card adapts automatically to the user’s preferred language.

Stock Level Warning

Business rules require warnings when stock is low or out of stock.

This means you display the stock warning only when stockLevel is not 'OK'.

Therefore, the correct condition is:"$when": "${stockLevel != 'OK'}"

Image Alt Text for Accessibility

Accessibility requirements specify that all images must have alt text in English, Spanish, and Portuguese.

In the product JSON, "alttext" is also localized:

"altText": { "en": "Bicycle", "es": "Bicicleta", "pt": "Bicicleta" }

To render the correct localized alt text dynamically, use image.altText[language].

Correct Selections:

First blank: name[language]

Second blank: "$when": "${stockLevel != 'OK'}"

Third blank: image.altText[language]

Adaptive Cards Templating

Adaptive Card $when property

Multilingual data in Azure Cognitive Search and Adaptive Cards

Microsoft References

Box 1: api-nam.cognitive.microsofttranslator.com

https://docs.microsoft.com/en-us/azure/cognitive-services/translator/referenc e/v3-0-reference

Box 2: /translate

Scenario: All videos must have transcripts that are associated to the video and included in product descriptions.

Product descriptions, transcripts, and all text must be available in English, Spanish, and Portuguese.

Step 1: Upload the video to blob storage

Given a video or audio file, the file is first dropped into a Blob Storage. T

Step 2: Index the video by using the Video Indexer API.

When a video is indexed, Video Indexer produces the JSON content that contains details of the specified video insights. The insights include: transcripts, OCRs, faces, topics, blocks, etc.

Step 3: Extract the transcript from the Video Indexer API.

Step 4: Translate the transcript by using the Translator API.

Parameter type: stream

Visual features list: VisualFeatureTypes.Description

Result to use: results.Description.Captions[0]

To generate accessible alt text, you should use the caption produced by Azure Computer Vision’s Description feature (it produces a human-readable sentence with a confidence score). Therefore:

The image input should be a stream, because you’re uploading images (not just passing URLs) during product creation and AnalyzeImage…Async supports image streams.

Request the Description feature in VisualFeatureTypes so the service returns results.Description.Captions.

Use results.Description.Captions[0] and return the caption text if its confidence is high enough (e.g., > 0.5) to meet the accessibility requirement that all images must have relevant alt text.

Other features (Tags, Objects, Brands) are useful for enrichment but do not directly return natural-language captions suitable for alt text.

Microsoft Azure AI Solution References

Computer Vision (Image Analysis) – Description/Captions and features: Microsoft Docs, Image Analysis – VisualFeatureTypes.Description returns description.captions.https://learn.microsoft.com/azure/ai-services/computer-vision/concept-image-analysis

SDK usage (analyze image from a stream): Microsoft Docs, Analyze an image by using the Computer Vision client library.https://learn.microsoft.com/azure/ai-services/computer-visi on/how-to/call-analyze-image?tabs=version-3-2#analyze-an-image-from-a-stream

Scenario: Support autocompletion and autosuggestion based on all product name variants.

A: Call a suggester-enabled query, in the form of a Suggestion request or Autocomplete request, using an API. API usage is illustrated in the following call to the Autocomplete REST API.

POST /indexes/myxboxgames/docs/autocomplete?search&api-version=2020-06-30

{

"search": "minecraf",

"suggesterName": "sg"

}

B: In Azure Cognitive Search, typeahead or "search-as-you-type" is enabled through a suggester. A suggester provides a list of fields that undergo additional tokenization, generating prefix sequences to support matches on partial terms. For example, a suggester that includes a City field with a value for "Seattle" will have prefix combinations of "sea", "seat", "seatt", and "seattl" to support typeahead.

F. Use the default standard Lucene analyzer ("analyzer": null) or a language analyzer (for example, "analyzer": "en.Microsoft") on the field.

Box 1: QnA Maker Editor

Scenario: Provide all employees with the ability to edit Q&As.

The QnA Maker Editor (read/write) has the following permissions:

Create KB API

Update KB API

Replace KB API

Replace Alterations

"Train API" [in

new service model v5]

Box 2: Contributor

Scenario: Only senior managers must be able to publish updates.

Contributor permission: All except ability to add new members to roles

The question is about evaluating a Custom Vision classifier after training.

When you train an image classifier in Azure Custom Vision, the service automatically calculates performance metrics to help you evaluate the quality of the model.

Precision:

The percentage of correct positive predictions out of all positive predictions made.

Formula: Precision = TP / (TP + FP)

Helps determine how reliable positive predictions are.

Recall:

The percentage of actual positives that were correctly predicted.

Formula: Recall = TP / (TP + FN)

Helps determine how many of the true positives were captured.

Metrics Provided by Custom Vision:These two metrics are explicitly shown in the Custom Vision portal and via API.

A. Recall

Yes, Custom Vision reports recall.

Correct

B. F-score

Not directly reported in the Custom Vision portal.

Although it can be derived from precision and recall, it is not provided as a direct metric.

Incorrect

C. Weighted accuracy

Not reported by Custom Vision.

Incorrect

D. Precision

Yes, Custom Vision reports precision.

Correct

E. Area under the curve (AUC)

Not reported by Custom Vision.

More common in ROC curve analysis, not part of Custom Vision output.

Incorrect

Option Analysis

Correct Answer: A. recall, D. precision

Evaluate the prediction performance of your classifier in Custom Vision

Custom Vision training and evaluation

The question describes:

An Azure subscription with an Azure AI Content Safety resource.

A social media application where users can upload images.

The requirement is to moderate inappropriate content in those uploaded images.

In Azure AI Content Safety SDKs:

You create a ContentSafetyClient by providing the endpoint and key.

The ContentSafetyClient exposes methods such as:

AnalyzeText() → For text moderation

AnalyzeImage() → For image moderation

Let’s review the code structure:

public static void Analyze(AnalyzeImageOptions request)

{

var endpoint = Environment.GetEnvironmentVariable("ENDPOINT");

var key = Environment.GetEnvironmentVariable("KEY");

var client = new ContentSafetyClient(new Uri(endpoint), new AzureKeyCredential(key));

return client.AnalyzeImage(request);

}

First dropdown: must be ContentSafetyClient to instantiate the correct client for Azure AI Content Safety.

Second dropdown: since the requirement is image moderation, we must call client.AnalyzeImage(request).

Other options:

BlocklistClient → used for custom blocklists, not full moderation.

TextCategoriesAnalysis → refers to text analysis categories, not suitable here.

AnalyzeText → would be used only for text moderation.

Therefore, the correct completion is:

ContentSafetyClient

client.AnalyzeImage(request)

Correct Answer:

First dropdown: ContentSafetyClient

Second dropdown: client.AnalyzeImage(request)

Azure AI Content Safety – Analyze images

Azure AI Content Safety SDK documentation

ContentSafetyClient class

Microsoft References

To allow users to cancel an in-progress transaction, you need an interruption mechanism.

In Bot Framework Composer, this is done using triggers such as an intent trigger or dialog trigger (e.g., a CancelIntent trigger that interrupts the current flow).

A language generator handles variations in bot responses.

A custom event is not required for simple cancellation.

A conversation activity handles messages or events but does not manage interruption logic.

Correct Answer: C

Comprehensive Detailed ExplanationYou are deploying Anomaly Detector API as a container. The key requirements are:

Prevent billing and API keys from being exposed in command-line history.

Control access to container images using Azure RBAC.

Step-by-step reasoning:

Pull the Anomaly Detector container image

Microsoft Cognitive Services (including Anomaly Detector) provides container images via Microsoft Container Registry.

You must first pull the container image locally.

Push the image to an Azure container registry (ACR)

To enforce Azure RBAC, you need to use Azure Container Registry instead of Docker Hub.

Storing in ACR ensures authentication and role-based access control to the image.

Distribute a docker run script

Instead of providing credentials directly on the command line (which risks storing API keys in shell history), best practice is to distribute a docker run script (or use environment variables / mounted files) to run the container.

This prevents exposure of sensitive information.

Run the container on local devices or on-premises datacenters

The container now runs securely, with API key and billing info injected at runtime via environment variables or mounted secrets.

Create a custom Dockerfile → Not needed, because Microsoft provides the official Anomaly Detector container image.

Build the image → Not required; again, the container is prebuilt.

Push the image to Docker Hub → Does not allow RBAC, so this would not meet the security requirement.

Incorrect Options

Correct Sequence:

Pull the Anomaly Detector container image.

Push the image to an Azure container registry.

Distribute a docker run script.

Run the container in the local or on-prem environment.

Use Cognitive Services containers

Azure Container Registry – Authentication and RBAC

Best practices for running Cognitive Services containers

Microsoft References

Box 1: Yes

You create property accessors using the CreateProperty method that provides a handle to the BotState object. Each state property accessor allows you to get or set the value of the associated state property.

Box 2: Yes

Box 3: No

Before you exit the turn handler, you use the state management objects' SaveChangesAsync() method to write all state changes back to storage.

Upload a glossary file to the container for French files

Define a document translation specification that has a French target

Perform an asynchronous translation by using the document translation specification

You need to translate Word and PowerPoint files (German → French) while preserving formatting and supporting a custom glossary. The correct service is Azure Document Translation, part of the Translator service in Azure Cognitive Services.

Step-by-step reasoning:

Upload a glossary file to the container for French files.

Glossaries (also called custom terminology files) guide translation to ensure consistent word usage.

They are stored in the target container (in this case, the French container).

Define a document translation specification that has a French target.

A translation request is defined by creating a document translation specification JSON.

This specification indicates:

The source container (German files)

The target container (French files)

The glossary file (for custom terminology)

Output target language (French).

Perform an asynchronous translation by using the document translation specification.

Document translation jobs are submitted asynchronously.

This step executes the translation while preserving formatting and applying the glossary rules.

Why not the other options?

Generate a list of files to be translated → not required, the service automatically processes all files in the source container.

Perform asynchronous translation using a list of files → that method does not support document-level translation with glossary and formatting preservation, it’s used for text-based translations.

Correct Answer Order:

Upload a glossary file to the container for French files

Define a document translation specification that has a French target

Perform an asynchronous translation by using the document translation specification

Document Translation – Translate documents in containers

Use custom glossaries with Document Translation

Submit document translation requests

Microsoft References

Comprehensive Detailed ExplanationTo move a Question Answering project to a different Azure region, you migrate the project data and then re-deploy it in the target region:

Export the existing project (source region).In Language Studio (Question Answering), you first export the project. This produces a package (JSON/ZIP) containing your knowledge bases, sources, synonyms, and settings. Exporting is the supported way to move a project between resources/regions.

Import the project into the new Language service instance (target region).In the target region’s Language service instance, use Language Studio to import the previously exported file. This recreates the project (KBs and configuration) under the new resource.

Train and publish from the new instance.After import, you must train (build) and then publish the project so that an endpoint is created under the new regional resource. Clients can then point to the new endpoint and key.

Actions like “enable custom text classification” or “regenerate the keys” are not required for moving a Question Answering project, and training/publishing from the original instance won’t deploy to the target region.

Microsoft Azure AI Solution References

Export and import Question Answering projects in Language Studio (move between resources/regions):Microsoft Learn – Export and import projects (Question Answering).https://learn.microsoft.com/azure/ai-services/language-service/question-answering/how-to/export-import-project

Train and publish a Question Answering project:Microsoft Learn – Create, train, and publish projects (Question Answering).https://learn.microsoft.com/azure/ai-services/language-service/question-answering/how-to/create-test-deploy

Language service overview and regional deployment concepts:Microsoft Learn – What is Azure AI Language?https://learn.microsoft.com/azure/ai-services/language-service/overview

Azure Cosmos DB supports multiple APIs, each aligned to a specific data model:

Gremlin API

Designed for graph data.

Stores vertices (nodes) and edges (relationships).

Query language: Gremlin.

Correct mapping: Graph data.

MongoDB API

Designed for document data using JSON.

Supports MongoDB wire protocol.

Correct mapping: JSON documents.

Table API

Designed for key-value data.

Compatible with Azure Table Storage.

Correct mapping: Key/value data.

Cassandra API

Designed for wide-column (column-family) data.

Uses CQL (Cassandra Query Language).

Not listed in the answer area, but if included, it maps to columnar data, not the options shown here.

Correct Mapping:

Graph data → Gremlin API

JSON documents → MongoDB API

Key/value data → Table API

APIs in Azure Cosmos DB

Choose the right API for Azure Cosmos DB

Microsoft References

When testing a bot with the Bot Framework Emulator, especially if the bot uses authentication (OAuth), you need the Emulator to mimic real-world authentication flows. To do that:

Use version 1.0 authentication tokens

Ensures that authentication tokens are generated in the same format as Bot Framework v1.0, which is compatible with most OAuth flows.

Use a sign-in verification code for OAuthCard

Prompts the user with a verification code during sign-in flows, ensuring the emulator behaves like a real client app (e.g., mobile or Teams).

This is required to test sign-in prompts and enforce credential entry.

Use your own user ID to communicate with the bot

Ensures that the Emulator identifies you uniquely and triggers authentication properly.

Without this, the bot may treat sessions generically, and authentication prompts might not behave as expected.

Why not the others?

Application Updates (automatically download/install) → Related to emulator updates, not authentication.

Data Collection → Only for telemetry; does not affect authentication.

Ngrok settings → Used for tunneling remote bot connections; unrelated to credential prompts.

Correct Answer Selections:

Use version 1.0 authentication tokens

Use a sign-in verification code for OAuthCard

Use your own user ID to communicate with the bot

Bot Framework Emulator - Authentication

Testing bots with Bot Framework Emulator

Microsoft References

The chatbot uses Question Answering in Azure Cognitive Service for Language.

Users report that the chatbot’s responses to spurious questions (such as jokes, casual chitchat, or off-topic queries) are not formal enough.

Comprehensive Detailed ExplanationIn Question Answering projects, you can add chitchat sources provided by Microsoft to handle small talk. These sources include:

qna_chitchat_friendly.tsv → Informal/friendly responses.

qna_chitchat_professional.tsv → Formal/professional responses.

qna_chitchat_witty.tsv → Humorous/witty responses.

By changing the chitchat source to qna_chitchat_professional.tsv, then retraining and republishing, the bot will provide formal responses to spurious questions.

Therefore, this solution meets the goal.

Correct Answer: A. Yes

Add chit-chat to a Question Answering project

Chit-chat personality types (friendly, professional, witty)

Microsoft References

curl -i -X: The POST method is appropriate because you are creating a new custom analyzer, which involves sending a request to create a resource. POST is used for creating new resources in REST APIs.

https:// .services.ai.azure.com/: The base URL should be updated to include the contentunderstanding endpoint, as this is the specific service within the Azure AI Content Understanding resource (cu1) that handles analyzer-related operations. Replace with the actual resource name or endpoint provided by your Azure subscription.

/analyzers/myInvoice7api-version-2024-12-01-preview: This part of the URL is correct as it specifies the endpoint for creating a custom analyzer (/analyzers) with the name myInvoice7 and the API version 2024-12-01-preview. No changes are needed here, assuming the analyzer name and version are intended as shown.

Explanation

To deploy the bot to Azure, you should run the following three Azure CLI commands in sequence:

az deployment group create This command will create the Azure resources for your bot using an ARM template and a parameters file. You need to specify the resource group name, the template file path, and the parameters file path. For example:

az deployment group create --resource-group myResourceGroup --template-file “deploymentTemplates\template-with-preexisting-rg.json” --parameters “deploymentTemplates\parameters-for-template-BotApp-with-rg.json”

This command will also output the app ID and password of your bot, which you will need for the next command1.

az webapp deployment source config-zip This command will deploy your bot code to the app service that you created in the previous step. You need to specify the resource group name, the app service name, and the zip file path of your bot code. For example:

az webapp deployment source config-zip --resource-group myResourceGroup --name myBotAppService --src “code.zip”

This command will also output the URL of your bot endpoint, which you will need for the next command2.

az ad app update This command will update your bot registration with the endpoint URL of your bot. You need to specify the app ID of your bot and the endpoint URL. For example:

az ad app update --id myBotAppId --set replyUrls=“https://myBotAppService.azurewebsites.net/api/messages”

This command will complete the deployment process and make your bot ready to be tested3.

The requirement:

You are using Azure AI Anomaly Detector.

You need to deploy it on Server1, which has intermittent internet access.

This means you need to run the service locally using containers (Docker).

Step 1 – Install Docker Engine

Before pulling or running any containers, Docker must be installed on Server1.

Without Docker Engine, no container can be deployed.

Step 2 – Pull the container image

Use docker pull to download the Anomaly Detector container image from Microsoft Container Registry.

This requires internet access, so it should be done when connectivity is available.

Step 3 – Run the container

After pulling the image, use docker run to start the Anomaly Detector container.

This exposes a local REST API endpoint on Server1.

Step 4 – Query the local endpoint

Once the container is running, you can query the prediction endpoint on Server1.

This allows local inference without requiring continuous internet access.

Correct Sequence:

Install the Docker Engine on Server1.

From Server1, run the docker pull command.

From Server1, run the docker run command.

Query the prediction endpoint on Server1.

Use Azure AI Anomaly Detector on containers

Deploy Azure AI services in Docker containers

Anomaly Detector container setup

Microsoft References

You are adding a custom plugin to a Semantic Kernel–based agent and you want function calling to be enforced and self-completing:

To register a plugin that exposes one or more callable functions to the agent, use CreatePluginFromFunctions. This builds a plugin from Kernel functions (prompt- or code-based) and makes them available for tool/function calling by the model.

To ensure the model must call functions (and request any required parameters it doesn’t have), set the prompt execution settings to FunctionChoiceBehaviour.Required. In Semantic Kernel, this corresponds to the OpenAI tool/function-calling control that forces the assistant to invoke appropriate functions. When required parameters are marked in the function’s schema, the assistant will ask follow-up questions to collect them before (or while) invoking the function.

References (Microsoft Azure AI Solution)

Semantic Kernel: Plugins and Functions, ChatCompletionAgent, OpenAIPromptExecutionSettings, and FunctionChoiceBehavior for enforced tool/function calling.

To create a resource that can generate fictional stories from prompts, you need an Azure OpenAI account (--kind OpenAI).

To protect data with a customer-managed key (CMK), you must pass the key information (Key Vault URI, key name, key version) via the --encryption parameter when creating the Cognitive Services account. The JSON shown (with keyName, keyVersion, and keyVaultUri) is exactly the payload expected by --encryption.

A complete example pattern:

az cognitiveservices account create \

-n myresource -g myResourceGroup -l westeurope \

--kind OpenAI --sku S \

--assign-identity \

--encryption '{

"keyName":"keyname",

"keyVersion":"secretVersion",

"keyVaultUri":"https:// .vault.azure.net/"

}'

(Adding --assign-identity allows the service to access the Key Vault key; the hotspot specifically asks for the parameter that takes the JSON block and the resource kind, which are --encryption and OpenAI.)

Microsoft References

Azure CLI: Create Cognitive Services account with customer-managed keys using --encryption.https://learn.microsoft.com/azure/ai-services/cognitive-services-encryption-keys#configure-customer-managed-keys

Azure Cognitive Services (Azure AI services) CLI parameters including --kind OpenAI.https://learn.microsoft.com/azure/ai-services/cognitive-services-management-api-cli#create-a-cognitive-services-account

Box 1: Cognitive Service User

Ensure that the members of a group named Management-Accountants can approve the FAQs.

Approve=publish.

Cognitive Service User (read/write/publish): API permissions: All access to Cognitive Services resource except for ability to:

1. Add new members to roles.

2. Create new resources.

Box 2: Cognitive Services QnA Maker Editor

Ensure that the members of a group named Consultant-Accountants can create and amend the FAQs.

QnA Maker Editor: API permissions:

1. Create KB API

2. Update KB API

3. Replace KB API

4. Replace Alterations

5. "Train API" [in new service model v5]

Box 3: Cognitive Services QnA Maker Read

Ensure that the members of a group named the Agent-CustomerServices can browse the FAQs.

QnA Maker Read: API Permissions:

1. Download KB API

2. List KBs for user API

3. Get Knowledge base details

4. Download Alterations

Generate Answer

Can search content in different formats, including video

Audio and video insights (multi-channels). When indexing by one channel, partial result for those models will be available.

Keywords extraction: Extracts keywords from speech and visual text.

Named entities extraction: Extracts brands, locations, and people from speech and visual text via natural language processing (NLP).

Topic inference: Makes inference of main topics from transcripts. The 2nd-level IPTC taxonomy is included.

Artifacts: Extracts rich set of "next level of details" artifacts for each of the models.

Sentiment analysis: Identifies positive, negative, and neutral sentiments from speech and visual text.

Within a search service, synonym maps are a global resource that associate equivalent terms, expanding the scope of a query without the user having to actually provide the term. For example, assuming "dog", "canine", and "puppy" are mapped synonyms, a query on "canine" will match on a document containing "dog".

Create synonyms: A synonym map is an asset that can be created once and used by many indexes.

Explanation:

Scenario: When the response confidence score is low, ensure that the chatbot can provide other response options to the customers.

When no good match is found by the ranker, the confidence score of 0.0 or "None" is returned and the default response is "No good match found in the KB". You can override this default response in the bot or application code calling the endpoint. Alternately, you can also set the override response in Azure and this changes the default for all knowledge bases deployed in a particular QnA Maker service.

Choosing Ranker type: By default, QnA Maker searches through questions and answers. If you want to search through questions only, to generate an answer, use the RankerType=QuestionOnly in the POST body of the GenerateAnswer request.

C: Analyze Receipt - Get Analyze Receipt Result.

Query the status and retrieve the result of an Analyze Receipt operation.

Request URL: https://{endpoint}/formrecognizer/v2.0-preview/prebuilt/receipt/analyzeResults/{resultId}

E: POST {Endpoint}/vision/v3.2/read/analyze

Use this interface to get the result of a Read operation, employing the state-of-the-art Optical Character Recognition (OCR) algorithms optimized for text-heavy documents.

Scenario: Contoso plans to develop a document processing workflow to extract information automatically from PDFs and images of financial documents

The document processing solution must be able to process standardized financial documents that have the following characteristics:

- Contain fewer than 20 pages.

- Be formatted as PDF or JPEG files.

- Have a distinct standard for each office.

*The document processing solution must be able to extract tables and text from the financial documents.

The document processing solution must be able to extract information from receipt images.

The requirements state:

All AI solution responses must have a confidence score ≥ 70%.

If the response confidence score is < 70%, the response must be improved by human input.

Members of the Consultant-Bookkeeper group must be able to process financial documents, which includes performing manual review when the AI confidence is below threshold.

Looking at the provided JSON:

"fields": {

"ReceiptType": {

"type": "string",

"valueString": "Itemized",

"confidence": 0.672

},

"MerchantName": {

"type": "string",

"valueString": "Tailwind",

"confidence": 0.913

}

}

ReceiptType.confidence = 0.672 → this is below 0.7.

MerchantName.confidence = 0.913 → this is above 0.7.

Therefore, the correct condition for triggering manual review is:

documentResults.fields..confidence < 0.7

Now, evaluating the options:

A. documentResults.docType == "prebuilt:receipt"

Always true for receipts, does not check confidence. Not correct.

B. documentResults.fields.*.confidence < 0.7

This is the correct general expression: trigger manual review whenever any field confidence is below 0.7.

C. documentResults.fields.ReceiptType.confidence > 0.7

This would bypass manual review when ReceiptType has high confidence. The requirement is to trigger review when confidence < 0.7, so this is the opposite.

D. documentResults.fields.MerchantName.confidence < 0.7

This only checks one field (MerchantName). In the JSON, MerchantName has confidence 0.913 (>0.7), so this condition would not trigger, but ReceiptType clearly needs review. Too narrow.

Correct Answer: B. documentResults.fields.*.confidence < 0.7

Azure AI Document Intelligence – Confidence scores

Human-in-the-loop for Document Intelligence

Microsoft References