Free Microsoft AI-103 Practice Test Questions MCQs

Explanation:

This question tests your ability to complete Python code for authenticating and interacting with models in a Microsoft Foundry project using the Azure AI Projects SDK. It specifically evaluates setting up Microsoft Entra managed identity credentials and executing a chat or text inference request via the Responses API.

✅ Correct Option:
DefaultAzureCredential is the standard class from the azure.identity package used to handle Microsoft Entra token authentication, seamlessly resolving to a managed identity at runtime in Azure environments. The .responses.create method is the designated API function within the client library used to programmatically submit prompts (input) and parameter payloads to a deployed model to generate an AI response.

❌ Incorrect options:

AzureKeyCredential:
This class is exclusively dedicated to API-key-based authentication, which violates the requirement to authenticate using a Microsoft Entra managed identity.

ClientSecretCredential:
This credential type explicitly requires a hardcoded application ID and a client secret value, rather than dynamically inheriting an Azure managed identity.

compact:
This is an invalid method name for initiating model inference or text generation workflows within the Azure AI SDK structure.

retrieve:
This method is conventionally reserved for fetching metadata or current state tracking configurations of an existing run or asset rather than creating a new generative response payload.

🔧 Reference:
→ Microsoft Foundry SDKs and Endpoints confirms that using DefaultAzureCredential handles Entra ID managed identity tokens, and the client manages model inference requests through its integrated generative endpoints.

Explanation:

This question tests your understanding of how to maintain conversation history and continuity across sessions in Microsoft Foundry Agent Service. The requirements include multi-turn continuity within a session, cross-session continuity for the same customer case, and access to full interaction history (user messages, agent messages, tool calls, and tool outputs). In Foundry, the conversation object is specifically designed for this purpose—it is a durable, persistent object that stores all items across turns and can be reused across sessions by storing and supplying its ID on subsequent requests .

✔️ Option C: Create and reuse a conversation by storing the conversation's ID and supplying the ID on subsequent requests. (Correct)
In Microsoft Foundry Agent Service, a conversation is a durable object with a unique identifier that automatically manages message history across turns . Conversations store all interaction items including user messages, agent responses, tool calls, and tool outputs . By creating a conversation once and persistently storing its ID (e.g., in a database or client-side storage linked to the customer's case), you can supply that ID on every subsequent request. This ensures the agent automatically loads the complete historical context on each new turn, meeting both intra-session and cross-session continuity requirements . The conversation ID provides a stable reference for resuming a support case even after days of inactivity .

❌ Option A: Persist only the final model response stored in the client application and prepend the response to future prompts. (Incorrect)
Persisting only the final model response is incomplete because it loses the full interaction history—user messages, tool calls, and tool outputs. Preprending only the last response to future prompts would not provide the "complete history" required for the agent to resume context accurately. Additionally, this approach requires manual reconstruction of context and does not leverage Foundry's built-in state management, making it brittle and prone to missing critical details from previous turns.

❌ Option B: Enable memory summarization on the agent definition to persist the context automatically. (Incorrect)
Memory summarization is a feature for retaining important data over time, but it is distinct from conversation history. It is more focused on long-term storage of key information rather than preserving the full, chronological transcript of all messages, tool calls, and outputs . The requirement explicitly asks for access to the "full interaction history, including user messages, agent messages, tool calls, and tool outputs," which is not what summarization provides. Memory summarization may condense or abstract context and would not ensure that the agent reloads complete, unmodified history on each turn.

🔧 Reference:
→ Build with agents, conversations, and responses | Microsoft Learn - Confirms conversations are durable objects with unique identifiers that store items including messages, tool calls, and outputs, and can be reused across sessions by storing the conversation ID.

Explanation:

This question tests understanding of which model category fits a customer support agent requiring grounded retrieval, deep reasoning, and detailed natural language generation. The scenario needs a model capable of processing long retrieved contexts, performing multi-step reasoning, and producing rich conversational output.

✅ Correct Option:

D. a large language model (LLM) — LLMs are trained on massive datasets and have the parameter scale needed to support deep, multi-step reasoning across long contexts, understand nuanced natural language queries, and generate detailed, coherent responses. When paired with retrieval from Azure AI Search, an LLM can ground its answers in internal product documentation while still handling the complex reasoning and long-context requirements described in the scenario.

❌ Incorrect options:

A. a multimodal model — Multimodal models are designed to process and reason across multiple input types, such as text, images, and audio, together. The scenario only describes text-based product documentation and natural language responses, so multimodal capability isn't the requirement being tested here.

B. a key phrase extraction model — Key phrase extraction models are narrow NLP tools that pull out important terms or phrases from text; they don't generate natural language responses or perform reasoning. This model type cannot satisfy the requirement for detailed, conversational output.

C. a small language model (SLM) — SLMs are optimized for lower latency and cost with a smaller parameter footprint, but this comes at the expense of reasoning depth and long-context handling. They're better suited to lightweight, narrow tasks rather than the deep multi-step reasoning and long-context grounding this scenario demands.

🔧 Reference:
→ Microsoft Learn – What are large language models? — confirms LLMs are designed for complex reasoning, long-context understanding, and generating detailed natural language responses, forming the foundation of retrieval-augmented generation solutions on Azure.

Explanation:

This question tests understanding of how temperature affects the behavior of generative AI models in Microsoft Foundry agents, and whether changing it can improve response completeness when required regulatory clauses are being omitted. The scenario is that users report some responses miss required clauses even when those clauses are present in retrieved policy documents.

✔️ Correct Option (B):
Increasing the temperature value makes the model more creative and variable, not more deterministic or complete. It encourages diverse wording and can lead to more omissions, hallucinations, or inconsistent inclusion of required content. To improve response completeness and ensure that required regulatory clauses are consistently included, you need to reduce randomness (lower temperature) and/or improve grounding, prompt instructions, or retrieval. Therefore, increasing temperature does not meet the goal of improving response completeness.

❌ Incorrect option:

❌ A (Yes):
Choosing “Yes” implies that increasing temperature would help ensure required clauses are included. This contradicts how temperature works: higher temperature increases randomness and reduces strict adherence to instructions or source content. It would not address the problem of missing required clauses and could make the issue worse.

🔧 Reference:
⇒ Microsoft Learn – GPT Realtime & language model parameters (temperature)
This confirms that temperature controls randomness: higher values increase variability, while lower values make outputs more deterministic and instruction-following, which is what you want for consistent inclusion of required clauses.

⇒ Microsoft Learn – Understanding “Yes/No” solution questions in certification exams
This explains that for Yes/No scenario questions, if the proposed solution does not completely solve the stated problem, the correct answer is “No”. Increasing temperature does not solve the completeness problem.

Explanation:

This question tests your understanding of protecting AI applications from prompt injection attacks, specifically when processing content from external sources like user-uploaded documents. The scenario involves extracting and appending OCR text from uploaded images to a model's prompt. This creates a risk of indirect attacks, also called cross-domain prompt injection attacks, where hidden instructions embedded within third-party content can hijack the model's behavior. Prompt Shields for documents is the feature designed to detect and mitigate exactly this type of threat.

✔️ Option D: prompt shields for documents (Correct)
Prompt Shields for documents is the correct safeguard because it protects against indirect attacks that come from "information not directly supplied by the user or developer, such as external documents". Attackers can hide commands in user-provided files, and when OCR text from an uploaded image is appended to the prompt, the model might inadvertently follow them. Enabling this shield ensures that text extracted from uploaded images is scanned for embedded malicious instructions before it reaches the model, meeting the requirement to prevent processing of potentially malicious content.

❌ Option A: protected material text (Incorrect)
Protected material detection is used to scan AI-generated text for copyrighted content like song lyrics or articles. It does not prevent prompt injection attacks, so it is irrelevant to the stated requirement.

❌ Option B: prompt shields for user prompts (Incorrect)
Prompt shields for user prompts is designed to detect direct attacks from user inputs, such as jailbreak attempts aimed at bypassing system rules. The threat in this scenario comes from content extracted from images, which is treated as third-party "document" input, making this option insufficient.

❌ Option C: image moderation (Incorrect)
Image moderation analyzes visual content for harmful categories like violence or sexual content. It does not detect hidden text-based instructions embedded within the image itself, nor does it prevent the model from acting on them. Furthermore, embedded text in images is typically not analyzed by standard image moderation algorithms.

🔧 Reference:
→ Prompt Shields in Microsoft Foundry | Microsoft Learn - Confirms Prompt Shields detect and prevent attempts to manipulate model behavior through adversarial inputs, including document attacks where hidden instructions are embedded in third-party content.

Explanation:

This question tests knowledge of the custom speech model lifecycle in Azure Speech in Foundry Tools, specifically what happens at a real-time speech recognition endpoint once the deployed custom model reaches its transcription expiration date. This distinction is important for planning model refresh cycles without unexpected service disruption.

✅ Correct Option:

A. Speech recognition requests will fall back to the most recent base model for the same locale — When a custom model expires, the custom endpoint doesn't fail; instead, it automatically switches to using the latest base model available for that locale. Recognition continues to return results, but accuracy for domain-specific terms may degrade since the specialized customization is no longer applied. This is the documented expected behavior at expiration.

❌ Incorrect options:

B. Speech recognition requests will continue to use the expired custom model until the model is removed manually — Once a model passes its transcription expiration date, it is no longer available for transcription regardless of whether it has been manually deleted. The endpoint does not keep using the expired model; it automatically redirects requests to the base model.

C. Speech recognition requests will return a 4xx error until a new custom model is deployed — A 4xx error on expiration applies specifically to batch transcription requests that explicitly specify an expired model ID. Real-time recognition through a deployed custom endpoint does not fail with an error; it falls back gracefully to the base model instead.

D. The custom model will be deleted automatically when the model expires — Expiration only affects whether the model can be used for transcription; it does not trigger automatic deletion. The model and its metadata remain in the collection unless explicitly deleted by the user.

🔧 Reference:
→ Microsoft Learn – Custom speech model lifecycle — confirms that expired custom model requests fall back to the most recent base model for the same locale, while expired batch transcription requests fail with a 4xx error.

Explanation:

This question tests how to grant developers model inference access to an Azure OpenAI (Foundry) model deployment using RBAC and managed identity, while following the principle of least privilege. The application uses the Azure OpenAI v1 API with DefaultAzureCredential, and developers are getting HTTP 403 (authorization failed) errors even after az login, which indicates they lack the required RBAC role for inference.

✔️ Correct Option (A):
Cognitive Services OpenAI User is the purpose-built RBAC role that allows users to perform model inference calls (create completions and embeddings) against Azure OpenAI deployments, while not allowing resource creation, key management, or model deployment changes. This exactly matches the requirement: developers need to perform inference, and the solution must follow least privilege. Official documentation confirms this role enables inference calls without broader administrative permissions.

❌ Incorrect options:

❌ B (Cognitive Services Data Reader):
This role is scoped to read data/logs and usage information, not to perform inference operations. It does not grant permissions to call completion or embedding APIs, so developers would still receive 403 errors when sending inference requests.

❌ C (Cognitive Services User):
This role allows reading and listing keys for Cognitive Services resources, but it does not include inference permissions for Azure OpenAI deployments. It is also not specific to OpenAI; it is more general and still insufficient for the required inference operations.

❌ D (Contributor):
Contributor is a broad management role that allows creating and managing resources, deployments, and keys. While it would technically allow inference, it violates the least privilege requirement because it grants far more permissions than necessary. The exam explicitly expects the minimal, purpose-built role for inference.

🔧 Reference:
⇒ Microsoft Learn – Azure built-in roles
This confirms that the Cognitive Services OpenAI User role provides read access to models and deployments and allows creating completion and embedding calls (inference), without broader management permissions.

Explanation:

This question tests observability and evaluation practices for RAG agents in Microsoft Foundry using Azure AI Search. It focuses on diagnosing why retrieved content leads to inaccurate responses after updates.

✅ Correct Option:

B. groundedness evaluation metrics
Groundedness metrics measure how faithfully the agent's generated response aligns with the retrieved context without fabrication or omission of key details. Reviewing these signals (often via LLM-as-judge evaluators) directly identifies whether poor grounding from the updated documents is causing the accuracy drop.

❌ Incorrect options:

A. prediction drift metrics
Prediction drift tracks changes in model output distribution over time. It does not specifically analyze the relationship between retrieved content and generated responses.

C. latency breakdown traces
Latency traces help diagnose performance issues. They provide no insight into response accuracy or grounding quality.

D. indexer status and failure history
Indexer status checks ingestion health. It confirms content was indexed but does not evaluate how that content affects response quality.

🔧 Reference:
→ Retrieval-Augmented Generation (RAG) Evaluators for Generative AI
Describes groundedness evaluators for assessing alignment between retrieved context and agent responses.

Explanation:

This question tests knowledge of Azure Content Understanding and selecting the correct built-in analyzer for document processing scenarios. The requirement includes preserving document layout, extracting tables and structural elements, and detecting embedded QR codes from scanned PDFs without using a language model. The correct choice is the analyzer specifically designed for document structure and layout extraction.

🟢 Correct Option:

A. prebuilt-layout

The prebuilt-layout analyzer extracts document structure while preserving layout information such as paragraphs, tables, sections, and reading order. It also supports detection of elements like barcodes and QR codes in scanned documents. Because it focuses on document understanding without requiring a language model deployment, it satisfies all requirements for structured extraction and downstream processing.

🔴 Incorrect options:

B. prebuilt-documentFieldSchema

This analyzer is intended for extracting predefined fields according to a schema rather than preserving complete document structure. It focuses on structured field extraction and does not primarily address layout preservation or comprehensive QR code detection requirements.

C. prebuilt-read

The prebuilt-read analyzer performs optical character recognition to extract text from documents and images. However, it mainly focuses on text recognition and does not provide the richer layout understanding needed for tables, document structure, and QR code-based processing.

D. prebuilt-documentSearch

The prebuilt-documentSearch analyzer is designed for document search and retrieval scenarios rather than extracting detailed layout structures. It does not specifically preserve document organization or provide the required content and QR code extraction capabilities.

🔧 Reference:

⇒ Microsoft Learn – What is the Document Intelligence layout model?
Confirms that the prebuilt-layout model extracts document structure, tables, reading order, and barcode information.

⇒ Microsoft Learn – What is Azure Document Intelligence in Foundry Tools?
Confirms capabilities for extracting layout and structured content from documents.

Explanation:

This question tests your ability to design document intelligence pipelines in Microsoft Foundry. It focuses on identifying an analytical tool that extracts specific, user-defined semantic values (like invoice number and total amount) across diverse layouts while calculating exact field-level extraction confidence scores for manual review routing.

✅ Correct Option:
A custom Azure Content Understanding analyzer allows developers to explicitly declare a target schema specifying required fields like invoice number, date, vendor, and amount. Because it is custom-built to generalize across layouts, it extracts these specific key-value pairs from varying invoice templates and naturally provides accurate, field-level extraction confidence scores to cleanly route items below 0.80 for supervisor verification.

❌ Incorrect options:

A. the Azure Content Understanding in Foundry Tools prebuilt-layout analyzer
The prebuilt-layout analyzer extracts general document structures, including paragraphs, text blocks, and tables. It does not provide semantic key-value extraction for explicit financial fields like "invoice number" or "total amount" out of the box, nor does it deliver field-specific validation confidence scores for downstream routing.

B. a Foundry agent that has groundedness guardrails enabled to extract invoice fields and confidence scores
Groundedness guardrails validate whether an agent's conversational output is based directly on the provided context to prevent hallucinations. They evaluate the truthfulness of a language model's text generation rather than serving as an extraction pipeline that outputs structured mathematical field extraction confidence scores.

D. the Azure Content Understanding in Foundry Tools prebuilt-documentSearch analyzer and search.score from the Azure AI Search results for routing
The prebuilt-documentSearch analyzer is optimized to chunk and index content for search and retrieval engines. The resulting search.score measures the keyword or semantic relevance of a search result matching a query; it does not measure the extraction accuracy of data values inside the invoice document.

🔧 Reference:
→ Custom analyzers in Azure Content Understanding confirms that defining custom extraction fields returns explicit, targeted schema values along with field-specific extraction confidence scores ideal for automated validation routing.