Free and Premium Microsoft AI-102 Dumps Questions Answers

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.

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.

Comprehensive Detailed Explanation

The 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]

Microsoft References

Adaptive Cards Templating

Adaptive Card $when property

Multilingual data in Azure Cognitive Search and Adaptive Cards

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

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

Box 2: /translate

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.

SDK usage (analyze image from a stream): Microsoft Docs, Analyze an image by using the Computer Vision client library .

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.

Metrics Provided by Custom Vision:

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.

These two metrics are explicitly shown in the Custom Vision portal and via API.

Option Analysis

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

Correct Answer: A. recall, D. precision

Microsoft References

Evaluate the prediction performance of your classifier in Custom Vision

Custom Vision training and evaluation

To detect harmful content with Azure AI Content Safety using the .NET SDK, you instantiate a ContentSafetyClient with the endpoint and key. For text moderation, you construct an AnalyzeTextOptions object with the input string (and optionally specify categories, blocklists, etc.). You then call client.AnalyzeText(AnalyzeTextOptions options) and inspect the result (e.g., categories analysis and blocklist matches).

Code completed:

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

var request = new AnalyzeTextOptions( " what is the weather forecast for Seattle " );

Response < AnalyzeTextResult > response = client.AnalyzeText(request);

Microsoft Azure AI References

Azure AI Content Safety – SDK usage for text analysis with ContentSafetyClient and AnalyzeTextOptions (Analyze Text API).

Azure AI Content Safety – Concepts: text categories (hate/sexual/violence/self-harm) and blocklists, returned in AnalyzeTextResult .

Comprehensive Detailed Explanation

A 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.)

Microsoft Azure AI References

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 Le arn

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

Azure AI Content Safety supports custom blocklists —dictionaries of terms/phrases you define to detect obscure or domain-specific offensive terms in user content. Creating a blocklist is the minimal-effort, built-in way to meet this requirement; you don’t need to build a classifier.

References

Create and use blocklists in Azure AI Content Safety.

Text moderation overview (using built-in classifiers with optional blocklists).

Comprehensive Detailed Explanation

Active learning in Language Understanding (LUIS / Conversational Language Understanding) works by collecting real user queries sent to your prediction endpoint.

By setting log=true in the prediction endpoint query, these user utterances are stored in the LUIS service.

The logged utterances can then be reviewed in the Review endpoint utterances page of the LUIS portal, where you can relabel and retrain the model. This enables the active learning loop.

Why not the others?

A. show-all-intents=true: This simply forces the endpoint to return all intents, not related to active learning.

B. Enable speech priming: Used for improving speech-to-text accuracy, unrelated to LUIS active learning.

D. Enable sentiment analysis: Adds sentiment scores to prediction output, not related to active learning.

For a social media messaging app that must identify the language of text messages in real time, the most direct SDK is the Azure AI Translator – Text Translation SDK. Its client libraries (e.g., Azure.AI.Translation.Text in .NET) include a language detection operation that returns the detected language code and a confidence score, which is exactly what you need for real-time text scenarios.

Other options are not a fit:

Microsoft.CognitiveServices.Speech is the Speech SDK for speech-to-text, TTS, and speech translation (audio), not text-only language detection.

Azure.AI.Translation.Document targets asynchronous document translation workflows, not short text message detection. Microsoft Learn

Azure.AI.Translation.Speech isn’t the package used; speech translation is covered by the Speech SDK package above. Microsoft Learn

Microsoft References

Text Translation SDK overview (supports language detection): Azure AI Translator. Microsoft Learn

DetectedLanguage in Azure.AI.Translation.Text (returned by detect operation). Microsoft Learn

Quickstart: Translator text client libraries. Microsoft Learn

Install/use the Speech SDK (contrast with text scenario). Microsoft Learn

Document Translation SDK overview (not applicable to short text detection). Microsoft Learn

Scenario Recap:

Proposed Solution: Deploy service1 with a public endpoint, and configure a Network Security Group (NSG) for vnet1.

Analysis:

NSGs only control inbound/outbound traffic at the VNet/subnet or NIC level.

Configuring NSGs does not create private connectivity to Cognitive Search.

Traffic still flows over the public endpoint.

Answer: B. No

NSGs filter traffic, but they don’t prevent routing via the public internet. Only Private Link does.

To access multiple Azure AI capabilities (e.g., Speech and Language) using a single endpoint and a single set of credentials, you should provision an Azure AI multi-service resource (called Azure AI service in the portal; formerly “Cognitive Services” multi-service account). This resource provides one endpoint and one key (or Microsoft Entra ID) that authorizes calls across supported services, including Speech and Language. Creating separate “Azure AI Speech” or “Azure AI Language” resources would give you distinct endpoints/keys for each, which does not meet the requirement. Azure AI Content Safety is unrelated.

Microsoft References

Azure AI services multi-service resource (single endpoint/credential across services).

What are Azure AI services (overview of consolidated access model).

To validate that your Azure AI Content Safety resource can identify images containing potential violence, you must call the Image Analyze operation of Content Safety. The REST endpoint for this operation is:

POST {endpoint}/contentsafety/image:analyze?api-version=2024-09-01

This operation analyzes an image for the four harm categories Hate, SelfHarm, Sexual, and Violence. Therefore, the correct base path is /contentsafety, and the correct operation is image analyze (shown in the hotspot as /imageanalyze).

Microsoft References

REST API: Analyze Image — POST {endpoint}/contentsafety/image:analyze?api-version=2024-09-01 ; categories include Hate, SelfHarm, Sexual, and Violence. Microsoft Learn

Quickstart: Analyze image content with Azure AI Content Safety (overview and examples). Microsoft Learn

Harm categories concept (lists Violence among supported categories). Microsoft Learn

You created five bots with Microsoft Bot Framework Composer, but want to make them appear as one unified bot for users, with dynamic routing depending on user input.

This is exactly the Bot Framework Orchestrator scenario. Orchestrator is the recognizer that allows you to dispatch incoming utterances to the correct skill (bot) or dialog.

Step 1 – Install Orchestrator package

To use Orchestrator inside Bot Framework Composer, you first install the Orchestrator package.

This provides the functionality for language understanding and routing.

Correct answer: F.

Step 2 – Change Recognizer/Dispatch type

By default, a bot project might use LUIS recognizer or Regex recognizer.

To use Orchestrator, you need to change the recognizer type to Orchestrator in Composer.

Correct answer: B.

Step 3 – Create an Orchestrator model

Orchestrator requires a trained model that maps utterances to intents or routes them to the correct skill/bot.

You must create an Orchestrator model for dispatch.

Correct answer: A.

Other Options (Incorrect):

C. Create a Composer extension → Not required for orchestrating multiple bots.

D. Enable WebSockets → Useful for streaming scenarios, not for bot orchestration.

E. Create a custom recognizer JSON file → Applies to building custom recognizers, not needed with Orchestrator.

The chatbot needs to recognize two different kinds of information:

Code names for internal product development

These are not standard entities like " locations " or " organizations " that prebuilt NER can detect.

You need to train a custom model to recognize internal terms or codenames (for example, " Project Falcon " ).

The correct Azure Cognitive Service for Language feature is Custom Named Entity Recognition (Custom NER), which allows defining and training entity categories specific to your business.

Messages that include credit card numbers

Credit card numbers are sensitive data falling under Personally Identifiable Information (PII).

Azure Cognitive Service for Language provides a PII detection feature that automatically identifies and masks sensitive information such as credit card numbers, SSNs, and phone numbers.

This minimizes development effort since it is prebuilt and ready to use.

Correct Answer Mapping:

Identify code names for internal product development → Custom named entity recognition (NER)

Identify messages that include credit card numbers → Personally Identifiable Information (PII) detection

Microsoft References

Custom Named Entity Recognition in Azure AI Language

PII detection in Azure AI Language

Scenario Recap

You have a web app app1 running on VM1 in vnet1.

You plan to create an Azure Cognitive Search service (service1).

Goal: Ensure app1 can connect to service1 without routing over the public internet.

Proposed Solution

“You deploy service1 and a public endpoint to a new virtual network, and you configure Azure Private Link.”

Analysis

Azure Cognitive Search and Private Link:

Azure Cognitive Search supports Private Endpoints via Azure Private Link.

When you configure a private endpoint, the service is accessible privately over the virtual network and traffic does not go over the public internet.

You can still keep a public endpoint enabled optionally, but access from your VM can be restricted to the private endpoint.

Key Point: The solution specifies using a public endpoint AND a private link.

This still meets the requirement because Private Link ensures that VM1 in vnet1 communicates with service1 privately.

The existence of the public endpoint does not force traffic to go public — traffic from the private endpoint is routed over the VNet.

Conclusion

Yes, this solution meets the goal because Private Link provides secure, private connectivity to Cognitive Search, avoiding the public internet.

Correct Answer: A. Yes

Microsoft References

Secure access to Azure Cognitive Search with Private Link

Azure Private Link overview

Use " definition " for the first field and " sampleBlobUrl " for the second field

When creating a custom text category in Azure AI Content Safety, you call the PUT /contentsafety/text/categories/{categoryName} endpoint and provide a JSON body that includes:

categoryName : the identifier of your category.

definition : a natural-language description of what the category covers (e.g., “text prompts about learning advice while preparing for an exam”).

sampleBlobUrl : a pointer to labeled sample data (typically a JSONL file in Azure Storage) used to help the service understand the category.

Keys like prompt or text are used when analyzing content (for example, text:detect ), not when defining a category. Likewise, blocklistName applies to blocklist operations, and outputType is not part of the category-creation schema. Therefore, the correct payload fields to complete the cURL are definition and sampleBlobUrl .

Microsoft Azure AI References (titles only)

Azure AI Content Safety – Create or update custom text categories (REST)

Azure AI Content Safety – Custom categories concepts and training data (JSONL in blob storage)

Azure AI Content Safety – Text analysis vs. category management endpoints

To quickly improve a GPT-3.5 chatbot’s response quality with minimal development effort:

Provide grounding content (B): Ground the model with authoritative data (e.g., the travel agent’s policies, inventory, fares) using Azure OpenAI on your data or a lightweight RAG pattern. Grounding reduces hallucinations and makes answers more accurate and context-aware without retraining the model. This typically involves configuring a data connection (Azure Cognitive Search/Blob) and augmenting prompts—far less effort than training.

Add sample request/response pairs (C): Use few-shot examples directly in the system/user messages to demonstrate ideal answers, style, and formatting. Few-shot prompting is a core prompt-engineering technique that meaningfully boosts quality with minimal code changes or infrastructure.

Options A, D, and E involve model training or retraining (fine-tuning or building a custom LLM), which require data preparation, experimentation, monitoring, and higher cost/complexity—contrary to the “minimize development effort” constraint.

Microsoft References

Prompt engineering with examples (few-shot) to improve output quality:

Azure OpenAI “on your data” (grounding to improve relevance and accuracy):

Guidance comparing prompt engineering/grounding with fine-tuning and when to use each:

How-to: Fine-tuning (shows added complexity vs. prompt techniques):

To build narration for video training content using Custom Neural Voice, we must know where each step is done:

Creating a Custom Neural Voice

A Custom Neural Voice is a text-to-speech (TTS) feature within Azure AI Speech.

It allows you to create a unique, natural-sounding synthetic voice.

The correct tool to build and configure a custom voice is the Speech Studio portal.

Not the Language Understanding portal (LUIS), Azure portal directly, or Bot Framework Composer.

Generating narration

Narration requires converting written text into speech.

This is done via the Text-to-Speech service in Azure AI Speech.

Other options:

Language Understanding → For intent/utterance processing, not narration.

Speaker Recognition → For identifying/authenticating speakers, not narration.

Speech-to-text → Converts spoken words to text (the opposite direction).

Thus:

Custom Neural Voice → Speech Studio portal

Narration → Text-to-speech

Correct Answers:

Custom neural voice: The Speech Studio portal

Narration: Text-to-speech

Microsoft References

Custom Neural Voice in Speech Studio

Text-to-Speech overview

Named Entity Recognition (NER) is one of the features offered by Azure Cognitive Service for Language, a collection of machine learning and AI algorithms in the cloud for developing intelligent applications that involve written language. The NER feature can identify and categorize entities in unstructured text. For example: people, places, organizations, and quantities.

Scenario Recap:

IoT data from 100 machines × 50 sensors × 1-minute intervals for 1 year = 5,000 time series datasets .

Requirement: Detect unusual values (outliers) to predict failures.

Correct Service:

Azure Anomaly Detector (A) is designed for time-series anomaly detection.

It learns temporal patterns and detects anomalies in sensor/IoT data streams.

Other options:

Cognitive Search = full-text search

Form Recognizer = extract text/fields from documents

Custom Vision = image classification

Answer: A. Anomaly Detector

The scenario involves a Language Understanding (LUIS) or Conversational Language Understanding (CLU) model that has:

An intent called FindContact (used for searching a contact list).

Training phrases like:

“Find contacts in London”

“Who do I know in Seattle?”

“Search for contacts in Ukraine”

Key Requirement

The model must recognize locations (London, Seattle, Ukraine) inside the FindContact intent.

Why the Solution is Incorrect

The proposed solution is to create a new intent for location.

This is not correct because:

Intents represent what the user wants to do (the action, e.g., FindContact ).

Entities represent details within the user’s utterance (the data, e.g., location ).

Here, the intent is already defined: FindContact .

Location should be modeled as an entity (Location entity), not as a separate intent.

Creating a new intent for each location (London, Seattle, Ukraine) would fragment the model and make it harder to generalize. Instead, the model should capture location as a parameter of the single intent FindContact .

Correct Approach

Keep the existing FindContact intent.

Add an entity for location (prebuilt GeographyV2 in LUIS or “Location” entity in CLU).

Train the model so that London , Seattle , Ukraine are recognized as entity values inside the FindContact intent.

Correct Answer: B. No

Microsoft References

Intents and entities in Language Understanding

Prebuilt entity: GeographyV2

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.

Instead, you could migrate to a Cognitive Search service that uses a higher tier.

Note: A simple fix to most throttling issues is to throw more resources at the search service (typically replicas for query-based throttling, or partitions for indexing-based throttling). However, increasing replicas or partitions adds cost, which is why it is important to know the reason why throttling is occurring at all.

Comprehensive Detailed Explanation

To 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) .

Train and publish a Question Answering project:

Microsoft Learn – Create, train, and publish projects (Question Answering) .

Language service overview and regional deployment concepts:

Microsoft Learn – What is Azure AI Language?

Comprehensive Detailed Explanation

The scenario:

You are building an Azure WebJob to create knowledge bases from an array of URLs.

You already have a QnAMakerClient object instantiated with the relevant API keys.

You need to know what steps are required to create a knowledge base programmatically.

Step 1 – Create a CreateKbDTO object

CreateKbDTO is the request payload for creating a knowledge base.

It contains the name of the knowledge base and its sources, which may include:

A list of URLs.

A list of QnA pairs ( QnADTO ).

A list of files ( FileDTO ).

In this case, since the WebJob provides URLs, they will be passed inside the CreateKbDTO.Sources property.

Step 2 – Call client.Knowledgebase.CreateAsync

Once the CreateKbDTO object is defined, you use the QnAMakerClient to send the request:

var response = await client.Knowledgebase.CreateAsync(createKbDTO);

This triggers the asynchronous creation of a new knowledge base in the QnA Maker service.

Why not A or C?

A. Create a list of FileDTO objects: Not required here, because the question specifies URLs, not files.

C. Create a list of QnADTO objects: Also not needed, since you’re not directly supplying QnA pairs; the knowledge base will be built from URLs.

Correct Answer

B. Call the client.Knowledgebase.CreateAsync method.

D. Create a CreateKbDTO object.

Microsoft References

QnA Maker – Create Knowledge Base API

QnAMakerClient Class – Azure SDK for .NET

CreateKbDTO Class

The question is about creating an Azure Cognitive Services resource programmatically with C#.

Key requirements from the question:

Free resource → This requires the F0 (Free) pricing tier.

West US region → Location should be " westus " .

Generate captions of images automatically → This requires the Computer Vision service.

Option Analysis

A. create_resource(client, " res1 " , " ComputerVision " , " F0 " , " westus " )

Uses " ComputerVision " kind → Correct, because Computer Vision provides the image captioning feature.

Tier is " F0 " → Correct, free tier.

Location " westus " → Correct.

This is the correct answer.

B. create_resource(client, " res1 " , " CustomVision.Prediction " , " F0 " , " westus " )

Custom Vision is for building and deploying custom image classifiers.

The Prediction resource is specifically for running inference, not general captioning.

Wrong service for the requirement.

C. create_resource(client, " res1 " , " ComputerVision " , " S0 " , " westus " )

" ComputerVision " is correct.

But " S0 " is a paid tier, not the required free tier.

Does not meet the requirement.

D. create_resource(client, " res1 " , " CustomVision.Prediction " , " S0 " , " westus " )

Wrong service (captioning is not handled by Custom Vision).

Wrong tier (paid instead of free).

Incorrect.

Correct Answer: A. create_resource(client, " res1 " , " ComputerVision " , " F0 " , " westus " )

Microsoft References

Azure AI Computer Vision documentation

Create a Cognitive Services resource in Azure

Computer Vision capabilities – Image analysis and captioning

A view is a virtual table based on the result set of a query.

Views allow you to encapsulate complex queries (including joins and calculated columns) and make them reusable by other users.

Index improves performance but does not store or rerun queries.

Scalar function returns a single value, not a tabular result.

Table stores raw data, not queries.

An ML entity can be composed of smaller sub-entities, each of which can have its own properties. For example, Address could have the following structure:

Address: 4567 Main Street, NY, 98052, USA

Building Number: 4567

Street Name: Main Street

State: NY

Zip Code: 98052

Country: USA

Comprehensive Detailed Explanation

You are tasked with building a solution using Custom Vision to detect faults in factory components. Custom Vision follows a defined workflow:

Create a project

Before anything else, you must create a Custom Vision project in the Azure AI portal.

This project specifies the type of model you are building: classification (classifying entire images) or object detection (locating items within images).

Since the question is about detecting faults in specific components (a business-specific scenario), it aligns with classification unless explicitly stated otherwise.

Upload and tag images

You must provide training data.

Upload a set of images showing both faulty and non-faulty components.

Tag each image correctly so that the model can learn from labeled examples.

Train the classifier model

Once images are tagged, you run training on the dataset to generate the classifier model.

The model can then be published and used for inference via API calls.

Why not the other options?

Initialize the training dataset: This is not a direct step in Custom Vision; instead, uploading and tagging images inherently prepares the training dataset.

Train the object detection model: Object detection is used if you need bounding boxes around items within an image. Since the question is about recognizing faults in a component (faulty vs non-faulty), a classifier model is appropriate.

Correct Sequence:

Create a project

Upload and tag images

Train the classifier model

Microsoft References

Quickstart: Build an image classification project with the Custom Vision portal

Custom Vision overview

Train and test a Custom Vision model

To let an Azure AI Agent access publicly available, recent web content, you add the Bing grounding tool. In the SDK, you first define a ToolConnectionList with the Bing connection ID (here, " bingConnectionId " ), then construct a BingGroundingToolDefinition(connectionList) so the agent can call Bing Search with recency filters (e.g., last 90 days) when answering questions.

When creating the agent, tool definitions are passed via the tools: parameter of CreateAgentAsync(...) as a List < ToolDefinition > . The toolResources parameter is used when you must also supply resource descriptors (for example, an Azure AI Search index configuration), which is not needed here because the Bing grounding tool already references the connection through the ToolConnectionList .

Therefore:

Use BingGroundingToolDefinition to ground the agent on current public web data.

Provide that tool in tools: new List < ToolDefinition > { grounding } when calling CreateAgentAsync(...) .

Microsoft Azure AI References (titles only)

Azure AI Agent Service – Bing web grounding tool (tool definitions and connections)

Azure AI Agent Service SDK – Agent creation ( CreateAgentAsync parameters: tools vs toolResources )

Azure AI Agent Service – Tool connections and ToolConnectionList usage

The Cognitive Services OpenAI User role grants least-privilege read/use permissions: view resource endpoints, list available models, use existing deployments in Azure OpenAI Studio (e.g., generate text and images ). It cannot create or manage deployments (that would require Cognitive Services OpenAI Contributor ), satisfying least-privilege.

References

Azure OpenAI built-in roles: OpenAI User vs OpenAI Contributor .

Azure RBAC for Azure AI services.

In the Bot Framework SDK, if you want to collect structured input step by step, you typically use a Waterfall dialog. Each step in the waterfall represents one piece of logic, such as asking for the size, toppings, or type of food item.

Prompts are used inside waterfall steps to actually ask the user for input (e.g., text prompt, choice prompt, date-time prompt).

Adaptive, Action, Input are concepts more relevant to Power Virtual Agents or Adaptive Dialogs (Composer), not the Bot Framework SDK question context.

Since the question specifically mentions Bot Framework SDK, the correct answer is Waterfall dialog + Prompts.

Correct Answer: C, D

 The text value must use JSON-formatted text. No

 The command will analyze inputted text and identify whether the text contains published song lyrics. Yes

 The Ocp-Apim-Subscription-Key value must contain the ID of the Azure subscription that hosts Resource1. No

Comprehensive Detailed Explanation

The cURL calls the Protected Material detection endpoint:

POST {endpoint}/contentsafety/text:detectProtectedMaterial?api-version=2024-09-01.

This API expects a JSON body with a text property whose value is a plain string (the content to check). The body is JSON, but the text value itself is not required to be “JSON-formatted text”; it’s just ordinary text inside a JSON payload. Hence, statement 1 is No . Microsoft Learn

The Protected Material (text) feature “flags any known text content … such as song lyrics , articles, recipes, and selected web content.” Therefore, this command will analyze the input and can identify whether it contains published song lyrics. Statement 2 is Yes .

Ocp-Apim-Subscription-Key is the API (resource) key used to authenticate requests to Azure AI services or APIs fronted by API Management. It is not the Azure subscription ID . Authentication guidance explicitly states the header carries a resource key or token; API Management documentation identifies Ocp-Apim-Subscription-Key as the subscription key header. Therefore, statement 3 is No .

Microsoft Azure AI References

Detect Text Protected Material – REST API (endpoint, request/response schema): Microsoft Learn

Protected material detection (concepts; includes song lyrics examples): Microsoft Learn

What’s new in Azure AI Content Safety (mentions protected material detection for lyrics): Microsoft Learn

Azure AI services authentication (resource key in headers): Microsoft Learn

API Management subscriptions (meaning of Ocp-Apim-Subscription-Key): Microsoft Learn

Comprehensive Detailed Explanation

Looking at the exhibit:

The GetWeather dialog is set up with a trigger phrase:

“what is the weather like in {city=Seattle}”

Here, city is an entity (ex: Seattle, New York, London, etc.).

1. User asks “what is the weather like in New York”

Since “New York” matches the city entity, the bot will correctly identify New York as a city entity.

It will not confuse it with a state entity, nor default to Seattle, because entity recognition extracts the correct city name dynamically.

Correct choice: Identify New York as a city entity

2. GetWeather dialog trigger

In Bot Framework Composer, the trigger type determines how the dialog is activated.

Since GetWeather is linked to the intent “GetWeather” from the Language Understanding model (LUIS/CLU), the trigger is Language Understanding Intent recognized.

This means whenever the user utterance maps to the GetWeather intent, the dialog starts.

Correct choice: Language Understanding Intent recognized

Correct Answer:

Identify New York as a city entity

Language Understanding Intent recognized

Microsoft References

Bot Framework Composer – Triggers

Entities in Conversational Language Understanding

Comprehensive Detailed Explanation

The screenshot shows a Bot Framework Composer dialog that collects user input:

user.name is an entity.

False.

user.name is a property in bot state (a variable), not an entity.

Entities are part of LUIS/NLU models (e.g., PersonName, DateTime).

The dialog asks for a user name and a user age and assigns appropriate values to the user.name and user.age properties.

True.

The dialog explicitly has:

A Bot Asks (Text) step → assigns user’s response to user.name .

A Bot Asks (Number) step → assigns response to user.age .

So the values are stored in those properties.

The chatbot attempts to take the first non-null entity value for userName or personName and assigns the value to user.name.

True.

On the right-hand side, the Value expression is:

=coalesce(@userName, @personName)

coalesce returns the first non-null value.

This means if userName entity is available, it is used; otherwise, personName is used.

That result is assigned to user.name .

Correct Answers:

No

Yes

Yes

Microsoft References

Bot Framework Composer - Manage variables and properties

Bot Framework Composer - Recognizers and entities

Coalesce function in Composer expressions

The wiki contains text in English, French and Portuguese.

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

The Document Extraction skill extracts content from a file within the enrichment pipeline. This allows you to take advantage of the document extraction step that normally happens before the skillset execution with files that may be generated by other skills.

Note: The Translator Text API will be used to determine the from language. The Language detection skill is not required.

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. < field > .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

Microsoft References

Azure AI Document Intelligence – Confidence scores

Human-in-the-loop for Document Intelligence

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.

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:

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.

Step 1: Create a new project and load sample documents

Create a new project. Projects store your configurations and settings.

Step 2: Label the sample documents

When you create or open a project, the main tag editor window opens.

Step 3: Train a custom model.

Finally, train a custom model.

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.