Free AI-103 Practice Test Questions and Answers (2026)

The operational cost of large language models (LLMs) used in agents is primarily determined by the number of tokens processed. This includes tokens in the input prompt (model input size), tokens in the generated response (model output size), and tokens consumed by any integrated tools. By monitoring token usage, specifically metrics like prompttokens, completiontokens, and totaltokens, you can directly identify which component is responsible for the increased consumption and, consequently, the higher costs. This provides a precise, quantifiable measure to diagnose the financial impact of the recent update.

A. evaluation metrics: These metrics (e.g., relevance, groundedness) assess the quality and performance of the model's output, not the resource consumption or cost associated with generating it.

C. latency: Latency measures the response time of the agent. While larger inputs/outputs can increase latency, it is a performance metric, not a direct measure of operational cost.

D. run success rate: This metric indicates the reliability of the agent by tracking successful versus failed executions. It does not provide insight into the cost drivers of the successful runs.

---

1. Azure Machine Learning Documentation - Monitor prompt flow endpoints in production: This official document lists the key metrics collected for prompt flow endpoints. It explicitly mentions prompttokens, completiontokens, and totaltokens as available metrics for understanding consumption.

Reference: Microsoft. (n.d.). Monitor and collect data from prompt flow endpoints in production. Azure Machine Learning documentation. Retrieved from the official Microsoft Learn website. In the section "View metrics in Azure portal," see the table "Available metrics for prompt flow endpoints," which lists token-related metrics.

2. Azure OpenAI Service Pricing: The official pricing model for Azure OpenAI Service directly links cost to token consumption. The pricing is specified "per 1,000 tokens" for both prompt and completion, which confirms that token usage is the fundamental unit of cost.

Reference: Microsoft. (n.d.). Azure OpenAI Service - Pricing. Microsoft Azure. Retrieved from the official Microsoft Azure pricing page. Review the pricing tables for models like GPT-4 or GPT-3.5-Turbo, which show distinct costs for "Input" and "Output" tokens.

3. Azure Machine Learning Documentation - How to evaluate a prompt flow: This document details the built-in and custom evaluation metrics available in Prompt Flow. It lists metrics like "Groundedness," "Relevance," and "Coherence," demonstrating that their purpose is to measure quality, not cost.

Reference: Microsoft. (n.d.). How to evaluate a prompt flow. Azure Machine Learning documentation. Retrieved from the official Microsoft Learn website. See the section "Evaluation metrics."

Meeting security and compliance requirements often involves adhering to data privacy regulations such as GDPR, HIPAA, or CCPA. A primary concern in these regulations is the handling of Personally Identifiable Information (PII). The PII detection feature, available in services like Azure AI Language, is specifically designed to identify and redact sensitive personal data from text. Implementing PII detection for Agent1 is a direct and crucial step to prevent the unintentional processing or logging of sensitive user data, thereby ensuring compliance with data protection laws and enhancing security.

A. prompt shields: This is a security feature to protect against prompt injection attacks, not a general compliance control for handling user data.

C. self-harm content filtering: This is a content safety feature for responsible AI, focused on a specific category of harmful content, not a primary requirement for data privacy compliance.

D. violence content filtering: Similar to self-harm filtering, this is a specific content safety control rather than a foundational security and compliance measure for protecting personal data.

1. Microsoft Learn, Azure AI Language Documentation, "Detect and redact personal information": "The PII detection feature can evaluate unstructured text, and can identify and redact sensitive information in text... This can be useful in a variety of scenarios, such as redacting personal information from customer support conversations... to be compliant with local and industry-wide regulations."

2. Microsoft Learn, Azure AI Services Documentation, "What is Azure AI Content Safety?": This document outlines the primary content filtering categories as Hate, Sexual, Violence, and Self-harm. This positions options C and D as specific content safety features, distinct from the broader compliance function of PII detection.

3. Microsoft Learn, Azure OpenAI Service Documentation, "Responsible AI practices for Azure OpenAI models": Under the "Protecting data, privacy, and security" section, it discusses the importance of data protection. PII detection is a key technology for implementing this principle, whereas content filtering is discussed separately under "Mitigating harmful content."

In Azure AI Studio (formerly Microsoft Foundry), an OpenAPI tool must be explicitly associated with a connection to use the credentials stored within it. The 401 Unauthorized error, coupled with the trace showing a missing API key header, indicates that the tool is not configured to retrieve the key. By connecting the tool to Connection1, the AI Studio runtime is instructed to fetch the API key from that connection and automatically inject it into the HTTP header of every request, as defined by the tool's authentication settings. This resolves the authentication failure.

A. There is no concept of a generic "default connection" for custom OpenAPI tools in a project; connections must be explicitly assigned to the tools that use them.

C. Identity passthrough uses the caller's Microsoft Entra ID token for authentication, which is incorrect for an external API that specifically requires a static API key.

D. Hardcoding secrets like an API key directly into the OpenAPI specification is a severe security anti-pattern and is not the correct or secure way to manage credentials.

1. Microsoft Learn, "How to use OpenAPI tool in prompt flow":

Section: Set up OpenAPI tool > Authentication

Content: This document explicitly states, "For API Key, you need to select a connection that contains the API key." This confirms that the tool must be connected to the specific connection resource to function correctly. The UI shown in the documentation includes a dropdown to select the appropriate connection.

2. Microsoft Learn, "Connections in Azure AI Studio":

Section: Overview

Content: "Connections in Azure AI Studio are a way to store and manage secrets and credentials that your application needs to connect to external services... When you create a connection, you select a connection type and provide the required information to connect to the service." This establishes that connections are the designated mechanism for storing secrets like API keys, which are then consumed by other components like tools.

The problem requires a solution that can process invoices with varied layouts, perform OCR, understand the document structure (layout analysis), and extract specific fields like totals and invoice numbers. Crucially, the solution must not require training a custom model and should minimize administrative effort.

Azure AI Document Intelligence (formerly Form Recognizer) offers a prebuilt invoice model that is specifically designed for this purpose. This service combines advanced OCR with deep learning models to understand the layout and semantics of invoices. It can accurately extract key-value pairs (e.g., "Invoice Number:" and its value), line items from tables, and totals, even from documents it has never seen before. As a prebuilt model, it requires no training, directly meeting the problem's constraints and minimizing administrative overhead. The option "Azure Content Understanding" is the best description of this capability among the choices.

A. an Azure Machine Learning model: This option is incorrect because it involves building, training, and deploying a custom model, which explicitly violates the requirement to NOT train a custom model and would maximize administrative effort.

C. Azure Language in Foundry Tools: This is incorrect because Azure AI Language service is designed for natural language processing on unstructured text. It does not analyze the visual layout or geometric structure of a scanned document, which is the core reason the current OCR-only pipeline is failing.

1. Azure AI Document Intelligence - Prebuilt Invoice Model:

Microsoft Learn. (2023). Document Intelligence invoice model. "The prebuilt invoice model is ready to use without any training. It combines our powerful Optical Character Recognition (OCR) capabilities with deep learning models to extract key information from invoices." This confirms it provides OCR, layout analysis, and field extraction without custom training.

Reference: https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/concept-invoice?view=doc-intel-4.0.0, Section: "Invoice model overview".

2. Azure Machine Learning Overview:

Microsoft Learn. (2023). What is Azure Machine Learning?. "Azure Machine Learning is a cloud service for accelerating and managing the machine learning project lifecycle. Machine learning professionals, data scientists, and engineers can use it in their day-to-day workflows: Train and deploy models..." This highlights that its primary purpose is for creating custom models, which is disallowed by the question.

Reference: https://learn.microsoft.com/en-us/azure/machine-learning/overview-what-is-azure-machine-learning?view=azureml-api-2, Section: "What is Azure Machine Learning?".

3. Azure AI Language Service Overview:

Microsoft Learn. (2023). What is Azure AI Language?. "Azure AI Language is a cloud-based service that provides Natural Language Processing (NLP) features for understanding and analyzing text." This shows its focus is on linguistic analysis of text, not the structural or layout analysis of a visual document like a PDF invoice.

Reference: https://learn.microsoft.com/en-us/azure/ai-services/language-service/overview, Section: "What is Azure AI Language?".

A reflection pass is an agentic design pattern where the AI agent reviews and critiques its own generated output against the source material and initial instructions. By adding a logical step in the code for the agent to "reflect" on its summary—asking itself if it missed any key points from the policy documents—it can identify and correct omissions. This self-correction loop directly addresses the goal of improving response completeness before the final answer is returned to the user.

A. Decreasing the temperature parameter makes the model's output more deterministic and less creative, which does not inherently improve the completeness of a summary.

C. The scenario describes an agent that "generates summaries from retrieved policy documents," which is already the definition of a Retrieval Augmented Generation (RAG) pattern. Therefore, this is not a change.

D. Enabling response streaming affects the delivery method of the response (showing it token-by-token) to improve perceived latency, but it does not alter the final content or its completeness.

1. Microsoft Learn, Prompt engineering techniques, "Chained-thought prompting" section: This official documentation describes breaking down a complex task into intermediate steps. A reflection pass is an advanced form of this, where one step is generating a response and a subsequent step is evaluating and refining it. This is implemented in the application logic.

Source: Microsoft Learn, "Prompt engineering techniques". In the context of improving outputs, chaining prompts to have the model review its work is a documented strategy.

2. Shinn, N., Labash, B., & Gopinath, A. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv preprint arXiv:2303.11366. (Cornell University). This foundational academic paper defines the "Reflexion" technique where an agent verbally reflects on its past actions and outputs to produce a better plan or refined response in subsequent attempts.

Source: Section 3, "THE REFLEXION FRAMEWORK," describes the process: "The agent uses the feedback to reflect and generate verbal self-reflections... These reflections are then added to the agent’s working memory... to produce a better action in the next trial."

DOI: https://doi.org/10.48550/arXiv.2303.11366

3. Microsoft Learn, "Build your own copilot with prompt flow": Prompt flow in Azure AI Studio is the tool used to implement such complex logic. It allows developers to chain multiple Large Language Model (LLM) calls and code steps, which is the mechanism for implementing a generation step followed by a reflection/evaluation step.

Source: Microsoft Learn, "Build your own copilot with prompt flow". The documentation illustrates creating multi-step workflows, which is the prerequisite for implementing a reflection pass.

To fulfill the requirement of preventing harmful content from being returned during runs, the guardrail action must be configured to Block. Applying this action across all interaction points (User input, Output, Tool response, and Tool call) ensures comprehensive coverage for an agent that utilizes tools (like the ticketing tool) and processes data dynamically.

For the storage access requirement, following the principle of least privilege dictates that the service only needs read access to evaluate the image at the blob URL. Utilizing a system-assigned managed identity with the Storage Blob Data Reader role provides secure, credential-free read access to Azure Storage without granting unnecessary write or delete permissions (which Contributor would grant) or relying on static access keys (which violates modern security best practices).

Microsoft Learn: Configure Azure AI Content Safety for Azure Storage - Specifies the requirement of the Storage Blob Data Reader role for managed identities accessing blob data for analysis. (Source: Microsoft Azure Documentation)

Microsoft Learn: How to use Content Safety in Prompt flow / Azure AI Foundry - Details configuring guardrail policies, emphasizing the "Block" action to halt execution when thresholds are met across inputs and tool outputs. (Source: Microsoft Azure Documentation)

Microsoft Learn: Azure built-in roles for storage - Defines "Storage Blob Data Reader" as the correct role for strictly reading blob containers and data, adhering to the principle of least privilege. (Source: Microsoft Azure Documentation)

If/else condition expression: The objective is to verify that the variable holds a value. In Power Fx, IsBlank() checks if a scalar value or string is empty or null. By wrapping it in the Not() function, Not(IsBlank(Local.Var01)) evaluates to true only when data is present. The option IsEmpty() is incorrect for this scenario because it is specifically designed to test whether a data table contains zero records, not to check scalar variables.

Send message expression: The objective is to format the text output in uppercase. The Power Fx function Upper() is used to convert strings to all uppercase characters. Proper syntax in this context requires the variable to be referenced with its scope identifier to prevent ambiguity, making {Upper(Local.Var01)} the correct choice over {Upper(Var01)}.

Microsoft Power Platform Documentation - Blank, IsBlank, and IsEmpty functions: details that IsBlank tests for empty strings or nulls, whereas IsEmpty tests for empty tables. (https://learn.microsoft.com/en-us/power-platform/power-fx/reference/function-isblank-isempty)

Microsoft Power Platform Documentation - Lower, Upper, and Proper functions: defines the Upper function as the standard method for converting text strings to uppercase. (https://learn.microsoft.com/en-us/power-platform/power-fx/reference/function-lower-upper-proper)

Microsoft Power Platform Documentation - Logical functions: outlines the use of the Not function to invert a boolean logic check. (https://learn.microsoft.com/en-us/power-platform/power-fx/reference/function-logicals)

To properly diagnose the root causes of the reported user issues, you must map the symptoms to the correct Azure AI telemetry data streams:

1. Model Unavailability and Resource Limits: Selecting Model Availability Rate and Provisioned Utilization directly addresses these two concerns. The Model Availability Rate tracks the ratio of successful calls to server errors (HTTP 5xx), which identifies if the model is genuinely unavailable. Provisioned Utilization (or standard rate-limit tracking) monitors resource consumption against allocated capacities. Exceeding 100% utilization triggers the HTTP 429 "rate limit exceeded" errors.
2. Inference failures: Collecting the RequestResponse diagnostic log is required to debug the "No relevant information found" issue. This log category captures the specific HTTP request payloads (prompts and injected context) and response payloads (model completions). By examining these logs, developers can trace whether the Retrieval-Augmented Generation (RAG) search step failed to provide context, or if the model's inference simply failed to synthesize the answer correctly. (Note: The trace log option is primarily utilized for legacy Custom Question Answering or specific legacy AI pipelines, not standard base model inference diagnostics).

Microsoft Learn: Supported metrics with Azure Monitor (Microsoft.CognitiveServices/accounts/projects). Details the use of ModelAvailabilityRate for tracking server-side availability and ProvisionedUtilization for identifying throttling limits (error code 429). Available at Microsoft Learn: Monitor Models

Microsoft Learn: Enable diagnostic logging for Azure AI services. Specifies that RequestResponse logs capture API operational data (prompts, completions, and status codes) vital for diagnosing inference behavior and logic errors. It also clarifies that trace logs are traditionally restricted to Custom QA. Available at Microsoft Learn: Diagnostic Logging

Dropdown 1 (DefaultAzureCredential()): The case study explicitly mandates that "API keys must NOT be used" and that developers must authenticate "by using Microsoft Entra authentication." DefaultAzureCredential() from the azure.identity module provisions this token-based Entra ID authentication context. Choosing AzureKeyCredential() would violate the security constraint by relying on API keys.

Dropdown 2 (get): The goal of the Python script is to grant the Agent1Dev team access to the existing agent ("Agent1") to maintain it. The correct method to retrieve an existing agent instance by its name in the Azure AI Projects SDK is get. Using create_version would generate a new iteration rather than retrieving the current baseline state.

Microsoft Azure SDK for Python Documentation: Context on azure.identity and Entra ID integrations. Specifying the usage of DefaultAzureCredential over AzureKeyCredential for role-based, keyless access.

Azure AI Projects Client Library for Python (Official GitHub / MS Learn): azure-ai-projects module documentation. Section detailing Agent Operations, specifically the usage of project_client.agents.get(agent_name=...) to retrieve established agent topologies. (Source: Azure SDKs, Microsoft azure-sdk-for-python/tree/main/sdk/ai/azure-ai-projects).

According to official Microsoft Foundry Agent Service documentation, Memory is the capability specifically designed to capture, consolidate, and persist user-specific context (such as preferences and profiles) across multiple sessions and interactions.For the second requirement, the File search tool is explicitly recommended by Microsoft to allow users to dynamically upload and search their own documents for contextual grounding during a chat interaction.

Microsoft Learn. "Memory in Microsoft Foundry Agent Service (preview)". Concepts. The "Consider these guidelines" section explicitly states to "Use memory to capture user-specific or agent context that is learned and persists through interactions over time" and to "Use the file search tool to search user-provided documents during an interaction."

To evaluate answers that are unsupported by retrieved documents, Groundedness evaluation metrics must be used. Groundedness specifically measures how accurately a generative AI model's response aligns with and relies upon the provided context (the retrieved documentation), helping identify hallucinations or unverified claims in Retrieval-Augmented Generation (RAG) scenarios.

For responses flagged for policy violations, Risk and safety metrics are required. These metrics monitor the application's outputs for harmful, biased, or inappropriate content that violates predefined safety configurations and content filters. Latency breakdown and token usage are operational performance metrics and do not evaluate output accuracy or safety compliance.

Microsoft Learn: Azure AI Foundry Documentation - Evaluation metrics for generative AI. * Section: Quality and Safety Metrics.

Relevance: Defines "Groundedness" as the metric used to measure whether the generated answers are firmly based on the source materials provided to the model, rather than fabricated information.

Microsoft Learn: Azure AI Foundry Documentation - Monitor generative AI applications.

Section: Content Safety and Risk Monitoring.

Relevance: Details how "Risk and safety metrics" track the frequency and types of content policy violations (e.g., hate speech, self-harm) intercepted by content filters during runtime interactions.

To enable long-term memory that is isolated per user across separate conversations—without requiring the client application to manage user IDs manually—the scope parameter of the MemorySearchTool must be set to the built-in system variable "{{$userId}}". Microsoft Foundry automatically resolves this dynamic token at runtime based on the authenticated user's Microsoft Entra ID. Scoping by "session" or "{{$conversationId}}" would only retain short-term memory limited to a single interaction. Finally, to successfully equip the agent with this capability, the initialized memory_tool instance must be provided as a sequence/list to the tools parameter of the PromptAgentDefinition, formatted as [memory_tool].

Microsoft Learn: MemorySearchTool Class (Azure.AI.Projects / AgentServer). Section: Properties - Scope. Official documentation explicitly dictates: "The namespace used to group and isolate memories... Use special variable {{$userId}} to scope memories to the current signed-in user."

Microsoft Learn: PromptAgentDefinition Class. Section: Constructors / Parameters. Documents that the tools parameter expects an iterable list of instantiated agent tool definitions (e.g., [memory_tool]) to correctly bind functionalities to the model deployment.

Pipeline1 is designed for processing standalone PDF invoices, which strictly dictates a single-file task. The requirement for high-volume and cost-effective processing aligns with "standard mode," which is optimized for routine, high-throughput extraction tasks without the overhead of advanced reasoning models. Pipeline2 involves cross-document validation, which inherently requires a multi-file task configuration to analyze multiple documents collectively. The requirement for multi-step reasoning and integration of reference data dictates the use of "pro mode," as this tier utilizes advanced generative capabilities to execute complex logic, compare interrelated documents, and synthesize validated outputs.

Microsoft Learn: Azure AI Foundry - Content Understanding Overview. "Content Understanding schemas and modes." Standard mode is recommended for cost-effective, single-document entity extraction, while Pro mode is designed for complex reasoning, multi-document analysis, and multi-step validation. (Section: Tool configurations and pricing tiers).

Microsoft Learn: Azure AI Services - Document Intelligence / Content Understanding. "Choosing between Single-file and Multi-file processing." Multi-file configurations allow the model to retain context across several uploaded documents to perform cross-referencing and reconciliation. (Section: Supported document processing workflows).

In Microsoft Foundry Agent Service (and the underlying Azure OpenAI API), the "tool_choice" parameter controls how an agent selects and invokes available tools during an execution run. By default, this value is set to "auto", which allows the model to autonomously decide whether a tool call is necessary based on the user's prompt.

When an agent responds without calling a required tool, developers must enforce tool execution to maintain consistent application logic. Setting the "tool_choice" parameter to "required" explicitly mandates that the model must call at least one available tool before returning a final response to the user. This guarantees deterministic tool execution, effectively resolving the issue of the ticket-triage agent bypassing required tools.

Microsoft Learn: "Tool best practices for Microsoft Foundry Agent Service." * Section: Improve tool-calling reliability.

Details: The documentation specifies using the tool_choice parameter for deterministic control, explicitly stating that setting it to "required" means "The model must call one or more tools."

URL: https://learn.microsoft.com/en-us/azure/foundry/agents/concepts/tool-best-practice

Microsoft Learn: "Use tool calling with Foundry Local." * Section: Understanding tool choice settings (Table).

Details: Confirms that providing the Value "required" for the tool choice Option enforces the behavior where "The model must call at least one tool." The alternative "auto" allows the model to decide.

URL: https://learn.microsoft.com/en-us/azure/foundry-local/how-to/how-to-use-tool-calling-with-foundry-local

Microsoft Learn: "How to use Azure OpenAI Assistants function calling (classic)." * Section: Example function definition.

Details: Outlines the tool_choice parameter usage within the run payload dictionary to force the use of a specific tool or force tool execution in a particular assistant run.

URL: https://learn.microsoft.com/en-us/azure/foundry-classic/openai/how-to/assistant-functions

To meet the specific workflow optimization requirements for the Microsoft Foundry (Azure AI) agent, the built-in tools are designed to handle distinct tasks. Grounding with Bing Search connects the generative model to the live internet, enabling it to retrieve and cite up-to-date public information that is not part of its static training data. The Code interpreter provides a secure, sandboxed Python environment where the agent can write and execute code to solve complex math problems and perform accurate calculations dynamically. Lastly, the File search tool augments the agent by parsing, indexing, and querying unstructured text within custom documents directly uploaded by users during the session.

Microsoft Learn: Azure OpenAI Service - How to use tools with Assistants. Section: "Code Interpreter tool". Details how the assistant writes and runs Python code for calculations and data processing.

Microsoft Learn: Azure OpenAI Service - How to use tools with Assistants. Section: "File Search tool". Details the usage of the file search tool to augment the assistant with user-uploaded documents and proprietary data outside of its model.

Microsoft Learn: Azure AI Studio - Grounding with Bing Search. Section: "Overview of Bing grounding". Explains how to integrate web search capabilities to ground agent responses in current, public web data.