AI-901: Microsoft Azure AI Fundamentals

What you will learn

AI-901: Microsoft Azure AI Fundamentals is the entry point for understanding and beginning to develop artificial intelligence solutions in Azure. It combines capability selection with technical fundamentals for Microsoft Foundry.

This guide was reviewed on October 18, 2026. It organizes learning into seven sections, uses store and warehouse scenarios and includes Python snippets to connect concepts with an application. By the end, you should be able to justify the capability you need, interpret a simple client and distinguish a generated answer from an executed action.

For revision practice, you have the LarrúaTech AI-901 practice test, with 200 original questions, explanations and official references.

Before you start

You need basic Python: variables, strings, lists, dictionaries, functions, imports, property access and error handling. For asynchronous examples, you should also recognize async and await. It helps to know what an Azure subscription, resource, endpoint, credential and HTTP request are.

You do not need to master model training to start this path. You should understand what data you send, which service you call and what result it returns. If Python is new to you, first learn to read a dictionary and iterate over a list: those structures appear continually in requests and results.

Running service exercises requires a subscription, suitable permissions and available resources. Check quotas and costs before deploying; free access to lab instructions does not make all Azure consumption free.

Current syllabus and exam format

The official AI-901 guide publishes objectives effective from April 15, 2026 and two domains:

The seven sections organize study: Microsoft does not assign a separate percentage to each. The profile includes Python and familiarity with REST APIs, SDKs and CLI. AI-900 is the retired previous exam; do not prepare for AI-901 using only its historical structure. Review the official announcement of the certification’s evolution.

Microsoft describes 45 minutes of exam time and a 65-minute appointment for Fundamentals; specific conditions are confirmed when booking. The number of questions can vary. Passing requires 700 points on the official scale, which does not necessarily mean 70% correct. Sources: duration and exam experience and exam scoring.

Header prices are regional exam fees, not course prices. Confirm currency, taxes and discounts when booking. This guide and the LarrúaTech practice test are free.

1. Responsible AI principles

An application must be evaluated by its results and effects on people. Fast, well-written answers do not prove it is safe, fair or reliable.

The fairness is not demonstrated by high average accuracy alone: one group may account for many errors. The transparency principle means enabling appropriate interpretation of the system, rather than revealing technical secrets. The accountability remains with people and organizations even when an external model is used.

Apply controls at multiple layers: evaluation, data access, action validation and incident management. A prompt guides behavior but does not alone guarantee there will never be errors or harmful answers. References: responsible AI principles and system messages and safety.

Check your understanding: if an assistant fails more often with certain accents, first identify the fairness issue. If it provides no alternative to voice, there is also an inclusion barrier. One case can affect multiple principles.

2. Models, capabilities and configuration

A language model generates content from context and relationships learned during training. Inference means using the model to obtain output; including data in a prompt does not by itself constitute a new training operation.

The tokens are units of content: they can represent words or parts of words. The context window limits how much a model can handle in one request, with specific input and output conditions. The embeddings represent content as vectors and enable meaning comparisons; do not confuse them with a written answer or generated image. See language models and representations.

How to choose a model

Start with the task and modalities. A model accepting text does not necessarily interpret images; another interpreting photographs may not generate new images. Check capabilities, region, operation, terms of use, latency and cost with representative inputs. The largest model is not automatically the best fit. Reference: Microsoft Foundry models.

Available parameters depend on the model and API. Do not copy settings from an example without checking compatibility. References: Chat Completions and Responses.

Deployment and access

Foundry offers different deployment options. Batch jobs suit deferred workloads, such as processing many descriptions overnight; they should not be treated as immediate interactive service. Geographic processing differences also require review. Reference: deployment types.

In Azure OpenAI v1 with your own deployment, model identifies your deployment name. There is a contextual exception to recognize: instant access in new Foundry, in preview, enables supported models without your own deployment under its conditions, currently for projects in West US 3. Do not generalize this option to every model or region.

3. Choose the right workload

Start by identifying input, transformation and output. One application can chain multiple capabilities.

These techniques are described in Azure Language, Speech, vision technologies and Content Understanding.

Example: turning a carrier’s voice message into an incident may require recognition, product and reason extraction, and summarization. Obtaining a transcript does not mean the other tasks are complete.

4. Generative applications and agents in Foundry

Understand the connection

Knowing a URL does not grant access. Authenticating does not guarantee permission for every operation either. DefaultAzureCredential uses identity mechanisms supported by the environment; it does not create every missing role. The SDK and endpoints guide explains which client fits each scenario.

Read a Python client

The following example uses Azure AI Projects 2.x and new Foundry, with a deployment accessible from the project. It requires compatible packages, configured identity and permissions. The example’s environment variables must contain your project endpoint and deployment name.

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

with DefaultAzureCredential() as credential:
    with AIProjectClient(
        endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        credential=credential,
    ) as project:
        with project.get_openai_client() as client:
            response = client.responses.create(
                model=os.environ["FOUNDRY_MODEL_DEPLOYMENT"],
                instructions="Explica procesos de almacén de forma breve.",
                input="¿Cómo puedo revisar una recepción de mercancía?",
            )
            print(response.output_text)

AIProjectClient configures project access; get_openai_client() obtains the compatible client; responses.create() sends the task and output_text makes the text output easy to read. This snippet does not query an ERP or confirm stock: it only generates an answer. It is based on the official Foundry quickstart. This guide’s examples were checked against documentation; they have not been executed against Azure.

Design instructions and context

General instructions define role, tone and boundaries. User input specifies the task. Provide relevant context, request an evaluable format and define what to do when data is missing.

Eres un asistente de incidencias de un almacén.
Usa la información de la incidencia proporcionada.
No inventes cantidades, ubicaciones ni acciones realizadas.
Si falta un dato necesario, pide una aclaración.
Responde con: problema entendido, siguiente comprobación y motivo.

To answer about a current policy, the application can retrieve relevant passages and supply them to the model. This grounding does not replace evaluation: an old document or irrelevant retrieval can still produce an incorrect answer. References: prompts and retrieval and grounding.

From answering to acting

An agent combines model, instructions and tools. One tool can query stock; another can request a reservation. Its configuration should describe purpose, arguments and usage conditions. Before executing a modification, the application validates arguments, identity and business rules.

In compatible APIs, tool_choice="none" prevents tool calls, auto allows the model to decide and required requires one or more. required does not by itself select a particular function or demonstrate that a transaction completed. Forcing a specific tool requires the API’s supported format. See tool best practices.

Keep history associated with the authorized user. Treat external documents as reference data even if they contain phrases trying to change instructions. Evaluate answers, errors and actions with representative tests, in addition to checking connectivity. Reference: evaluation in Foundry.

5. Text and speech solutions

Text: results and errors

A text-analysis client sends documents and processes each task’s specific result. A batch may contain successful documents and others with errors. Do not access their properties as if every item were a valid result.

The documentation for Text Analytics for Python 5.4.0 helps interpret methods such as recognize_entities, detect_language, recognize_pii_entities and analyze_sentiment. When studying code, connect the method, input and output structure.

Current Language documentation distinguishes core capabilities recommended for new development from legacy features maintained for existing implementations. Learning sentiment, key phrases or summarization as syllabus techniques does not mean every older integration is recommended for a new architecture. Check the status of each capability.

Classification confidence is not a percentage of actual satisfaction across the company. Detecting personal information does not guarantee universal anonymization either: evaluate categories, languages and coverage before sharing messages.

Speech: recognition and synthesis

In Python, recognizer.recognize_once_async().get() recognizes one utterance and waits for the result. For multiple extended utterances, review the continuous-recognition pattern. Check the status, such as recognized speech, no match or cancellation, before assuming result.text contains a valid transcript.

Producing a spoken notice uses synthesis, for example synthesizer.speak_text_async(texto).get(), with the appropriate destination and voice. Voice, language, region and format must be compatible. Sources: recognition and synthesis.

A voice assistant can chain recognition, generation and synthesis, or use a compatible multimodal model. Supporting audio input does not imply producing audio output. Translation adds a language change not included merely by transcribing.

6. Vision and image generation

Interpret an image

Choose a vision model and supply the image through a supported mechanism. Writing C:/fotos/caja.jpg in a message does not transmit bytes from a computer to the remote service. Depending on support, you can use an accessible URL, a Base64 data URI or a supported file identifier.

This snippet illustrates input content for Responses:

content = [
    {"type": "input_text", "text": "Describe los daños visibles de la caja."},
    {"type": "input_image", "image_url": IMAGE_URL},
]

In the corresponding example for Chat Completions, the vision structure is different:

content = [
    {"type": "text", "text": "Describe los daños visibles de la caja."},
    {"type": "image_url", "image_url": {"url": IMAGE_URL}},
]

These are snippets for compatible clients and requests, not interchangeable structures. See Responses and the Chat Completions reference.

Visual detail can affect processed information, consumption and latency. Evaluate with real photographs: a low level may miss small letters, while a high level does not automatically reconstruct a blurry label. The assistant should express uncertainty and request another photo when evidence is insufficient.

Create a new image

Generating illustrations or editing a background requires a model and operation supporting those capabilities. Define subject, composition, style and constraints; then review the result against the business purpose.

The reviewed documentation states that DALL-E 3 is retired and points toward compatible GPT Image models. Verify the available alternative and its options rather than assuming every historical tutorial still works. Reference: image generation in Azure OpenAI.

7. Information extraction with Content Understanding

Azure Content Understanding transforms documents, images, audio and video into information applications can use. An analyzer defines which content it processes, what it extracts and how the output is structured.

For a supplier invoice, separate supplier, number, date, amounts and lines. Lines may need a collection of objects with description, quantity and price. OCR provides characters; assigning the correct meaning to each amount requires interpretation and structure.

The following snippet illustrates the pattern for the Content Understanding 1.1.0 aio client, inside an asynchronous function. It assumes a configured client and an invoice URL accessible through the supported mechanism:

from azure.ai.contentunderstanding.models import AnalysisInput

async def analizar_factura(client, invoice_url):
    poller = await client.begin_analyze(
        analyzer_id="prebuilt-invoice",
        inputs=[AnalysisInput(url=invoice_url)],
    )
    result = await poller.result()
    return result

The synchronous client uses its corresponding pattern without await, for example poller.result(). Do not turn an aio client into a synchronous one by removing words from the example: use the correct class and version. Reference: Content Understanding Python SDK.

Validate before automating

A correct schema does not guarantee correct values. Check missing fields, inconsistent amounts and repeated items. Confidence and provenance can help decide which results need review and where to find document evidence.

In supported document analyzers, estimateFieldSourceAndConfidence provides source and confidence information according to configuration. Thresholds should be evaluated with representative documents. High confidence does not authorize payments or prove authenticity.

If an invoice has no due date, do not invent one to fill every field. Represent absence or uncertainty according to the schema and escalate when needed. References: analyzers and fields and evaluation using confidence and provenance.

Practice path with business scenarios

The following scenarios are LarrúaTech suggestions for applying what you studied. Start with the official AI Fundamentals labs and adapt their data to these situations. Before running them, review each exercise’s requirements; afterward, check which resources and deployments you can delete to avoid unnecessary consumption.

Case 1. Warehouse incident assistant

Prepare a fictional document with three incidents: incomplete receipt, damaged product and unknown location. Define instructions to answer only from that information and test when to ask for clarification. Use the portal first, then a short client.

Deliverable: instructions, three resolved queries, one ambiguous query and one out-of-scope query. Explain the source of each answer and missing data. Do not attribute real-stock queries to an application with only a sample document.

Case 2. Voice-based customer service

Record a fictional customer message asking about a delivery. Obtain a transcript, review errors and prepare a written answer. Then synthesize the notice with a configured audio destination.

Deliverable: recording, transcript, corrections and spoken notice. Explain which part performs recognition, which generates content and which synthesizes speech. A poor transcript can propagate an error into later stages.

Case 3. Package photographs and visual material

Use your own photograph of a box with no visible personal data. Ask for a description of apparent damage, then repeat with a less readable image. As a separate task, generate a packaging illustration for an internal procedure using a compatible model.

Deliverable: two interpretations and a reviewed new image. Clearly identify which result analyzes a photo and which is generated. Record cases where visual evidence does not support a reliable conclusion.

Case 4. Invoices for purchasing and warehouse operations

Prepare fictional invoices: one complete, one without a due date and one with multiple lines. Use an appropriate analyzer, review the schema and compare results with reference values recorded beforehand.

Deliverable: extracted fields, a discrepancy list and a human-review rule. Explain how to distinguish completed extraction from an invoice valid for accounting or payment. If practicing with audio or video, define a schema for those modalities.

Study and revision plan

This schedule is indicative: adjust its duration to your experience and availability. Progress when you can explain and verify each result.

Start with sessions of 10 or 20 questions in practice mode. Read the explanation and open the source when an answer does not fit your understanding. Then use exam mode and review performance by domain.

The bank contains 84 conceptual questions and 116 implementation questions. Exam selection maintains approximately that distribution, with necessary rounding. The 70% target is local practice guidance: it is neither Microsoft’s scoring formula nor a prediction of passing.

Mistakes to avoid

• Memorizing names without input and output. Check what each capability receives and returns.
• Confusing generation with evidence. A convincing answer may contain unconfirmed data.
• Confusing authentication and authorization. A valid token does not guarantee permission for an operation.
• Mixing versions or APIs. New and classic Foundry, Projects 2.x and earlier examples, or Responses and Chat Completions require explicit context.
• Treating required as confirmation of a transaction. Tool selection does not prove successful execution.
• Reading a poller as if it were already the result. First retrieve the output using the correct synchronous or asynchronous pattern.
• Approving data based on its format. Valid JSON and high confidence do not replace business validation.
• Assuming practice is always free. Instructions, portal access and resource consumption are different things.

Official resources to continue

Before booking, check that you can connect each section with a scenario, interpret client snippets and explain their results’ limitations. Keep a short list of remaining errors and check them against official references.