AI-900 Free Practice Test

→ Why the correct answer is right:

Microsoft’s audio generation quickstart shows you must set modalities=[“text”, “audio”] to request spoken output, plus provide an audio object with voice and format settings like {“voice”: “alloy”, “format”: “wav”}. This tells the model to return both text and audio instead of text-only.

→ Why the other options are wrong:

Option A: modalities=[“text”] keeps the response text-only without audio output

Option C: The audio object alone is incomplete without the modalities parameter

Option D: response_format=”audio/wav” is not the documented pattern in Microsoft’s examples

Quick Memory Tip 🧠

“modalities = what you get back (text + audio), audio = how it sounds (voice + format)”

→ Why the correct answer is right:

Compare models is correct because Microsoft’s playground documentation says compare mode lets you run controlled, parallel evaluations across up to three models with synchronized input. It’s specifically designed for side-by-side output comparison in the model playground.

→ Why the other options are wrong:

Option A: Agents playground is for multi-turn agent prototyping with tools and memory, not parallel model comparison

Option B: Video playground is for video model workflows, not general text/chat model comparison

Option D: Metrics is for performance review dashboards, not the interactive comparison feature itself

Quick Memory Tip 🧠

“Compare models = side-by-side benchmarking (up to 3 models)”

→ Why the correct answer is right:

Microsoft’s deployment guide tells you to verify that the deployment status shows Succeeded in the deployment list after deployment completes. That’s the documented ready state before you proceed with normal use in the portal.

→ Why the other options are wrong:

Option A: Pending means provisioning is still underway, not complete

Option B: Draft is not the documented status in Foundry deployment steps

Option C: Running is not the verification state Microsoft explicitly calls out

Quick Memory Tip 🧠

“Succeeded = deployment is ready to use”

→ Why the correct answer is right:

Microsoft’s deployment documentation says you need the Cognitive Services Contributor role or equivalent permissions on the Foundry resource to create and manage deployments. Partner and community models also require Azure Marketplace access and permissions needed to subscribe to model offerings.

→ Why the other options are wrong:

Option A: Azure AI Search index is for retrieval grounding scenarios, not a deployment prerequisite

Option C: Agents playground tracing is for AgentOps analysis, not model deployment authorization

Option D: Video playground access is for video workflows, unrelated to deployment permissions

Quick Memory Tip 🧠

“Partner models = Contributor role + Marketplace permissions”

→ Why the correct answer is right:

Microsoft says the deployment name is used in the model parameter during inference to route requests to that particular deployment. When you copy a sample from the portal’s Code tab, the deployment name maps to the model field used by the request.

→ Why the other options are wrong:

Option B: endpoint is related but not the documented parameter for inference routing

Option C: deployment_type refers to characteristics like Global Standard, not the runtime identifier

Option D: project is for portal organization, not the parameter that routes inference requests

Quick Memory Tip 🧠

“model parameter = routes to your deployment”

→ Why the correct answer is right:

Microsoft’s tutorial shows using prebuilt-document as the base analyzer when creating a custom document analyzer. That is the correct parent analyzer for documents and forms, which determines the content type and supported configuration path.

→ Why the other options are wrong:

Option B: prebuilt-image is for image analyzers rather than document analyzers

Option C: prebuilt-audio is intended for audio content, not forms or document field extraction

Option D: prebuilt-documentFields is a utility analyzer for key-value pairs, not the base analyzer for custom document analyzer creation

Quick Memory Tip 🧠

“prebuilt-document = forms and document extraction”

→ Why the correct answer is right:

Statement 1 is incorrect because Microsoft says partner and community models require Azure Marketplace subscription, but models sold directly by Azure do not. The word “every” makes this statement wrong. Statement 2 is correct because Microsoft says you can type your prompt and see outputs in the playground after opening the deployed model. Statement 3 is also correct because the Code tab shows details about programmatic access to the deployment.

→ Why the other options are wrong:

Option A: Incorrectly marks Statement 1 as Yes and Statement 3 as No

Option B: Repeats the mistake of treating Marketplace subscription as universal and marks Statement 2 as No

Option D: Marks Statement 2 as No even though prompt testing in playground is a core documented step

Quick Memory Tip 🧠

“Marketplace = partner/community models only, not EVERY model”

→ Why the correct answer is right:

Microsoft’s deployment article says to make sure the New Foundry toggle is on, and the “What is Microsoft Foundry?” page repeats that the current version of the portal uses the New Foundry toggle in the banner. This is the documented switch for the current portal experience.

→ Why the other options are wrong:

Option A: AgentOps is tied to tracing and evaluation in agents playground, not the portal version toggle

Option C: Global Standard is a deployment type example, not a banner toggle for portal versioning

Option D: Compare models is a playground feature for side-by-side evaluation, not the portal banner setting

Quick Memory Tip 🧠

“New Foundry toggle = current portal experience”

→ Why the correct answer is right:

Microsoft’s audio generation quickstart says after deployment, you can interact with the model in the Foundry portal Chat playground. It specifically directs you to select Audio playground > Try the Chat playground for gpt-4o-mini-audio-preview. The Chat playground lets you record audio prompts, attach audio files, and enter text prompts.

→ Why the other options are wrong:

Option A: Agents playground is for agent scenarios with tools and memory, not direct deployed model audio testing

Option C: Model catalog is for browsing and discovering models, not interacting with deployed models

Option D: Speech Studio is for Azure Speech experiences, not the documented Chat playground workflow for Foundry audio-capable models

Quick Memory Tip 🧠

“Chat playground = record audio + test spoken prompts”

→ Why the correct answer is right:

The correct structure for inline spoken audio is an input_audio content item containing the encoded audio data and its format. Microsoft’s audio generation quickstart shows this exact request shape with {“type”: “input_audio”, “input_audio”: {“data”: encoded_string, “format”: “wav”}}. The model needs both the audio bytes and the format to process the spoken prompt correctly.

→ Why the other options are wrong:

Option A: Does not match Microsoft’s documented structure; leaves out the nested input_audio object and format field

Option B: speech_input is not the documented field name; the real structure uses input_audio

Option C: audio_url is for audio from cloud locations by URL, not inline base64-style payload

Quick Memory Tip 🧠

“input_audio = inline audio data + format”

→ Why the correct answer is right:

To send a spoken prompt, you need to include input_audio in the user content. Microsoft’s examples show spoken input being passed as an input_audio item with audio data and format inside the message content. To request spoken output, Microsoft’s audio generation examples use modalities=[“text”, “audio”] together with an audio configuration block, which tells the model to produce an audio response instead of text-only.

→ Why the other options are wrong:

Option A: image_url is for image input, not spoken input; it belongs to multimodal image scenarios

Option B: OCR is for extracting text from images or documents, not part of chat request structure for audio prompts

Option D: Foundry Agent Service memory matters in agent workflows but is not required for direct spoken-prompt interaction

Quick Memory Tip 🧠

“input_audio = spoken input, modalities=[text, audio] = spoken output”

→ Why the correct answer is right:

Appending the review record to an audit log is the best choice because accountability depends on traceability. Microsoft’s guidance on accountability highlights governance data and lineage, including who made changes, why they were made, and when deployments occurred. Without a record of the approver and reason, it becomes harder to investigate issues or justify decisions.

→ Why the other options are wrong:

Option A: Printing to console does not create a reliable audit trail; console output is temporary and not structured governance records

Option C: Overwriting reviewer with “system” reduces accountability instead of improving it by erasing who actually approved

Option D: Setting change reason to None removes useful governance context about why changes were made

Quick Memory Tip 🧠

“audit_log.append() = traceable accountability record”

→ Why the correct answer is right:

Microsoft’s multimodal chat completions documentation shows that when audio is available at an accessible cloud location, you pass it using a content item with “type”: “audio_url” and an audio_url object containing the URL. This is different from input_audio, which is used when you send encoded audio data directly in the request body.

→ Why the other options are wrong:

Option A: input_voice sounds plausible but Microsoft does not use that field name in documented multimodal request format

Option B: speech_url sounds intuitive but is not the field Microsoft documents; official examples use audio_url

Option D: audio_input is close in meaning but not the actual content item type for URL-based audio input

Quick Memory Tip 🧠

“audio_url = cloud location, input_audio = inline data”

→ Why the correct answer is right:

Statement 1 is correct. Microsoft explicitly says audio-enabled models introduce the audio modality into the existing /chat/completions API and supported modalities include text, audio, and text + audio. Statement 2 is also correct because Microsoft says the Chat playground lets you record audio prompts, attach audio files, and enter text prompts. Statement 3 is incorrect because the quickstart says the Audio playground does not support gpt-4o-mini-audio-preview and you should use the Chat playground instead.

→ Why the other options are wrong:

Option B: Marks Statement 2 as No (wrong) and Statement 3 as Yes (wrong); both contradict Microsoft documentation

Option C: Marks Statement 1 as No (wrong) and Statement 3 as Yes (wrong); reverses documented playground guidance

Option D: Marks Statement 1 as No and Statement 2 as No, but both are directly supported by Microsoft documentation

Quick Memory Tip 🧠

“Chat playground = test gpt-4o-mini-audio-preview, not Audio playground”

→ Why the correct answer is right:

Microsoft’s multimodal chat completions documentation lists a required prerequisite: a chat completions model deployment with support for audio and images. If you don’t already have one, the article tells you to add and configure a supported Foundry model first. Without a supported deployment, there is nothing for the application to call when sending audio input.

→ Why the other options are wrong:

Option A: Azure AI Search is useful for retrieval scenarios but not a prerequisite for basic multimodal chat completions with audio

Option B: OCR model training belongs to vision and text extraction scenarios, not speech input to multimodal chat models

Option C: Foundry Agent Service is not required just to use chat completions with audio on a deployed multimodal model

Quick Memory Tip 🧠

“Supported deployment = prerequisite for audio chat completions”

→ Why the correct answer is right:

Microsoft’s deployment instructions for the current Foundry portal say to sign in, ensure the New Foundry toggle is on, and then select Discover followed by Models to begin a new deployment. That is the documented entry point for deploying a model from the portal, mapping directly to the AI-901 objective about deploying and interacting with models.

→ Why the other options are wrong:

Option A: Build → Models is for managing existing deployments, not starting a brand-new deployment

Option C: Playground → Code is used after deployment exists for programmatic access, not the starting point for creating deployment

Option D: Agents → Knowledge confuses model deployment with agent setup; documented flow starts from Discover → Models

Quick Memory Tip 🧠

“Discover → Models = start new deployment”

→ Why the correct answer is right:

Microsoft’s deployment guide says Discover → Models is the starting path for deployment, the deployment details page lets you view endpoint details and keys, and the Code tab shows details about how to access the model deployment programmatically. These separate starting deployment, managing existing deployment, and moving from portal interaction into code.

→ Why the other options are wrong:

Option A: Wrong because New Foundry toggle is required for current portal steps, not classic portal steps (reverses the meaning)

Option C: Build → Models manages existing deployments; Marketplace subscription is handled during deployment flow, not as Build → Models purpose

Option E: Video playground appears for video models like Sora-2, not default destination for every deployed text model

Quick Memory Tip 🧠

“Discover = start, Build = manage, Code = programmatic access”

→ Why the correct answer is right:

Adding an input_audio content item with encoded data and format is correct because Microsoft’s examples use that exact structure for inline spoken input. Adding a text content item is also valid and common; Microsoft’s examples show a text instruction alongside audio input, such as asking the model to describe, translate, or respond to spoken audio.

→ Why the other options are wrong:

Option A: image_url is designed for image input, not audio bytes; it belongs to vision scenarios, not spoken-prompt scenarios

Option C: OCR is for extracting text from images/documents, not a replacement for chat completions with spoken input

Option E: Audio format belongs in input payload or output audio settings, not inside the model name

Quick Memory Tip 🧠

“input_audio + text guidance = spoken prompt pattern”

→ Why the correct answer is right:

Statement 1 is correct. Keyword extraction is designed to identify the main concepts or talking points in text, which is exactly what Microsoft documents. Statement 2 is also correct because entity detection (named entity recognition) identifies and categorizes entities such as people, places, and organizations. Statement 3 is incorrect because positive, neutral, and negative labels come from sentiment analysis, not summarization. Summarization condenses content, while sentiment analysis evaluates attitude.

→ Why the other options are wrong:

Option B: Gets Statement 2 wrong (entity detection DOES categorize people/organizations) and Statement 3 wrong (summarization doesn’t assign sentiment labels)

Option C: Marks Statement 1 as No (wrong; keyword extraction identifies main concepts) and Statement 3 as Yes (wrong; sentiment analysis assigns labels)

Option D: Marks all three judgments incorrectly; conflicts with Microsoft’s descriptions of keyword extraction and named entity recognition

Quick Memory Tip 🧠

“Sentiment = positive/neutral/negative, Summarization = condense content”

→ Why the correct answer is right:

Accountability review starts with ownership and governance. Asking who owns incident response and who approves production deployment helps confirm that responsibility is assigned before something goes wrong and that review authority is clear before the system is released. Microsoft’s guidance on responsible AI governance emphasizes documented responsibilities, sign-off processes, reporting mandates, and clear operational ownership.

→ Why the other options are wrong:

Option C: Accent color is a design preference, not an accountability control; affects branding/usability but not who is answerable for model behavior

Option D: Choosing a natural-sounding voice relates to speech experience and UX, not accountability or governance approval paths

Option E: Emoji count is a UI choice with no direct connection to responsible AI accountability or governance value

Quick Memory Tip 🧠

“Accountability = who owns failures + who approves deployment”

→ Why the correct answer is right:

prebuilt-invoice is the best choice because Azure Content Understanding includes domain-specific analyzers for common document categories, and Microsoft specifically lists prebuilt-invoice for invoices. The quickstart uses prebuilt-invoice to extract structured data from an invoice document, which is the analyzer already tuned for invoice extraction.

→ Why the other options are wrong:

Option A: prebuilt-documentSearch is for broad document understanding with layout-aware markdown, optimized for search and RAG scenarios, not structured invoice fields

Option B: prebuilt-documentFieldSchema proposes a field schema for new document types, used for schema discovery rather than production field extraction

Option D: prebuilt-documentFields extracts generic key-value pairs, but prebuilt-invoice is the purpose-built analyzer specifically for invoices

Quick Memory Tip 🧠

“prebuilt-invoice = structured invoice fields (vendor, date, total)”

→ Why the correct answer is right:

Fairness is the correct answer because Microsoft describes fairness as treating people fairly and avoiding different effects on similar groups. A loan system that gives different recommendations to applicants with similar financial circumstances raises a direct fairness concern. This aligns with the AI-901 study guide skill “Describe considerations for fairness in an AI solution.”

→ Why the other options are wrong:

Option A: Transparency is about helping people understand how and why AI systems behave, not about unequal outcomes for similar applicants

Option B: Reliability and safety focuses on consistent performance and safe operation, not unequal treatment across groups

Option D: Privacy and security concerns protecting data and safeguarding systems, not different outcomes for similar people

Quick Memory Tip 🧠

“Fairness = similar people get similar outcomes”

→ Why the correct answer is right:

Documenting who changed the model and why is an accountability practice because it creates ownership, traceability, and review history. Microsoft’s guidance on accountability highlights governance data, lineage, and change information as part of better accountability for AI systems. This shows who approved the system, who changed it, and who is responsible.

→ Why the other options are wrong:

Option B: Explaining recommendations supports transparency (helping users understand the system), not accountability about who approved or changed it

Option C: Encrypting sensitive data is a privacy and security control, not governance or change accountability

Option D: Supporting keyboard-only navigation supports accessibility and inclusiveness, not audit trails or ownership structures

Quick Memory Tip 🧠

“Accountability = document who + why (change history)”

→ Why the correct answer is right:

The Python SDK examples show begin_analyze with analyzer_id, and the invoice example uses analyzer_id=”prebuilt-invoice” to extract structured invoice fields. This matches the scenario exactly of analyzing an invoice and returning structured fields, not just proposing a schema or returning generic document content.

→ Why the other options are wrong:

Option A: prebuilt-documentFieldSchema proposes a field schema for new document types, used for schema discovery, not live invoice analysis

Option B: prebuilt-documentFields extracts generic key-value pairs, but prebuilt-invoice is the stronger Microsoft-matched option for invoices

Option D: prebuilt-document is the base analyzer for custom document analyzers, not the domain-specific invoice analyzer

Quick Memory Tip 🧠

“analyzer_id=’prebuilt-invoice’ = invoice field extraction”

→ Why the correct answer is right:

Statement 1 is correct. Microsoft describes fairness as making sure AI systems treat everyone fairly and avoid affecting similarly situated groups in different ways. Statement 2 is also correct because Microsoft Learn highlights the importance of using real-world data to evaluate fairness. Statement 3 is incorrect because making model internals or behavior understandable is primarily a transparency concern, not the core definition of fairness.

→ Why the other options are wrong:

Option B: Marks Statement 2 as false (wrong; fairness evaluation uses real-world data) and Statement 3 as true (wrong; visibility is transparency)

Option C: Marks Statement 1 as false (wrong; matches Microsoft’s fairness framing) and Statement 3 as true (wrong; transparency ≠ fairness)

Option D: Marks all three incorrectly; Microsoft explicitly supports fair treatment across groups and real-world data evaluation

Quick Memory Tip 🧠

“Fairness = similar groups treated similarly, evaluated with real data”

→ Why the correct answer is right:

prebuilt-documentFields is the best answer because Microsoft describes it as the utility analyzer that extracts key-value pairs from documents. This matches the requirement directly for pulling loose key-value pairs from mixed forms without a predefined domain schema.

→ Why the other options are wrong:

Option B: prebuilt-documentFieldSchema suggests an appropriate schema for new document types, used for schema discovery rather than direct field extraction

Option C: prebuilt-invoice is domain-specific for invoices, but the requirement describes mixed forms without a predefined domain

Option D: prebuilt-documentSearch produces structured markdown for search and broader document understanding, not loose key-value pair extraction

Quick Memory Tip 🧠

“prebuilt-documentFields = generic key-value pairs”

→ Why the correct answer is right:

The correct method is extract_key_phrases because the app needs the main talking points from text. Microsoft’s Python SDK documentation shows that extract_key_phrases determines the main talking points in the input and returns key phrases for each document. The code prints doc.key_phrases, which matches the output shape of key phrase extraction.

→ Why the other options are wrong:

Option B: analyze_sentiment returns sentiment results (positive/neutral/negative), not key_phrases; purpose doesn’t align with finding talking points

Option C: recognize_entities detects named entities (people, places, organizations), not the most important phrases in content

Option D: detect_language identifies the language of input text, not the main concepts discussed in the content

Quick Memory Tip 🧠

“extract_key_phrases = main talking points”

→ Why the correct answer is right:

Microsoft documents prebuilt-invoice as the invoice-focused analyzer, prebuilt-documentFieldSchema as the analyzer that proposes an appropriate field schema, and enableOcr as the option used to extract text from scanned documents and images. These reflect the correct roles of document analyzers and configuration options.

→ Why the other options are wrong:

Option B: prebuilt-documentFields extracts key-value pairs, not proposes a schema; schema proposal belongs to prebuilt-documentFieldSchema

Option E: estimateFieldSourceAndConfidence returns source location and confidence for field values, not speaker diarization (which is audio transcription)

Option F: prebuilt-document is the base analyzer for custom document analyzers, not custom audio analyzers

Quick Memory Tip 🧠

“invoice = structured data, FieldSchema = propose schema, OCR = scanned docs”

→ Why the correct answer is right:

Statement 1 is correct. Microsoft describes prebuilt-documentFieldSchema as a utility analyzer that analyzes documents to propose an appropriate field schema, useful for discovering structure in new document types. Statement 2 is also correct because estimateFieldSourceAndConfidence returns source location information (page number, bounding box) and confidence for extracted field values. Statement 3 is incorrect because prebuilt-documentFields is documented as a document key-value extraction utility, not an audio transcription analyzer.

→ Why the other options are wrong:

Option B: Marks Statement 2 as No (wrong; field-source and confidence output is documented) and Statement 3 as Yes (wrong; documentFields ≠ audio transcription)

Option C: Marks Statement 1 as No (wrong; prebuilt-documentFieldSchema proposes schema) and Statement 3 as Yes (wrong; confuses document extraction with audio)

Option D: Marks all three statements incorrectly; reverses the documented roles of schema utility and field-source option

Quick Memory Tip 🧠

“FieldSchema = propose schema, estimateFieldSource = page + box + confidence”

→ Why the correct answer is right:

Microsoft’s multimodal documentation shows audio_url for cloud-hosted audio input, the audio quickstart shows modalities=[“text”, “audio”] for requesting both text and audio responses, and Microsoft shows input_audio for sending encoded audio data inline inside the user content. These reflect the main distinctions: URL-based vs inline audio input, and response settings for spoken output.

→ Why the other options are wrong:

Option A: Swaps the roles; input_audio is for embedded audio bytes, not cloud-hosted URL reference

Option C: Chat playground is for interacting with already deployed models, not deploying base models (deployment happens under Models + endpoints)

Option F: Microsoft explicitly says Audio playground does not support gpt-4o-mini-audio-preview and tells you to use Chat playground instead

Quick Memory Tip 🧠

“audio_url = cloud URL, input_audio = inline data, modalities=[text, audio] = audio response”

→ Why the correct answer is right:

Recording who approved a deployment supports accountability because it creates traceability and makes ownership visible. Microsoft’s guidance emphasizes governance data, lineage, approval history, and knowing who made changes and when. Defining human review for high-impact outcomes also supports accountability because Microsoft states AI systems should not be the final authority in decisions that affect people’s lives.

→ Why the other options are wrong:

Option B: Adding image captions supports accessibility and inclusiveness, not accountability (doesn’t identify decision owners or approval paths)

Option D: Increasing token limits is a configuration choice, not an accountability control (doesn’t create governance or traceability)

Option E: Using more training data sources might improve coverage but quantity alone doesn’t create accountability (requires clear ownership and review processes)

Quick Memory Tip 🧠

“Accountability = approval records + human review for high-impact”

→ Why the correct answer is right:

Microsoft’s deployment guide says that after opening the playground for the deployed model, you can type your prompt and see the outputs, and then select the Code tab to see details about how to access the model deployment programmatically. These two actions are explicitly part of the playground workflow and capture the two most practical post-deployment portal tasks: validate behavior interactively and bridge into code.

→ Why the other options are wrong:

Option A: Viewing endpoint keys happens from the deployment’s detail page under management flow, not as an action after opening the playground

Option B: Azure Marketplace subscription is part of deployment setup for partner/community models, not a step after opening the deployed model in playground

Option E: Reallocating TPM is mentioned in quota section for hitting quota limits, not as an action in the playground chat pane

Quick Memory Tip 🧠

“Playground = type prompt + see outputs, then Code tab for programmatic details”

→ Why the correct answer is right:

Fairness evaluation depends on checking how the system performs across different groups and using data that reflects real-world populations. Microsoft Learn explicitly calls out the importance of real-world data for evaluating fairness, and Microsoft’s responsible AI guidance describes fairness in terms of avoiding different impacts on similar groups. Testing across relevant groups and using representative data helps uncover whether one group is disproportionately disadvantaged.

→ Why the other options are wrong:

Option A: Hiding the model name doesn’t meaningfully assess or improve fairness (doesn’t show whether system treats groups equitably)

Option C: Encrypting stored files supports privacy and security, not fairness (doesn’t reveal systematically worse results for demographic groups)

Option E: Increasing server timeout affects performance/resilience, not bias or unequal treatment (closer to reliability than fairness)

Quick Memory Tip 🧠

“Fairness = real-world data + compare across groups”

→ Why the correct answer is right:

Accountability is about ownership, answerability, and governance for AI system behavior, so assigning owners and documenting deployment approvals are correct matches. Microsoft associates accountability with governance data, lineage, change history, and understanding who approved/changed a model. Privacy and security includes controlling access to resources and data, so role-based access control is also correct.

→ Why the other options are wrong:

Option B: Transparency is not about encrypting data (encryption is privacy/security); transparency is about helping people understand how decisions are made

Option D: Inclusiveness is not about model lineage (lineage relates to accountability/governance); inclusiveness is about designing experiences for varied abilities and backgrounds

Option F: Fairness is not mainly about explaining predictions (explanation aligns with transparency); fairness is about equitable treatment across groups

Quick Memory Tip 🧠

“Accountability = owners + approvals, Privacy = access control”

→ Why the correct answer is right:

prebuilt-documentFieldSchema is the correct answer because Microsoft documents it as the utility analyzer that analyzes documents to propose an appropriate field schema. It is specifically described as useful for discovering structure in new document types. This is the strongest fit when the task is schema discovery for a new form type, not extraction of known fields.

→ Why the other options are wrong:

Option A: prebuilt-documentSearch is for rich document content extraction and markdown output (search/RAG workflows), not proposing field schemas for new types

Option B: prebuilt-documentFields extracts key-value pairs from documents (actual field extraction), but this question asks for schema suggestion before building the analyzer

Option D: prebuilt-invoice is domain-specific for invoices, but the question says the team has a new form type (schema-proposal analyzer is more appropriate)

Quick Memory Tip 🧠

“prebuilt-documentFieldSchema = propose schema for new forms”

→ Why the correct answer is right:

enableOcr is appropriate because Microsoft documents it as the option that enables optical character recognition for images and scanned documents, directly matching image-based PDFs and scanned forms. estimateFieldSourceAndConfidence is also appropriate because it returns source location information (page number, bounding box) along with confidence for extracted field values.

→ Why the other options are wrong:

Option C: disableFaceBlurring is for image/video scenarios, not document field extraction from scanned forms

Option D: locales is for language-specific processing in audio/video transcription, not scanned document OCR and field-source validation

Option E: enableSegment is useful for classification/routing workflows, but doesn’t replace OCR or field-source estimation capabilities

Quick Memory Tip 🧠

“enableOcr = scanned PDFs, estimateFieldSource = page + box + confidence”

→ Why the correct answer is right:

Evaluating model results across age-based groups is the best fairness-focused response because fairness issues are identified by checking whether similar people or groups are being affected differently. Microsoft’s responsible AI guidance points to fairness assessment across sensitive groups as an important way to understand model behavior. This is the most relevant next step for potential bias in outcomes.

→ Why the other options are wrong:

Option A: Increasing model endpoints improves scale/availability but doesn’t reveal whether system disadvantages one age group (operational, not fairness evaluation)

Option B: Removing audit trail reduces oversight rather than improving it (auditability supports accountability and bias investigation)

Option C: Publishing source code increases openness but doesn’t directly test whether model treats age groups fairly (transparency ≠ fairness)

Quick Memory Tip 🧠

“Fairness issue = evaluate results across affected groups”

→ Why the correct answer is right:

model=”ops-assistant” is correct because Microsoft documents that the deployment name is used in the model parameter during inference. The Code tab exists to show programmatic access details for the deployment you created in the portal, so this is the correct argument to target that deployment. This tests the small implementation distinction between portal deployment and client call mapping.

→ Why the other options are wrong:

Option A: endpoint is useful (viewable from deployment details page), but deployment guide specifically says deployment name is used in the model parameter, not endpoint

Option B: deployment_type is a configuration choice, not the field that identifies which deployed model handles inference requests

Option C: project is a valid Foundry concept but Microsoft doesn’t describe project name as the inference argument that routes requests to deployed model

Quick Memory Tip 🧠

“model parameter = deployment name for inference routing”

→ Why the correct answer is right:

Fairness is best described as treating similar people fairly across groups. Microsoft’s current responsible AI material explains fairness in terms of avoiding different effects on similarly situated groups, which is the clearest match among the options. AI-901 fairness questions often test whether you can separate equitable treatment from explainability, privacy, and performance.

→ Why the other options are wrong:

Option A: Encrypting stored data belongs to privacy and security, not fairness (secure systems can still produce unfair outcomes)

Option B: Explaining internal parameters relates to transparency (making systems understandable), not fairness (centered on equitable treatment)

Option D: Responding within fixed latency is a performance/reliability concern (fast systems can still be unfair)

Quick Memory Tip 🧠

“Fairness = similar people treated similarly across groups”

→ Why the correct answer is right:

Both situations point directly to fairness risk. Different outcomes for similar applicants suggest unequal treatment, and poor representation of an affected group in test data makes it harder to evaluate whether the system performs equitably in the real world. These are classic AI-901 fairness signals. Microsoft’s material ties fairness to treatment across groups and stresses the value of representative real-world data when evaluating AI systems.

→ Why the other options are wrong:

Option B: TLS is a security control for data in transit (privacy/security), not a fairness indicator (secure systems can still show biased outcomes)

Option D: Dark theme is a UI preference, not a fairness indicator (doesn’t tell you about bias, representation, or unequal treatment)

Option E: Version number in model card supports documentation/governance (accountability/traceability), but doesn’t reveal unfair behavior or equitable treatment

Quick Memory Tip 🧠

“Fairness risk = different outcomes + poor representation in test data”

→ Why the correct answer is right:

Statement 1 is correct because underrepresentation in training data can contribute to biased or uneven outcomes. Microsoft’s responsible AI guidance emphasizes representative data and real-world evaluation as important fairness considerations. Statement 2 is incorrect because fairness and inclusiveness are separate responsible AI principles, even though they are related. Statement 3 is correct because comparing model behavior across demographic or sensitive groups is a practical fairness assessment step.

→ Why the other options are wrong:

Option A: Wrongly marks Statement 2 as true (fairness ≠ inclusiveness) and Statement 3 as false (group comparison is relevant for fairness evaluation)

Option C: Marks Statement 1 as false (wrong; underrepresentation is a common fairness concern) and Statement 2 as true (wrong; they are separate principles)

Option D: Marks Statement 1 as false (wrong) and repeats mistake on Statement 2; gets Statement 3 right but that’s not enough

Quick Memory Tip 🧠

“Fairness ≠ Inclusiveness (separate principles), underrepresentation = fairness risk”

→ Why the correct answer is right:

Evaluating results using real-world data from affected groups is the best practical step because Microsoft Learn explicitly highlights the importance of real-world data when assessing fairness. This helps teams see whether the system behaves equitably for the people who will actually be affected by it. AI-901 fairness questions usually focus on representative data, subgroup analysis, and unequal outcomes.

→ Why the other options are wrong:

Option A: Longer password policy supports privacy and security (access control), not fairness review (doesn’t determine if model treats groups fairly)

Option C: Increasing batch size is ML tuning for training behavior/efficiency, not fairness evaluation (doesn’t show if real users/groups treated equitably)

Option D: Disabling user feedback could reduce opportunities to identify harms or uneven impacts (removes feedback, doesn’t improve fairness review)

Quick Memory Tip 🧠

“Fairness review = real-world data from affected groups”

→ Why the correct answer is right:

An audit trail of model changes, approvals, and deployment history supports accountability because it creates traceability. Microsoft’s guidance highlights governance data, lineage, documented responsibilities, and approval processes as ways to make ownership, review, and follow-up clear across the AI lifecycle. Accountability means people remain answerable for how systems operate.

→ Why the other options are wrong:

Option A: Larger font improves accessibility and inclusiveness, but doesn’t establish who is responsible for model behavior or deployment decisions

Option C: Multilingual voice output relates to accessibility/speech/inclusiveness, not ownership of outcomes or governance (doesn’t identify approvers or reviewers)

Option D: Encrypting stored data is privacy and security (protects confidentiality), not accountability (doesn’t document who made model decisions)

Quick Memory Tip 🧠

“Accountability = audit trail (changes + approvers + history)”

→ Why the correct answer is right:

Microsoft states that prebuilt analyzer definitions can change across API versions. To ensure consistent behavior, the documentation recommends making a copy of the prebuilt analyzer instead of relying on the prebuilt version directly in production. This is the production-safe customization path for Content Understanding analyzers in Foundry Tools.

→ Why the other options are wrong:

Option A: Calling prebuilt analyzer directly ignores Microsoft’s warning that definitions can change across API versions (introduces unexpected behavior after service/API changes)

Option C: prebuilt-documentFields is a utility analyzer for key-value pairs, not a general replacement for version stability of customized analyzer behavior

Option D: tableFormat controls output format for tables (HTML vs markdown), not production stability across API versions (configuration distraction, not core answer)

Quick Memory Tip 🧠

“Copy prebuilt analyzer = stable production behavior across API versions”

→ Why the correct answer is right:

Accountability is the principle that best fits this sentence. Microsoft describes accountability as requiring the people who design and deploy AI systems to remain responsible for how those systems operate, including how decisions are reviewed and corrected when needed. This shows up through governance, documented responsibilities, monitoring, review, and mechanisms that preserve human control over important decisions.

→ Why the other options are wrong:

Option A: Fairness is about avoiding unjust differences in treatment across similar people/groups (asks whether system behaves equitably, not about ownership/answerability)

Option B: Transparency is about helping people understand how AI decisions are made (explainability, disclosure), but doesn’t establish who is responsible for system actions

Option D: Inclusiveness focuses on designing AI systems usable by people with diverse needs/abilities (accessibility/participation), not ownership of outcomes and governance

Quick Memory Tip 🧠

“Accountability = people remain answerable for AI system”

→ Why the correct answer is right:

Representative is the correct answer because Microsoft guidance on responsible AI fairness emphasizes using diverse and representative data to reduce bias. If data doesn’t reflect the people who will be affected by the AI system, some groups can be underrepresented and receive worse outcomes. Microsoft Learn also highlights using real-world data to evaluate fairness.

→ Why the other options are wrong:

Option A: Encrypted data protects confidentiality (privacy/security), but encryption doesn’t make dataset balanced or representative (can be well-protected but still unfair)

Option C: Compressed data is storage/transmission concern, not fairness control (reducing file size doesn’t address demographics or real-world usage)

Option D: Anonymized data supports privacy (reduces personal info exposure), but anonymization doesn’t ensure all groups are fairly represented (can be anonymized but still biased)

Quick Memory Tip 🧠

“Reduce bias = representative data of affected people”

→ Why the correct answer is right:

Statement 1 is incorrect. Microsoft’s accountability guidance specifically says AI systems should not be the final authority on decisions that affect people’s lives and that humans should maintain meaningful control over highly autonomous systems. Statements 2 and 3 are correct. Microsoft identifies lineage and governance data (who published models, why changes were made, when deployed) as accountability-supporting practices, and recommends governance structures, review boards, reporting mandates, and sign-off processes.

→ Why the other options are wrong:

Option A: Marks Statement 1 as Yes (main problem; accountability ≠ handing authority to AI) and Statement 3 as No (wrong; governance sign-off formalizes responsibility)

Option B: Still marks Statement 1 as Yes (wrong) and Statement 2 as No (wrong; logging supports accountability through traceability)

Option D: Correctly marks Statement 1 as No and Statement 3 as Yes, but incorrectly marks Statement 2 as No (logging who changed model supports accountability)

Quick Memory Tip 🧠

“Accountability = humans control, not AI final authority + logging + governance sign-off”

→ Why the correct answer is right:

Requiring a human reviewer for high-impact cases best reflects accountability because it preserves meaningful human control over decisions that can materially affect people. Microsoft states AI systems should not be the final authority on decisions affecting people’s lives and humans should remain in control of highly autonomous systems. Accountability is about defining who reviews outcomes, who can override them, and who is responsible.

→ Why the other options are wrong:

Option A: Hiding escalation rules works against good governance and weakens oversight (reviewers need context for meaningful review; makes accountable oversight harder)

Option B: Replacing all reviewers with automation is opposite of accountability (removes human control, makes organizations defer responsibility to model)

Option C: Short data retention relates to privacy practices, not accountability (doesn’t establish owners, sign-off process, or monitoring)

Quick Memory Tip 🧠

“Accountability = human reviewer for high-impact decisions”

→ Why the correct answer is right:

The organization remains accountable for how the AI solution is applied, governed, monitored, and reviewed, even when parts of the technology stack are managed by a provider. Microsoft’s responsible AI guidance emphasizes that people and organizations must remain answerable for the behavior and use of systems they deploy. Governance boards, sign-off processes, documented practices, and human oversight still matter with managed services.

→ Why the other options are wrong:

Option A: Anonymous contradicts accountability (accountability requires named owners, approvers, documented responsibilities; anonymous governance makes review harder)

Option B: Unbiased relates to fairness, not accountability (can attempt fairness improvements but still lack clear accountability processes)

Option C: Encrypted is privacy/security (protects data), not accountability (doesn’t establish who is responsible for approvals, monitoring, incident response)

Quick Memory Tip 🧠

“Managed services ≠ organization escapes accountability”

→ Why the correct answer is right:

Sentiment analysis is the best choice because it is designed to determine whether text expresses positive, neutral, or negative sentiment. Microsoft documents this as a core Azure Language capability, and it can return sentiment at both document and sentence level with confidence scores. This directly matches the requirement to classify product reviews by emotional tone.

→ Why the other options are wrong:

Option A: Keyword extraction identifies main concepts/talking points (topics like “battery life”), not emotional tone or polarity classification

Option B: Entity detection categorizes items (people, places, organizations, dates), not positive/neutral/negative labels (might detect brand but not if customer liked it)

Option D: Summarization creates condensed version of longer content (overview), not sentiment labels (classification of mood, not compression)

Quick Memory Tip 🧠

“Sentiment analysis = positive/neutral/negative classification”

→ Why the correct answer is right:

Entity detection is the correct answer because this requirement is about finding and categorizing named items in text. Microsoft documents this capability as named entity recognition, which identifies entities such as people, places, organizations, and quantities in unstructured text. This directly matches the need to systematically extract and categorize people, organizations, and locations.

→ Why the other options are wrong:

Option A: Summarization shortens content while preserving central meaning (doesn’t label specific phrases as person/location/organization entities)

Option C: Sentiment analysis measures positive/neutral/negative attitude (useful for satisfaction/reviews, not for categorizing names and places)

Option D: Keyword extraction finds main concepts/talking points (not meant to classify into entity categories like Organization or Location)

Quick Memory Tip 🧠

“Entity detection = people, places, organizations, quantities”

→ Why the correct answer is right:

Keyword extraction is used to identify main concepts in text, entity detection identifies and categorizes named items, and summarization condenses longer content. Those three pairings align directly with Microsoft’s descriptions of the corresponding Azure Language capabilities. These are the key distinctions for understanding text analysis techniques.

→ Why the other options are wrong:

Option B: Sentiment analysis determines emotional tone (positive/neutral/negative), not categorizing people/places/organizations (entity detection does that)

Option E: Keyword extraction identifies main concepts/talking points, not polarity labels (sentiment analysis produces sentiment labels and confidence scores)

Option F: Summarization generates shorter representation of content, not extracting/categorizing named entities (entity detection identifies organizations/locations)

Quick Memory Tip 🧠

“Keywords = talking points, Entity = named items, Summarization = condensed text”

→ Why the correct answer is right:

A, C, and E are correct because they match Microsoft’s fairness guidance closely. Fairness is about treating similar groups fairly, using representative or real-world data for evaluation, and checking whether model behavior differs across groups that might be sensitive or impacted differently. These are the distinctions AI-901 expects candidates to recognize.

→ Why the other options are wrong:

Option B: Transparency is about making AI systems understandable (capabilities, limitations, behavior); encrypting data is privacy/security, not transparency

Option D: Accountability is about people remaining responsible for AI systems; increasing GPU capacity is infrastructure scaling, not accountability mechanism

Option F: Reliability/safety focuses on stable/safe/robust behavior; hiding demographic results makes fairness assessment harder (demographic review is fairness evaluation, not safety)

Quick Memory Tip 🧠

“Fairness = similar groups treated equally + representative data + compare across groups”

→ Why the correct answer is right:

Summarization is the right answer because the requirement is to create a shorter version of longer content. Microsoft documentation describes summarization as a capability for producing summaries, and extractive summarization specifically identifies key sentences that convey the main idea of a document. This directly matches the manager’s need for a readable short version.

→ Why the other options are wrong:

Option A: Keyword extraction returns important phrases, not condensed narrative/sentence-based overview (list of phrases isn’t enough for readable short version)

Option B: Entity detection identifies named elements (people, locations, organizations) for metadata/indexing, not shortened retelling of document

Option C: Sentiment analysis evaluates positive/neutral/negative (useful for reviews/feedback), but incident report summary is about condensing information, not assigning emotional tone

Quick Memory Tip 🧠

“Summarization = short condensed version of long content”

→ Why the correct answer is right:

Microsoft’s multimodal chat completions documentation states that the model can read audio content from an accessible cloud location by passing the payload as audio_url. The example shows a user content item with “type”: “audio_url” and a URL pointing to an MP3 file. audio_url is an input method, the URL-based alternative to sending encoded audio inline with input_audio.

→ Why the other options are wrong:

Option A: Requesting spoken output is handled through response settings (modalities=[“text”, “audio”] + audio block), not audio_url (audio_url is about input transport, not output configuration)

Option B: audio_url doesn’t deploy anything (deployment done earlier under Models + endpoints; audio_url is just request payload after deployment)

Option D: Recording microphone input is Chat playground capability, not what audio_url field does in API request (audio_url points to hosted audio file)

Quick Memory Tip 🧠

“audio_url = cloud location audio input”

→ Why the correct answer is right:

Sentiment analysis commonly returns a sentiment label and confidence scores. Microsoft documents that Azure Language sentiment analysis assigns labels such as positive, neutral, and negative, and provides confidence scores for each document and sentence. These are the core outputs for determining emotional polarity.

→ Why the other options are wrong:

Option A: Organization categories come from entity detection (named entity recognition), not sentiment analysis (sentiment is about emotional polarity, not classifying text spans)

Option C: Key phrases come from keyword extraction (identifying main concepts/talking points), not sentiment analysis (different outputs for topic discovery vs attitude detection)

Option D: Person and location entities are outputs of entity detection (pulling structured info from unstructured text), not sentiment analysis (doesn’t describe author’s attitude/emotional tone)

Quick Memory Tip 🧠

“Sentiment = label (positive/neutral/negative) + confidence scores”

→ Why the correct answer is right:

The correct method is analyze_sentiment because the code needs to return doc.sentiment for each input document. Microsoft’s Python SDK documentation shows that analyze_sentiment determines whether text is positive, negative, neutral, or mixed and provides sentiment-focused results. The output property doc.sentiment is the biggest clue matching this method.

→ Why the other options are wrong:

Option A: extract_key_phrases identifies main talking points (surfaces concepts), not positive/negative attitude (would use doc.key_phrases, not doc.sentiment)

Option B: recognize_entities returns categorized entities (people, organizations, locations, dates, quantities), not review favorability (entity detection ≠ sentiment assessment)

Option D: detect_language identifies text language (helpful for multilingual preprocessing), not emotional polarity (doesn’t calculate sentiment)

Quick Memory Tip 🧠

“analyze_sentiment = doc.sentiment (positive/negative/neutral)”

→ Why the correct answer is right:

Keyword extraction is the correct choice because the retailer wants the main topics from the tickets, not a rewritten narrative. Microsoft describes key phrase extraction as a capability that quickly identifies the main concepts in text. The clue “They do not want a rewritten paragraph” rules out summarization and points toward returning important phrases or talking points.

→ Why the other options are wrong:

Option A: Summarization produces condensed version of content (rewritten paragraph), but question explicitly says user doesn’t want rewritten paragraph

Option B: Entity detection identifies named items (people, organizations, locations) for metadata/indexing, not main topics across tickets (focuses on named entities, not topics)

Option C: Sentiment analysis measures positive/neutral/negative (useful for satisfaction/triage), but doesn’t surface actual topics being discussed (sentiment score alone doesn’t reveal main themes)

Quick Memory Tip 🧠

“Keyword extraction = main topics/phrases (not rewritten paragraph)”

→ Why the correct answer is right:

For a field like InvoiceNumber, the correct generation method is EXTRACT because the analyzer should pull a concrete value from the document rather than generate a summary or classify a category. Microsoft’s custom analyzer tutorial shows document fields such as names and totals using GenerationMethod.EXTRACT. Extracted fields are grounded in the source document.

→ Why the other options are wrong:

Option A: GenerationMethod.GENERATE produces derived values like summaries (invoice number is not generated interpretation, it’s concrete field pulled from source)

Option B: GenerationMethod.CLASSIFY categorizes into classes (document type, sentiment label), but invoice number is direct field value, not category

Option D: enum=[“Invoice”] is used with classification fields to define allowed categories, but snippet missing field method for extracting document value (enum alone doesn’t create extraction field)

Quick Memory Tip 🧠

“EXTRACT = pull concrete value from document”

→ Why the correct answer is right:

Sentiment analysis is needed for the customer-review requirement because it’s the technique that assigns positive, neutral, or negative sentiment labels. Summarization is needed for the transcript requirement because it produces a condensed version of longer content. The question combines two different text-analysis goals: emotional polarity and shortening content, requiring two distinct techniques.

→ Why the other options are wrong:

Option A: Keyword extraction identifies main concepts/talking points (helps highlight themes), but doesn’t directly tell if review is positive/negative OR generate condensed readable transcript version

Option C: Entity detection categorizes named items (people, locations, organizations) for structured info extraction, but neither requirement asks for named entities (doesn’t replace polarity detection or create summary)

Option E: Detect language is preprocessing for multilingual systems (tells what language text is written in), not sentiment classification or summarization (out of scope for requirements)

Quick Memory Tip 🧠

“Sentiment = positive/negative, Summarization = condensed transcript”

→ Why the correct answer is right:

Think of it like ordering food at a restaurant. You sit down (set up the client), you write your order (add messages), and then you call the waiter to complete your order. That waiter is complete() — it sends your messages to the model and brings back the AI-generated reply. Prompt in, response out. That is the whole flow.

→ Why the other options are wrong:

Option A: embed turns text into numbers for similarity searches — it does not generate a conversational reply.

Option B: get_model_info just reads the model’s label and specs — like checking the menu, not actually ordering.

Option D: send_request is low-level network plumbing under the hood — Microsoft gives you complete() so you never need to go that deep.

Quick Memory Tip 🧠

You want the AI to complete your conversation → use complete().

→ Why the correct answer is right:

Imagine a meeting transcript that looks like one giant block of text with no names. Speaker diarization is like adding name tags to each part — it listens to the audio and automatically labels sections as “Speaker 1 said this, Speaker 2 said that.” It separates voices so you know exactly who spoke which portion. Perfect for meetings, interviews, and call centers.

→ Why the other options are wrong:

Option A: Speech Translation converts speech from one language to another — it does not identify or separate speakers.

Option C: SSML is a tool for designing how an AI voice sounds when speaking — it controls output, not who is speaking in incoming audio.

Option D: Keyword extraction finds important words in text that already exists — it cannot tell you who said those words.

Quick Memory Tip 🧠

Who said what = diarization. Think “diary” — it logs each speaker.

→ Why the correct answer is right:

Speech synthesis is the AI reading text out loud in a natural, human-like voice. And it is far from a one-size-fits-all robot voice — you can fine-tune it with SSML (Speech Synthesis Markup Language), which is basically like HTML but for voice. Want the AI to speak slowly? Add a pause? Sound excited? SSML does all that. Microsoft offers dozens of neural voices plus full customization.

→ Why the other options are wrong:

Option B: Converting recordings to transcripts is speech-to-text (recognition) — the opposite direction. Synthesis goes text → audio, recognition goes audio → text.

Option D: Speaker diarization is a recognition feature for labeling speakers in audio — it has nothing to do with generating audio.

Option E: Completely false — Microsoft offers dozens of neural voices and SSML customization. There is no “one fixed voice.”

Quick Memory Tip 🧠

Synthesis = text IN, voice OUT. SSML = the remote control for that voice.

→ Why the correct answer is right:

This one is beautifully obvious once you see it. You want the microphone? You literally say use_default_microphone=True. It is like telling your app “yes, use the built-in mic, start listening right now.” Microsoft designed this to be readable. There is no guessing — the parameter name tells you exactly what it does.

→ Why the other options are wrong:

Option B: filename=”meeting.wav” tells the app to read a saved audio file — great for playback, useless for live listening.

Option C: SpeechConfig.from_subscription(key, region) handles your subscription key and region — that is authentication setup, not audio input configuration. Different job entirely.

Option D: use_default_microphone=False literally says “do NOT use the default microphone” — the exact opposite of what you need.

Quick Memory Tip 🧠

Live microphone = use_default_microphone=True. If you see False, that is a trap.

→ Why the correct answer is right:

Picture a smart speaker waiting for “Turn on the lights.” It listens, hears one command, stops, and acts. That is recognize_once_async — it captures one utterance and moves on. No marathon listening sessions, no waiting forever. It is clean, lightweight, and exactly right for single-command apps like voice assistants or quick voice inputs.

→ Why the other options are wrong:

Option B: start_continuous_recognition_async keeps listening indefinitely — powerful for live dictation, complete overkill for one command.

Option C: speak_text_async makes the app talk, not listen — completely the wrong direction.

Option D: add_target_language is for speech translation — it adds a language to translate into, not how to capture speech.

Quick Memory Tip 🧠

One command = recognize_once_async. Long session = continuous. Never mix them up.

→ Why the correct answer is right:

The app already did the hard part — it generated a text reply. Now it just needs to read it aloud like a helpful assistant. Text-to-speech is exactly that bridge: hand it a string, it hands back a natural-sounding voice. No translation needed, no agents, no complexity. Just speech output from text input.

→ Why the other options are wrong:

Option A: Speech translation converts spoken words from one language to another — there is nothing to translate here, and there is no audio input to begin with.

Option B: Voice Live API is a powerful real-time voice-agent system combining recognition, AI, and synthesis — far more than you need just to read a text reply aloud.

Option D: Entity recognition finds names, places, and organizations inside text — it produces no audio output whatsoever.

Quick Memory Tip 🧠

Already have text, need audio = text to speech. Full stop.

→ Why the correct answer is right:

These three are the core Azure Speech trio — think of them as ears, mouth, and full conversation system. STT listens and writes. TTS reads and speaks. Voice Live API is the all-in-one real-time voice agent that combines both plus generative AI for live conversations. Nail these three and you can handle most speech questions on the exam.

→ Why the other options are wrong:

Option D: Speaker diarization labels who said what in audio — it does NOT create synthetic audio. That is TTS’s job, not diarization’s.

Option E: This is deliberately backwards. You use a custom endpoint for your own custom model. For Microsoft’s baseline model you leave it as None — no custom endpoint needed.

Option F: Speech Studio Voice Gallery is a browser tool to preview voices with zero code — it is not a required SDK for recognition. It is a no-code demo tool.

Quick Memory Tip 🧠

STT = ears. TTS = mouth. Voice Live API = full conversation. Diarization = name tags.

→ Why the correct answer is right:

The Foundry portal follows a simple and elegant two-step rhythm for everything: first play with it in Playgrounds, then grab your starter code from the Code tab. Think of it like test driving a car before buying — you experience it first in the playground, then walk away with the keys in the form of sample code. The JSON tab just shows raw response data for debugging, not SDK code.

→ Why the other options are wrong:

Option B: JSON tab shows raw API response output — great for inspecting results, but it does not hand you an SDK code sample.

Option D: Adding Azure Speech MCP Server in the agent playground is a completely different, more advanced flow for agent tooling — not the speech-to-text quickstart path.

Option E: Speech Studio Voice Gallery is for previewing text-to-speech voices — it has nothing to do with speech-to-text transcription.

Quick Memory Tip 🧠

Foundry flow = Playgrounds to test → Code tab to build.

→ Why the correct answer is right:

This one practically writes itself. You want to speak some text and do it async. The method is called speak_text_async. Microsoft named it perfectly — there is no guessing needed. Hand it your string, it plays the audio through the speaker. Done. Always look at the method name first — it usually tells you exactly what it does.

→ Why the other options are wrong:

Option A: get_voices_async just fetches a list of available voices — it does not play anything. It is like browsing a menu, not ordering.

Option C: recognize_once_async listens for audio and returns text — the complete opposite direction. You need synthesis, not recognition.

Option D: start_continuous_recognition_async keeps listening for audio indefinitely — again, recognition not synthesis, and you are going the wrong way entirely.

Quick Memory Tip 🧠

The method literally tells you: speak + text + async = speak_text_async.

→ Why the correct answer is right:

Imagine building a live AI phone assistant — it needs to hear you speak, think intelligently, and respond instantly in natural speech. That is exactly what Voice Live API is built for. It is an all-in-one powerhouse that combines speech recognition, generative AI, and text-to-speech into one low-latency pipeline. No stitching separate services together — it is designed for real-time voice conversations from the ground up.

→ Why the other options are wrong:

Option A: Speech Studio Voice Gallery is a browser-based demo tool for trying out TTS voices — no API, no agents, no real-time capability whatsoever.

Option B: Custom Speech helps improve recognition accuracy for specialized vocabulary — it is a customization layer, not a voice-agent runtime that handles the full conversation flow.

Option D: Speaker diarization labels who said what in a transcript — it is purely a transcription analysis tool, not a live conversational agent interface.

Quick Memory Tip 🧠

Real-time voice agent = Voice Live API. Nothing else on the list even comes close.

→ Why the correct answer is right:

Think of azure-ai-projects as the starter kit for Foundry apps. It is the package that gives you the project client, which is the thing your app uses to connect into the Foundry project and reach the model. If you install the wrong package, you may still be in Azure, but not in the right Azure AI lane.

→ Why the other options are wrong:

Option A: azure-ai-search is for search and retrieval, not for creating the Foundry project client.

Option C: azure-ai-language is for language analysis workloads, not Foundry project connectivity.

Option D: azure-ai-vision is for vision tasks, not lightweight Foundry chat setup.

Quick Memory Tip 🧠

Foundry project client = azure-ai-projects.

→ Why the correct answer is right:

An embedding is like turning text into a meaning fingerprint. Instead of storing the words themselves, the system converts them into numbers that place similar ideas close together in vector space. That is why embeddings are used for semantic search, retrieval, and similarity matching.

→ Why the other options are wrong:

Option A: A completion token is a piece of generated output, not a semantic vector.

Option B: A stop sequence tells the model when to stop generating.

Option C: Temperature controls randomness, not meaning representation.

Quick Memory Tip 🧠

Meaning as numbers = embedding.

→ Why the correct answer is right:

Microsoft’s quickstart is pretty simple here: install the Foundry SDK package and sign in to Azure. That is enough for DefaultAzureCredential to work and for the project client to authenticate. No search index, no speech resource, no extra detours.

→ Why the other options are wrong:

Option A: Search indexes are optional for retrieval scenarios, not required for the basic client setup.

Option B: azure-ai-vision is the wrong SDK family.

Option D: A speech deployment is unrelated to the Foundry project-client setup.

Quick Memory Tip 🧠

Foundry client setup = install package + sign in.

→ Why the correct answer is right:

The flow starts by creating a conversation, then sends requests through the responses API using the agent reference. That keeps the interaction tied to the right agent and the right conversation. It is basically: open a thread first, then talk inside that thread.

→ Why the other options are wrong:

Option B: previous_response_id is not the first step in this agent flow.

Option C: chat.completions.create() is not the documented agent flow here.

Option D: The model value should be the deployment name, not the catalog model name.

Quick Memory Tip 🧠

Agent flow = create conversation, then use agent reference.

→ Why the correct answer is right:

This is a very common trap. In Foundry, the thing you pass as the model is usually the actual deployment name, not the pretty catalog name you saw in the portal. If those do not match, the request lands at a dead address and you get a 404.

→ Why the other options are wrong:

Option A: Short output does not cause a 404.

Option B: A polite prompt will not break deployment routing.

Option D: HTTPS is expected, not the reason for a missing deployment.

Quick Memory Tip 🧠

404 + model call = check the deployment name.

→ Why the correct answer is right:

This is the classic text-to-speech move: you already have the text, and now you want the synthesizer to read it aloud. So you call speak_text_async. Recognition methods do the opposite, which is why the distractors feel close but still miss the mark.

→ Why the other options are wrong:

Option B: recognize_once_async listens for speech and returns text.

Option C: SpeechRecognizer is for recognition, not synthesis.

Option D: translate_text_async is not the standard text-to-speech call.

Quick Memory Tip 🧠

Text to speech = speak_text_async.

→ Why the correct answer is right:

When you use Entra ID with Foundry-style AI calls, the token needs to be scoped for the AI endpoint, not Graph, Search, or Azure management. If the scope is wrong, authentication may look fine but the model call still fails. So the scope is part of the plumbing, and it matters a lot.

→ Why the other options are wrong:

Option A: That is for Microsoft Graph.

Option B: That is for Azure AI Search.

Option C: That is for Azure management-plane operations.

Quick Memory Tip 🧠

For Foundry AI calls, remember the AI scope.

→ Why the correct answer is right:

AIProjectClient is not built the way beginners often expect — the docs point to Entra ID as the supported auth path there. The Responses API does use input for the prompt text, and a normal chat conversation usually ends with a user message so the assistant knows it should reply next. So the first statement is false, and the next two are true.

→ Why the other options are wrong:

Option A: It gets the auth statement wrong and the chat-flow statement wrong.

Option B: It gets the auth statement wrong and the input statement wrong.

Option D: It gets the input statement wrong.

Quick Memory Tip 🧠

AIProjectClient = Entra ID, Responses API = input, chat ends with user.

→ Why the correct answer is right:

The goal is to look at shelf photos and pull out structured details. That is exactly what Content Understanding is for. Think of it as the service that turns messy visual content into clean data you can actually use downstream.

→ Why the other options are wrong:

Option A: Speech handles audio, not image extraction.

Option C: Search retrieves information, but it does not analyze the image first.

Option D: Agents orchestrate workflows; they do not do the image extraction themselves.

Quick Memory Tip 🧠

Photos to structured fields = Content Understanding.

→ Why the correct answer is right:

Fine-tuning is like taking a general-purpose model and teaching it a specialized skill through extra training examples. That changes the model’s weights so it behaves better for a particular task or domain. It is not just prompt tweaking, and it is not the same as adding documents to search.

→ Why the other options are wrong:

Option A: That is retrieval or grounding, not fine-tuning.

Option C: That is prompt engineering, not training.

Option D: Streaming only changes how output is delivered.

Quick Memory Tip 🧠

Fine-tuning = retraining the model for the task.

→ Why the correct answer is right:

This is the handoff point in the Foundry SDK flow. AIProjectClient connects to the project, and get_openai_client() returns the OpenAI-compatible client that you use for chat and responses. So the missing line is the method that bridges the project connection into the model client.

→ Why the other options are wrong:

Option A: responses.create is called on the OpenAI-compatible client after you get it, not on the project client itself.

Option B: conversations.create is also used after you have the OpenAI-compatible client.

Option C: agents.create_version is for agent management, not for retrieving the chat client.

Quick Memory Tip 🧠

Project client first, OpenAI client second.

→ Why the correct answer is right:

Think of prebuilt-image as the parent blueprint for custom image analyzers. Microsoft’s custom analyzer pattern uses it as the starting point when you want to define your own image schema, such as chart fields or other image-specific outputs. The custom analyzer inherits image capabilities from that base.

→ Why the other options are wrong:

Option A: prebuilt-layout is for document layout extraction, not the base image analyzer.

Option B: prebuilt-imageSearch is a ready-made analyzer, not the inheritance base.

Option D: prebuilt-read is for OCR/document reading, not image analyzer inheritance.

Quick Memory Tip 🧠

Custom image analyzer base = prebuilt-image.

→ Why the correct answer is right:

The Responses API uses input for the text you want the model to process. So the call is responses.create(model=…, input=”…”). That is the exact pattern Microsoft shows for simple prompt-to-response requests.

→ Why the other options are wrong:

Option B: prompt sounds natural, but it is not the documented parameter here.

Option C: message is more of a chat-style term, not the top-level Responses API field.

Option D: question is plain English, but not the SDK parameter name.

Quick Memory Tip 🧠

Responses API prompt text goes in input.

→ Why the correct answer is right:

The quickstart pattern for image description uses prebuilt-imageSearch. That is the analyzer ID Microsoft shows for directly analyzing an image and returning a descriptive result such as a summary. It is the ready-to-use image analyzer, not the custom base analyzer.

→ Why the other options are wrong:

Option A: prebuilt-layout is document layout analysis.

Option B: prebuilt-documentSearch is document-oriented, not the image quickstart analyzer.

Option C: prebuilt-image is the base analyzer for custom image analyzers, not the direct quickstart ID.

Quick Memory Tip 🧠

Image description quickstart = prebuilt-imageSearch.

→ Why the correct answer is right:

Content Understanding needs the Foundry resource and the required supporting models before the SDK can run image extraction. Microsoft’s guidance ties the service to Foundry and says the required models must be deployed before using the Python client. Those are the core prerequisites for the workflow.

→ Why the other options are wrong:

Option A: Speech is a different Azure workload.

Option C: Search may be useful downstream, but it is not required setup for Content Understanding.

Option E: SSML is for speech synthesis, not image extraction.

Quick Memory Tip 🧠

Content Understanding setup = Foundry resource + required model deployment.

→ Why the correct answer is right:

This is the right pattern when you want structured fields from chart images. A custom analyzer based on prebuilt-image lets you define the schema, such as Title and ChartType, and then extract those fields from the image. It is precise and tailored to the image content.

→ Why the other options are wrong:

Option B: Speech cannot extract fields from images.

Option C: SSML controls spoken output, not image schemas.

Option D: Text to Speech generates audio from text, not image fields.

Quick Memory Tip 🧠

Structured chart fields from images = custom analyzer.

→ Why the correct answer is right:

Reliability and safety is about making sure the system behaves safely under risky or unexpected conditions. Filtering harmful content and stress-testing the app with adversarial prompts are direct ways to reduce unsafe outputs and improve dependable behavior. That is exactly what this scenario is asking for.

→ Why the other options are wrong:

Option A: Bias review is more closely tied to fairness.

Option C: Explainability is more closely tied to transparency.

Option D: Accessibility options are about inclusiveness, not safe output behavior.

Quick Memory Tip 🧠

Unsafe prompts → filter and stress-test.

→ Why the correct answer is right:

These three pairings match Microsoft’s documented Content Understanding image workflows. prebuilt-imageSearch is the ready-made analyzer used for image description, baseAnalyzerId is the property that points to the inherited base analyzer, and prebuilt-image is the base image analyzer used in the custom analyzer path.

→ Why the other options are wrong:

Option A: prebuilt-read is for OCR/document reading, not custom image inheritance.

Option C: fieldSchema is a real concept, but in this set the documented image workflow is more directly anchored by the analyzer and inheritance pairings above.

Option F: SSML is for speech synthesis, not image generation.

Quick Memory Tip 🧠

Image workflow terms: description, inheritance, base analyzer.

→ Why the correct answer is right:

Statement 1 is true because Content Understanding can process images into user-defined outputs. Statement 2 is also true because the quickstart uses prebuilt-imageSearch to generate an image description. Statement 3 is false because the custom image analyzer uses prebuilt-image as the base analyzer, not prebuilt-layout.

→ Why the other options are wrong:

Option A: It marks Statement 2 as No, which is wrong.

Option B: It marks Statement 1 as No, which is wrong.

Option D: It gets both Statement 1 and Statement 2 wrong.

Quick Memory Tip 🧠

Image quickstart and custom analyzer base are not the same thing.

→ Why the correct answer is right:

The custom analyzer pattern uses base_analyzer_id=”prebuilt-image” when building chart and graph analyzers. That tells the custom analyzer which base image analyzer to inherit from before applying your own field_schema. It is the exact documented inheritance setup.

→ Why the other options are wrong:

Option A: analyzer_id is not the property used for the base analyzer here.

Option C: prebuilt-imageSearch is the quickstart analyzer, not the custom analyzer base.

Option D: parent_analyzer is not the documented constructor field, and prebuilt-layout is the wrong analyzer family.

Quick Memory Tip 🧠

Custom chart analyzer = base_analyzer_id=”prebuilt-image”.

→ Why the correct answer is right:

The custom chart-image example is built around a simple schema: one field for the title and one field for the chart type. Title is a string field, and ChartType is classified using a small set of allowed values like bar, line, and pie. That combination makes the output structured and predictable.

→ Why the other options are wrong:

Option C: Summary with method: “generate” belongs to other analyzer scenarios, not the chart-image schema shown here.

Option D: Sentiment is a different kind of classification task and does not match the chart-image example.

Option E: prebuilt-audio is the wrong modality entirely for chart images.

Quick Memory Tip 🧠

Chart image schema = Title + ChartType.

→ Why the correct answer is right:

Reliability and safety is about safe, dependable behavior, especially when the system faces unexpected or risky conditions. Testing those edge cases is part of that job, and monitoring false negatives in harmful-content detection also supports safety because it helps catch dangerous misses. Understanding how the system works is useful, but that is more about transparency than reliability and safety.

→ Why the other options are wrong:

Option A: It wrongly says reliability and safety is mainly about understandability.

Option C: It wrongly denies that testing unexpected conditions is part of reliability and safety.

Option D: It gets the first statement wrong and also misses the false-negative monitoring point.

Quick Memory Tip 🧠

Unexpected behavior + harmful misses = reliability and safety.

→ Why the correct answer is right:

Generative AI models do not just memorize answers. They learn patterns from training data and then use those patterns to create new text, images, code, or audio that is statistically similar to what they learned. That is why they can answer different prompts in flexible ways rather than acting like a simple lookup table.

→ Why the other options are wrong:

Option A: Models do not store one fixed answer per prompt.

Option C: Copying source documents word for word is not the normal description of generative behavior.

Option D: Prompts are not converted into database tables.

Quick Memory Tip 🧠

Generative AI = pattern learning + new output.

→ Why the correct answer is right:

Reliability and safety focuses on whether the system behaves safely and consistently, especially when something goes wrong. The question about failure and unreliable outcomes gets right to that concern. The other choices map to neighboring responsible AI areas like inclusiveness, accountability, and transparency.

→ Why the other options are wrong:

Option A: That is more about inclusiveness.

Option B: That is more about accountability.

Option C: That is more about transparency.

Quick Memory Tip 🧠

Reliability and safety = failure modes.

→ Why the correct answer is right:

The purpose of the snippet is to detect harmful content in user text before it reaches another AI feature. analyze_text is the content safety method used for that job. It fits the moderation workflow and supports safer, more reliable AI behavior.

→ Why the other options are wrong:

Option B: Summarization changes the text instead of moderating it.

Option C: Entity extraction finds names and places, not harmful content.

Option D: Transcription is for audio, not already-written text.

Quick Memory Tip 🧠

Text moderation = analyze_text.

→ Why the correct answer is right:

Speech to text is the Azure Speech feature that listens to audio and converts it into text in real time. That makes it the right choice for live captions, dictation, and call transcription. The app needs recognition, not voice generation or search.

→ Why the other options are wrong:

Option A: Text to speech does the reverse job.

Option C: Agent Service is not the core speech-recognition capability.

Option D: Search is for retrieval, not transcription.

Quick Memory Tip 🧠

Live captions = speech to text.

→ Why the correct answer is right:

When a moderation system misses harmful content or blocks safe content, you need tuning and control. Adjusting severity thresholds and using blocklists are direct ways to improve moderation behavior and align the system with your safety policy. They help reduce both false negatives and false positives.

→ Why the other options are wrong:

Option C: A color change has nothing to do with moderation quality.

Option D: Shortening the FAQ does not change safety behavior.

Option E: Changing an icon does not affect harmful-content detection.

Quick Memory Tip 🧠

Moderation tuning = thresholds + blocklists.

→ Why the correct answer is right:

Microsoft’s Python quickstart for speech recognition shows the recognizer calling recognize_once_async().get() to capture one utterance and return the recognition result. That matches the scenario here because the app is listening to the microphone and needs a speech-to-text result.

→ Why the other options are wrong:

Option A: speak_text_async is a text-to-speech method, so it belongs to synthesis rather than recognition.

Option C: SpeechSynthesizer is the class used for text-to-speech output, not for recognizing microphone input.

Option D: speak_ssml_async is also a synthesis method, specifically for synthesizing SSML input into speech.

Quick Memory Tip 🧠

One utterance from mic = recognize_once_async().

→ Why the correct answer is right:

Text to speech is the Azure Speech capability that reads text aloud in a synthesized voice. That is exactly what a lesson-reading or narration app needs. The other options work in different directions or solve different problems.

→ Why the other options are wrong:

Option A: OCR extracts text from images.

Option B: Speech to Text converts audio into text.

Option C: Speech Translation translates speech, not lesson text narration.

Quick Memory Tip 🧠

Text in, voice out = text to speech.

→ Why the correct answer is right:

If the safety score drops below the threshold, the system should notify operators or trigger an alert. That is a practical reliability-and-safety response because it helps people react quickly when the model output is no longer within acceptable limits. Monitoring is useful only when it leads to action.

→ Why the other options are wrong:

Option A: A placeholder prompt does not respond to the safety issue.

Option B: Printing a model name does not alert anyone.

Option D: Setting the endpoint to None does not solve the problem.

Quick Memory Tip 🧠

Low safety score = alert operators.

→ Why the correct answer is right:

Medical summarization is a sensitive scenario. The most important reliability-and-safety step is to test how the system behaves in high-risk, unusual, or potentially harmful situations before it goes live. That is how teams catch unsafe behavior early instead of discovering it after deployment.

→ Why the other options are wrong:

Option B: A brighter theme affects appearance, not safety.

Option C: Marketing copy does not reduce clinical risk.

Option D: Renaming the workspace changes administration, not model safety.

Quick Memory Tip 🧠

High-risk use case = test edge cases first.

→ Why the correct answer is right:

Generative language models work token by token. A token is a chunk of text, and the model predicts the next token using the prompt and everything it has generated so far. That step-by-step process is what makes language generation possible.

→ Why the other options are wrong:

Option A: Tables are output formats, not generation units.

Option B: Image layers belong to image generation, not text generation.

Option D: A schema is a structure, not the item predicted during generation.

Quick Memory Tip 🧠

Text generation is token-by-token.

→ Why the correct answer is right:

recognize_once_async is for one utterance, start_continuous_recognition_async is for longer multi-utterance input, and Voice Live API is the combined real-time voice-agent interface that brings speech recognition, generative AI, and text-to-speech together. All three statements are true.

→ Why the other options are wrong:

Option A: It wrongly says continuous recognition is not the better choice for long input.

Option B: It wrongly denies that recognize_once_async is for a single utterance.

Option C: It wrongly denies the Voice Live API description.

Quick Memory Tip 🧠

One utterance, continuous speech, and voice agents are three different things.

→ Why the correct answer is right:

These three terms are foundational. Embeddings represent meaning numerically, prompts are the instructions you give the model, and fine-tuning updates model weights using task-specific examples. Together they describe how modern AI systems are guided, adapted, and represented.

→ Why the other options are wrong:

Option B: A base model is not yet customized.

Option D: Hallucination is unsupported output, not guaranteed grounding.

Option F: A completion token is generated text, not a form field.

Quick Memory Tip 🧠

Embedding, prompt, and fine-tuning are separate concepts.

→ Why the correct answer is right:

Generative AI models learn patterns from large datasets. Base models are not yet customized for a specific use case, and embeddings are useful for representing semantic similarity. So the right pattern is Yes / No / Yes.

→ Why the other options are wrong:

Option A: It wrongly claims a base model is already customized.

Option C: It wrongly denies that generative AI learns patterns from large datasets.

Option D: It wrongly denies both the training and embedding statements.

Quick Memory Tip 🧠

Base model = not customized yet.

→ Why the correct answer is right:

Reliability and safety includes resisting harmful manipulation from adversarial or unexpected prompts. In other words, the system should remain safe and dependable even when someone tries to push it into bad behavior. That is exactly what this sentence is describing.

→ Why the other options are wrong:

Option A: Model cards are documentation, not something the system resists.

Option B: Stakeholder mapping is part of risk analysis, not a threat the model resists.

Option D: Explainability relates more to transparency than to resisting manipulation.

Quick Memory Tip 🧠

Adversarial prompts = harmful manipulation.

→ Why the correct answer is right:

To translate from English into French, you add French as a target language on the translation configuration. The app listens in one language and adds one or more output target languages before creating the recognizer. That is the correct setup pattern.

→ Why the other options are wrong:

Option A: speak_text_async is for synthesis, not translation setup.

Option B: recognize_once_async is a recognizer method, not a configuration method.

Option C: remove_target_language does the opposite of what this app needs.

Quick Memory Tip 🧠

Translation setup = add target language.

→ Why the correct answer is right:

Microsoft's Responses API examples use input for the user prompt text. So the prompt goes in the input parameter when you call responses.create(...). This is the documented pattern for simple requests.

→ Why the other options are wrong:

Option B: prompt is a common word, but not the documented field here.

Option C: message belongs to a different request style.

Option D: content is used in some message structures, not this top-level field.

Quick Memory Tip 🧠

Responses API prompt field = input.

→ Why the correct answer is right:

Prompts shape the model's response, and fine-tuning can change the model's weights for a task. Those are both true descriptions of how generative AI systems are guided and adapted. The other statements are too absolute or describe different technologies.

→ Why the other options are wrong:

Option B: Outputs are not guaranteed to be identical in every context.

Option D: Base models do not automatically know private company data.

Option E: Embeddings are semantic vectors, not relational table rows.

Quick Memory Tip 🧠

Prompts guide output; fine-tuning changes weights.

→ Why the correct answer is right:

A base model is the original model before task-specific customization. It has not yet been fine-tuned for a particular business use case. That is the term Microsoft uses for the starting point of many generative AI solutions.

→ Why the other options are wrong:

Option A: A grounded response is an output supported by data, not a model type.

Option B: An agent session is an interaction context, not a model.

Option D: A vector store holds embeddings, not a model definition.

Quick Memory Tip 🧠

Untuned model = base model.