Sign in
Home/Microsoft/Microsoft Azure AI Fundamentals (AI-901)/Free questions

Microsoft Azure AI Fundamentals (AI-901) — Free Practice Questions

10 free sample questions from a bank of 37, with the correct answers and explanations. No signup required — start practising right now.

1You are using the Azure Speech SDK to develop a Python application that supports real-time spoken conversations. Which Azure Speech class should you use to configure the connection to the Azure Speech service?
  • AudioOutputConfig
  • SpeechSynthesizer
  • AudioConfig
  • SpeechConfig
Answer: D

Q1 - Correct answer: D. SpeechConfig.

The short version

Real-time spoken conversation in the Azure Speech SDK starts with a SpeechConfig: it carries your Speech resource key and region (or endpoint, host or authorization token) plus the source language, and you pass it into whichever engine you build. It answers "how do I reach the service", not "where does audio come from" or "how do I make audio".

Key concepts

  • SpeechConfig - the connection/configuration object: subscription key + region, endpoint, host or token, plus speech_recognition_language and service properties.
  • SpeechRecognizer - speech-to-text engine; consumes SpeechConfig and an optional AudioConfig.
  • SpeechSynthesizer - text-to-speech engine; also consumes SpeechConfig.
  • AudioConfig / AudioOutputConfig - audio input selection (default microphone, file, stream) and audio output selection (file or stream).

Why D is correct

The stem asks which class "configures the connection to the Azure Speech service". That is precisely the role of SpeechConfig, created like speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion") or from an endpoint / host / token. Every conversation turn - recognized user speech and synthesized replies - depends on that object holding the right credentials, region and language.

Why the others are wrong

  • A. AudioOutputConfig - describes where synthesized audio is written, e.g. AudioOutputConfig(filename="output.wav"). It is output plumbing for speech synthesis and contains no connection information.
  • B. SpeechSynthesizer - the text-to-speech engine. Real-time conversation needs it only to speak the agent's reply; it does not configure the connection to the service.
  • C. AudioConfig - selects the audio input (default microphone, a WAV file, a push stream). You pass it to a recognizer to say where sound comes from, which is a different concern from how you authenticate and where you connect.

AI-901 exam tip

Bucket every Speech SDK class into config / audio-IO / engine before you read the options. "Configure the connection" is always SpeechConfig; "read from microphone" is AudioConfig; "write to file or stream" is AudioOutputConfig; "recognize" and "synthesize" are the two engines.

2You are developing an application that analyzes uploaded video files by using Azure Content Understanding in Foundry Tools. You need to ensure that the application extracts structured information from the videos. What should the application call?
  • Azure Language in Foundry Tools sentiment analysis
  • the Analyze API in Content Understanding
  • the Image Analysis API in Azure Vision in Foundry Tools
  • Azure OpenAI
Answer: B

Q33 - Correct answer: B. the Analyze API in Content Understanding.

The short version

Azure Content Understanding in Foundry Tools is driven by analyzers. You submit content (document, image, audio or video) to the Analyze operation of the analyzer you built or picked, and the service returns structured fields plus markdown/transcript content. Everything else on this row is either a different service or a different kind of API.

Key concepts

  • Azure Content Understanding - a multimodal service that "analyzes and comprehends various media content - such as documents, images, audio, and video - transforming it into structured, organized, and searchable data".
  • Analyzers - "a configurable processing unit that defines how your content is analyzed and what information is extracted": the modality, the fields, and the extraction methods (extract, generate, classify).
  • Analyze operation - POST {endpoint}/contentunderstanding/analyzers/{analyzerId}:analyze?api-version=2025-11-01; the REST reference summarises it as "Extract content and fields from input." Results come back asynchronously, so the SDK hands you a poller.
  • AudioVisual modality - for video, the response carries transcriptPhrases, fields, key frames and timing data, which is what a video-understanding app consumes.

Why B is correct

The question asks how the application "extracts structured information from the videos". Structured extraction in Content Understanding is the analyzer's job, and the operation that runs it is the Analyze API. Submit the video URL or binary to the analyzer, poll the operation, then read fields (and transcriptPhrases) out of the result.

Why the others are wrong

  • A. Azure Language in Foundry Tools sentiment analysis - sentiment analysis is a text-level opinion model in Azure AI Language. It returns a sentiment label and score, not schema-driven fields extracted from video frames or audio tracks.
  • C. the Image Analysis API in Azure Vision in Foundry Tools - Image Analysis works on still images (tags, captions, OCR, objects). Video needs temporal analysis - key frames, timing, transcript - which only Content Understanding's analyzer provides.
  • D. Azure OpenAI - a multimodal Azure OpenAI model can describe a video's frames if you feed it frames, but it is not the service that returns analyzer-defined structured fields, and it has no video understanding operation. The row is asking for the extraction surface, which is Content Understanding.

AI-901 exam tip

Learn the mapping: "extract structured fields from documents / audio / video / images" -> Azure Content Understanding analyzer + Analyze operation. "Describe an image" -> Azure AI Vision. "Explain, summarise or draft text" -> a generative AI model on Azure OpenAI Service.

3You need to create an AI agent in Microsoft Foundry that follows a specific role and behavior when responding to users. What should you configure?
  • system instructions
  • temperature
  • tokens per minute (TPM)
  • max completion tokens
Answer: A

Q3 - Correct answer: A. system instructions.

The short version

Foundry agents are defined by text. The instructions field states the agent's role - "you are a returns specialist for Contoso" - and the rules it must follow, and that text is replayed into every turn. Nothing about temperature, quota or token ceilings makes an agent behave like a particular role.

Key concepts

  • Agent instructions - persistent, server-side prompting: "An agent defines core behavior. Once created, it ensures consistent responses in user interactions without repeating instructions each time."
  • System / developer message - the raw-API equivalent, outranking user input in the instruction hierarchy.
  • Temperature - sampling randomness; variety, not persona.
  • TPM and max_tokens - a deployment rate limit and a response-length ceiling respectively; capacity and cost controls.

Why A is correct

In the Foundry SDK an agent is created with a definition such as PromptAgentDefinition(model=..., instructions="You are a helpful assistant that answers general questions"). Role, audience, tone and hard boundaries all live in that string, which is why instructions - and only instructions - make the agent "follow a specific role and behavior".

Why the others are wrong

  • B. temperature - controls how random token selection is. It can make a reply more varied or more repetitive, but it cannot attach a role; the same model at temperature 0 is still a generic assistant.
  • C. tokens per minute (TPM) - a throughput quota applied to the deployment. Setting or reading it changes capacity, not conduct, and no prompt text moves it.
  • D. max completion tokens - caps reply length. It can force brevity, which changes style, but it cannot teach a model what it is supposed to be responsible for.

AI-901 exam tip

Agent questions split cleanly: identity and behaviour -> instructions; output style -> temperature / Top P; spend and length -> max completion tokens; capacity -> TPM and deployment rate limits. Never pick a knob from the wrong column.

4You are developing an application that uses the Azure Language SDK and a Microsoft Foundry resource. You need to return a list of important topics from unstructured text. Which Python method should you use?
  • client.begin_extract_summary()
  • client.extract_key_phrases()
  • client.recognize_linked_entities()
  • client.recognize_entities()
Answer: B

Q34 - Correct answer: B. client.extract_key_phrases().

The short version

"Return a list of important topics from unstructured text" is the textbook definition of key phrase extraction in Azure AI Language (Foundry Tools). The Python client method that does it is client.extract_key_phrases(...), which returns the salient phrases for each document. The other three methods on that client return something structurally different.

Key concepts

  • Azure AI Language in Foundry Tools - the language service whose text analytics features include key phrase extraction, named entity recognition, entity linking, sentiment analysis and summarization.
  • Key phrase extraction - "use key phrase extraction to quickly identify the main concepts in text"; it returns the main talking points and discards non-essential words, with no confidence score.
  • Python client (azure-ai-textanalytics) - TextAnalyticsClient; the docs' quickstart calls response = client.extract_key_phrases(documents = documents)[0] and then iterates response.key_phrases.
  • Topics vs entities vs summaries - topics (key phrases) are the subject matter; entities are named things; a summary is generated prose. Choosing the right capability matters as much as choosing the right service.

Why B is correct

extract_key_phrases() is the only method on the client that returns the main talking points of a body of text as a list of phrases, which is exactly the "list of important topics" the requirement asks for. It is synchronous and stateless, so it fits a request-response application.

Why the others are wrong

  • A. client.begin_extract_summary() - a summarizer returns generated prose (an abstractive or extractive summary), not a list of topic phrases. It also has to be polled, which is unnecessary work for a topic list.
  • C. client.recognize_linked_entities() - entity linking resolves mentions to entries in a public knowledge base such as Wikipedia and returns canonical IDs. That answers "who/what is this and where is it documented", not "what are the topics".
  • D. client.recognize_entities() - plain named entity recognition returns people, organizations and locations with categories and confidence. It finds proper nouns, so it misses the topical themes ("refund policy", "shipping delay") that key phrase extraction returns.

AI-901 exam tip

Learn the Azure AI Language method-to-capability map cold: extract_key_phrases = topics, recognize_entities = named entities, recognize_linked_entities = entities with knowledge-base IDs, begin_extract_summary = generated summary. The verb in the method is the give-away.

5You are developing a web app that processes invoices to calculate expenses. You need to extract structured fields, including nested values, from the invoices by using a defined schema. What should you use?
  • an optical character recognition (OCR)-only document processing pipeline
  • a transcription workflow in Azure Speech in Foundry Tools
  • an analyzer in Azure Content Understanding in Foundry Tools
  • an Azure AI Search service
Answer: C

Q5 - Correct answer: C. an analyzer in Azure Content Understanding in Foundry Tools.

The short version

The schema is the giveaway. You declare fields - vendor, date, total, and nested line items - and an Azure Content Understanding analyzer maps document content onto them, returning typed values in a fields object. OCR, transcription and search each fail on at least one of the three requirements: structured output, nested values, your own schema.

Key concepts

  • Azure Content Understanding - transforms "documents, images, audio, and video" into "structured, organized, and searchable data"; it is one of the Foundry Tools.
  • Analyzers - "a configurable processing unit that defines how your content is analyzed and what information is extracted"; a custom analyzer is created from a JSON field schema with extract, generate and classify methods.
  • Field extraction - each field returns a typed ContentField; arrays and objects allow nested line items.
  • Prebuilt analyzers - ready-made schemas for invoices, receipts, tax forms and identity documents, usable before you build your own.

Why C is correct

The application needs machine-readable line items with quantities and unit prices under a total, driven by a schema you own. That is precisely an analyzer's contract: you submit the invoice to the Analyze operation, poll it, and read the structured fields (including the nested array) out of the result - no hand-written parsing rules.

Why the others are wrong

  • A. an optical character recognition (OCR)-only document processing pipeline - OCR yields characters and bounding boxes. "Total" and the repeated line-item blocks are just text until you write the code that groups and types them, which is exactly the maintenance burden the analyzer removes.
  • B. a transcription workflow in Azure Speech in Foundry Tools - the Speech service turns audio into text. Invoices are documents, so transcription is irrelevant here and returns no structured fields.
  • D. an Azure AI Search service - Azure AI Search indexes and queries documents and returns matches. It can use a Content Understanding skill as an index enricher, but it is the retrieval layer, not the field extractor.

AI-901 exam tip

Memorise the four-way triage: schema-bound extraction -> Content Understanding analyzer; raw text from a page -> OCR / Document Intelligence; audio -> text -> Azure Speech; search over a corpus -> Azure AI Search.

6You are developing an application that records a user’s voice and sends the recorded audio to a deployed multimodal model in Microsoft Foundry. You need to send the user’s request to the model. What should you include in the request?
  • an image of the audio frames
  • a text transcript of the voice
  • an audio input prompt
  • a text embedding vector
Answer: C

Q35 - Correct answer: C. an audio input prompt.

The short version

The application already has the user's request as audio. To let a deployed multimodal model in Microsoft Foundry answer that spoken request, you send the audio itself in the request - an audio input prompt, i.e. a content item of type input_audio carrying the base64-encoded audio and its format (for example wav). The docs are explicit that audio-capable models "use audio inputs to prompt the model".

Key concepts

  • Multimodal / audio-capable models - deployed in Microsoft Foundry (for example gpt-4o-audio-preview, gpt-4o-mini-audio-preview, or the Realtime family). Supported modality combinations include audio-in with text-out and audio-in with audio-out.
  • Chat completions content items - a user message's content array can mix typed items: {"type": "text", ...} and {"type": "input_audio", "input_audio": {"data": encoded_string, "format": "wav"}}.
  • Base64 payload - the audio bytes are read from the recording, base64-encoded, and passed as data; the format field tells the service how to decode it (wav, mp3, ...).
  • Azure Speech in Foundry Tools - the alternative path, where you transcribe first and prompt with text; that is a different architecture from "send audio to a multimodal model".

Why C is correct

The requirement is "send the user's request to the model" and the request is a recording. The only option that delivers that request in its native form is an audio input prompt - the typed audio content item in the request payload. The model then reasons over the actual speech, which is what a multimodal deployment with audio input is for.

Why the others are wrong

  • A. an image of the audio frames - a waveform or spectrogram rendering is a picture of audio, not audio. A vision-enabled model can describe pixels, but it loses phonetics, so the model's answer would be a guess about a drawing.
  • B. a text transcript of the voice - a transcript is a different request payload: it means you already ran a speech-to-text step (Azure Speech) and are now prompting a text model. The question keeps the request as recorded audio and sends it to the multimodal model, so a transcript is not what you include.
  • D. a text embedding vector - embeddings are numeric vectors used for similarity search and RAG retrieval, not for carrying a user request to a chat model. Nothing in the request body accepts an embedding vector as an instruction.

AI-901 exam tip

Read the scenario, not just the service name. If the app has raw audio and a multimodal model, the answer is an audio input prompt. If the app has audio but must use a text-only model, you must transcribe first with Azure Speech. Same input, different architecture, different answer.

7You are developing an application that continuously transcribes speech from a default microphone by using Azure Speech in Microsoft Foundry Tools. You need to perform speech-to-text transcription from the microphone. Which Python class should you use?
  • SpeechRecognizer
  • SpeechSynthesizer
  • SpeechConfig
  • AudioOutputConfig
Answer: A

Q36 - Correct answer: A. SpeechRecognizer.

The short version

In the Azure Speech SDK for Python, SpeechRecognizer is the class that performs speech-to-text recognition, and for a default-microphone stream you construct it with just the SpeechConfig. Everything else on this row is either the opposite direction (speech out) or a settings/IO object rather than the recognizer.

Key concepts

  • Azure Speech in Foundry Tools - the speech service behind the Speech SDK, offering real-time, fast and batch transcription plus synthesis, translation and custom speech.
  • SpeechConfig - the connection object: resource key/region (or endpoint, host or authorization token), source language, and other service properties. Shared by recognition and synthesis.
  • SpeechRecognizer - "a speech recognizer" that consumes a SpeechConfig and an optional AudioConfig, and returns recognition results.
  • Recognition modes - recognize_once() / recognize_once_async() for a single utterance; start_continuous_recognition() plus event callbacks for a continuous session; keyword recognition for wake-word flows.
  • SpeechSynthesizer + AudioOutputConfig - the synthesis path: text in, spoken audio written to a file or stream.

Why A is correct

The requirement is speech-to-text from a default microphone, continuously. SpeechRecognizer is the class that owns that behaviour - the docs' microphone sample is speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config) followed by recognize_once_async(), with start_continuous_recognition() for an ongoing session.

Why the others are wrong

  • B. SpeechSynthesizer - this is text-to-speech: it turns written text into audio. It is the answer to "read this notification aloud over the phone system", not to "transcribe what the microphone hears".
  • C. SpeechConfig - configuration, not capability. You pass SpeechConfig into SpeechRecognizer; it carries the key, region and language but recognizes nothing on its own.
  • D. AudioOutputConfig - an output-side helper describing where synthesized audio goes (AudioOutputConfig(filename="output.wav")). It belongs to the synthesis path and has nothing to do with recognizing microphone input.

AI-901 exam tip

For the Speech SDK, sort every class into one of three buckets - config (SpeechConfig), input (AudioConfig, AudioStreamFormat, PushAudioInputStream), output (AudioOutputConfig) - and one of two engines (SpeechRecognizer in, SpeechSynthesizer out). Then read the direction of the data in the stem.

8What are two purposes of instructions when prompting a generative AI model? Each correct answer presents part of the solution. NOTE: Each correct selection is worth one point.
  • defines the agent’s role and behavior
  • selects which model to use
  • defines the Azure region where inference occurs
  • defines the tokens per minute (TPM) allocation for the model
  • defines constraints on the model’s responses
Answer: A, E

Q8 - Correct answers: A and E. Instructions define the agent's role and behavior, and define constraints on the model's responses.

The short version

When you prompt a generative AI model, the instruction text does two jobs. It tells the model who it is and how it should behave, and it states the limits on what it may produce. Neither job is about infrastructure: you cannot pick a model, a region or a throughput quota from inside a prompt.

Key concepts

  • Instructions / system message - the leading, highest-priority content of a chat request; in Microsoft Foundry this is the agent's instructions field.
  • Prompt engineering - writing instructions with role framing plus explicit constraints (format, length, tone, forbidden content) so output is usable without heavy post-processing.
  • Foundry Agent Service - stores instructions server-side so a persona is applied consistently across every session.
  • Deployment configuration - model family and version, Azure region of the resource endpoint, and TPM / rate limits: chosen on the deployment, not in the prompt.

Why A and E are correct

A. defines the agent's role and behavior - "you are a travel agent", "answer as a bank teller", "be concise and cite sources" are all role and behaviour statements, and they live in the instruction text.

E. defines constraints on the model's responses - "at most three bullets", "respond in Japanese", "never invent a booking reference" are output constraints. They work precisely because the instruction states them, which is what prompt engineering exploits.

Why the others are wrong

  • B. selects which model to use - you deploy a model in Microsoft Foundry and then address it by deployment name (model="gpt-5-mini"). Prompt text is interpreted by whichever model received it; it cannot retarget the request.
  • C. defines the Azure region where inference occurs - geography is a property of the Foundry resource whose endpoint you call (https://<resource>.services.ai.azure.com/api/projects/<project>). No instruction moves compute.
  • D. defines the tokens per minute (TPM) allocation for the model - TPM is a rate limit on the deployment. Instructions change generation; they do not change quota, and a longer prompt generally adds input tokens rather than reducing throughput.

AI-901 exam tip

Split any option in half: does it describe what the model should do (instruction) or where/how much it runs (deployment)? Role and constraints are instructions; model, region and quota are not.

9You are developing a simple application that uses the Microsoft Foundry SDK to send chat prompts to a model. Which three elements should you provide in the code to run the application? Each correct answer presents part of the solution. NOTE: Each correct selection is worth one point.
  • the model deployment name
  • the task type
  • the Foundry project display name
  • Microsoft Entra ID credentials
  • the endpoint URL
Answer: A, D, E

Q37 - Correct answers: A, D and E - the model deployment name, Microsoft Entra ID credentials, and the endpoint URL.

The short version

Any Foundry SDK sample that sends chat prompts reduces to three values: where the request goes (the project endpoint URL), which deployed model should answer (the model deployment name), and who you are (credentials - Microsoft Entra ID / DefaultAzureCredential, or an API key). Everything else in the options is descriptive metadata that never appears in the call.

Key concepts

  • Microsoft Foundry project endpoint - https://<resource-name>.services.ai.azure.com/api/projects/<project-name>. The Foundry SDK is a thin client that exposes the project's APIs through this one endpoint.
  • Model deployment name - the name you chose when you deployed the model (the quickstart uses gpt-5-mini); it is passed in the model field and is what actually routes the request to a specific deployment inside the resource.
  • Credentials - keyless Microsoft Entra ID authentication via DefaultAzureCredential from azure-identity, after az login, or an API key. Either way, unauthenticated calls are rejected.
  • Client construction - AIProjectClient(endpoint=..., credential=...), then project.get_openai_client() (or FoundryChatClient) for chat completions / Responses calls.

Why A, D and E are correct

A. the model deployment name - the deployment name identifies the model inside your resource. The quickstart instructs you to keep the deployment you created and to "update the model name in the sample code" if you deployed under a different name.

D. Microsoft Entra ID credentials - the documented Foundry SDK samples "authenticate by using DefaultAzureCredential, which comes from azure-identity", after signing in with az login. That credential is what turns an anonymous HTTP call into an authorized one.

E. the endpoint URL - the samples' first placeholder is the project endpoint, "in the format https://<resource-name>.services.ai.azure.com/api/projects/<project-name>". Without it the client has nowhere to send the prompt.

Why the others are wrong

  • B. the task type - there is no "task type" parameter in a Foundry chat call. Modern Foundry models are prompted through the Responses or Chat Completions surface, where the request carries the deployment name, the input messages and optional sampling parameters. Older Azure OpenAI SDKs had a task_type on the completions client, but that is a deprecated API shape, not what the Foundry SDK takes.
  • C. the Foundry project display name - that is a friendly label for humans browsing the portal. The SDK uses the project endpoint URL; the display name is never sent on the wire and the endpoint already encodes the project.

AI-901 exam tip

Memorise the triad for "what must the application include to call the model": endpoint + deployment name + credentials. In real code these are the .env values FOUNDRY_PROJECT_ENDPOINT / AZURE_OPENAI_ENDPOINT, FOUNDRY_MODEL_NAME / AZURE_OPENAI_DEPLOYMENT_NAME, and a token credential - three values, one request.

10You are using the Azure Speech SDK to develop a Python application that supports real-time spoken conversations. Which Azure Speech class should you use to configure the connection to the Azure Speech service? Official Answer: D
  • AudioOutputConfig
  • SpeechSynthesizer
  • AudioConfig
  • SpeechConfig
Answer: D

Q11 - Correct answer: D. SpeechConfig.

The short version

Every Azure Speech SDK call starts by building a SpeechConfig - it holds your Speech resource key and region (or endpoint / host / authorization token) and the source language, and you hand it to whichever engine you instantiate. It is configuration, not a capability, which is why it is the answer to "configure the connection".

Key concepts

  • SpeechConfig - the connection object: subscription key plus region, or an endpoint, host, or token. Also carries speech_recognition_language, endpoint IDs for custom models, and service properties.
  • SpeechRecognizer - the speech-to-text engine that consumes a SpeechConfig and optional AudioConfig.
  • SpeechSynthesizer - the text-to-speech engine; it also needs a SpeechConfig.
  • AudioConfig / AudioOutputConfig - describe where audio comes from or goes to (a microphone, a file, a stream), not how you connect to the service.

Why D is correct

The stem asks which class "configures the connection to the Azure Speech service". SpeechConfig is exactly that: created with speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion"), or from an endpoint / host / authorization token. Real-time spoken conversations need it whether the audio comes from a microphone or a stream, because the recognizer, the synthesizer and voice live detection all read their endpoint and credentials from it.

Why the others are wrong

  • A. AudioOutputConfig - an output-side descriptor used by SpeechSynthesizer to say where synthesized audio is written (for example AudioOutputConfig(filename="output.wav")). It configures no connection to the service.
  • B. SpeechSynthesizer - that is the speech-generation engine (text in, audio out). Real-time conversation needs a recognizer for what the user says; a synthesizer can optionally read the reply back.
  • C. AudioConfig - it identifies the audio input device or file (default microphone, fromWavFileInput, a push stream). You pass it to a recognizer, but it carries no key, region or endpoint.

AI-901 exam tip

Memorise the Speech SDK object model as three families: configuration (SpeechConfig), audio IO (AudioConfig, AudioOutputConfig, AudioStreamFormat, PushAudioInputStream) and engines (SpeechRecognizer, SpeechSynthesizer). "Configure the connection" is always the first family.

Want the full bank of 37 questions for Microsoft Azure AI Fundamentals (AI-901)? See all practice exams.