Pass the Microsoft Certified: Azure AI Fundamentals AI-901 Questions and answers with Dumpstech

Microsoft Foundry Agent Service documentation states that instructions define goals, constraints, and behavior for an agent. Therefore, instructions are used to guide how the generative AI model or agent should respond and behave.

Option A is correct because instructions can define constraints the model must follow.

Option B is correct because instructions can define the agent’s role and behavior.

Options C, D, and E are incorrect because Azure region, model selection, and TPM allocation are configuration or deployment/resource settings, not purposes of prompt instructions.

client = OpenAI(

api_key="...",

base_url="https://resource1.openai.azure.com/openai/v1/",

)

response = client.responses.create(

model="my-mini-gpt",

)

For Azure OpenAI in Microsoft Foundry, the base_url uses the Azure OpenAI resource name in the endpoint format:

https:// < resource-name > .openai.azure.com/openai/v1/

In the question, the Azure OpenAI resource is named Resource1 , so the first blank must be resource1 . Microsoft documentation for Azure OpenAI v1 endpoints confirms that the endpoint must use the ...openai.azure.com/openai/v1/ path.

For the model parameter, Azure OpenAI requires the deployment name , not the underlying model name. Microsoft states that Azure OpenAI always requires the deployment name when calling APIs, even when the parameter is named model.

The deployed model is gpt-4.1-mini , but the deployment name is my-mini-gpt . Therefore, the second blank must be:

model="my-mini-gpt"

So the correct selections are:

base_url blank = resource1

model blank = my-mini-gpt

Azure Content Understanding analyzers define the type of content to process, such as documents, images, audio, or video , and what to extract, such as text, layout, fields, transcripts, and structured JSON output. Microsoft lists base analyzer types such as prebuilt-document, prebuilt-audio, prebuilt-video, and prebuilt-image.

For scanned invoices in PDF format , the correct choice is document analyzer , because invoices are document/form content. Microsoft’s Content Understanding quickstart specifically uses the prebuilt-invoice analyzer to extract structured data from an invoice PDF.

For voicemail recordings in WAV format , the correct choice is audio analyzer , because voicemail is audio content. Content Understanding supports structured data extraction from audio files, and the analyzer reference identifies prebuilt-audio as the base analyzer for audio content.

Statement 1: The Temperature parameter can be set before deploying a model. = No

temperature is an inference/request parameter used when calling or testing a deployed model. It controls randomness in generated responses. It is not a required setting for deploying the model itself.

Statement 2: During inference, the model name is used to route requests to a specific deployment. = No

In Azure OpenAI / Microsoft Foundry deployments, application requests are routed to a specific deployment name , even when the SDK parameter is called model. The underlying model name, such as gpt-4.1-mini, is not what routes the request to the deployment.

Statement 3: After a model is deployed, both code and testing tools can be used to interact with the model. = Yes

After deployment, you can test the model in Foundry playground/testing tools or call the deployment from application code by using the endpoint, deployment name, and authentication credentials.

The correct Python method is:

recognizer.recognize_once()

Completed code:

import azure.cognitiveservices.speech as speechsdk

speech_config = speechsdk.SpeechConfig(subscription=key, region=region)

recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

recognizer.recognize_once()

Microsoft’s Azure Speech documentation for Foundry Tools explains that Speech to text is used for real-time speech recognition and converting spoken audio into text. The Python Speech SDK uses a SpeechRecognizer object for recognition from audio input, such as a microphone.

Why the other options are incorrect:

recognizer.speak_text_async("Ready") is incorrect because speaking text is text-to-speech , not speech-to-text recognition.

recognizer.start_continuous_recognition() can be used for continuous recognition, but the code shown is asking for the basic method to recognize spoken input and convert it to text from the SpeechRecognizer.

recognizer.start_keyword_recognition() is used for keyword/wake-word recognition, not general speech-to-text transcription of spoken commands.

Therefore, the correct answer is:

recognizer.recognize_once()

For thousands of recorded support calls stored as audio files in Azure Storage, the correct capability is speech to text batch transcription .

Microsoft states that batch transcription is designed to transcribe a large amount of audio data in storage , including audio files in Azure Blob Storage, and that files can be processed concurrently to reduce turnaround time.

Real-time transcription is for live audio, not large stored batches. Text to speech converts text into audio. Speech translation translates speech between languages, but the requirement is to generate transcripts.

For a vision-enabled model, Microsoft documentation shows that multimodal prompts can include both text and image content in the same user message content array. Azure OpenAI vision models accept multimodal image-and-text input and return natural language responses.

The correct request structure is a user message with a content array containing both items, for example:

{

"role": "user",

"content": [

{"type": "input_text", "text": "What is in this image?"},

{"type": "input_image", "image_url": image_url}

]

}

This avoids sending separate requests and is therefore the best choice for quickest response time.

A and C are incorrect because they send the text and image separately.

B is incorrect because the image/question should be sent as a user message, while system messages are used for instructions and behavior.

The completed sentence is:

An AI workload that produces new content based on user input is an example of generative AI .

Generative AI is used to create new content, such as text, images, code, audio, or other outputs, from user prompts or instructions.

The other options are incorrect:

content understanding extracts or interprets information from existing content.

information extraction identifies and extracts structured data from content.

text analysis analyzes existing text for entities, sentiment, key phrases, language, or summaries.

The completed code is:

poller = client.begin_analyze(

analyzer_id="invoice",

input_url=url

)

result = poller.result()

Azure Content Understanding analysis uses a long-running operation pattern. The Python SDK returns a poller from begin_analyze(), and Microsoft documentation states that the SDK poller handles polling automatically when you call .result() .

Therefore, to retrieve the analysis results after processing completes, the correct option is:

result

The other options are incorrect because status checks operation state, wait waits without returning the final analysis object, and get_results is not the method shown for retrieving the begin_analyze() result in this code pattern.

AudioOutputConfig(filename="output.wav")

The question specifically states the application must save the synthesized audio to a file . In the Azure Speech SDK for Python, speechsdk.audio.AudioOutputConfig(filename="output.wav") directs the synthesizer to write the generated speech output directly to a WAV file on disk — which is exactly the requirement.

Why the other options are wrong:

AudioOutputConfig(stream) — This routes audio output to an in-memory audio stream object, not a file. It is used when you want to process or play the audio programmatically without saving it to disk.

AudioStreamFormat(wave_stream_format=AudioStreamWaveFormat.PCM) — This class defines the format of an audio stream (e.g., PCM encoding, sample rate). It is used when configuring custom audio streams, not when specifying a file output destination. It is not a valid argument for speechsdk.audio. in this context.

The correct and complete line is:

audio_config = speechsdk.audio.AudioOutputConfig(filename="output.wav")