40 sessions · 45 minutes each · 8 weeks at your own pace · One track: your own Azure subscription
WEEK 1 OF 8 · PLAN THE SOLUTION AND WRITE THE FIRST CODE · SESSIONS 1–5
This week’s assessments: Pop Quiz 1 — Planning and First Code after Session 5
Every session: the exact names Microsoft uses · one assignment marked against a published rubric · pass mark 70 · Certificate: capstone at 70+ and the marked Final at 700+
A · Plan and manage an Azure AI solution · 25–30%SESSION 1
Choosing the model: LLMs, small language models, multimodal models, Foundry Tools
Session 1 of 40 · 45-minute session
Skills measured — Microsoft’s wording
Choose an appropriate model for each task, including large language models (LLMs), small language models, multimodal models, and Foundry Tools
Why This Matters
Every AI-103 scenario starts with a choice: which model, or which prebuilt tool, does this task actually need? Candidates who reach for the biggest model every time lose marks, and in a real job they lose money. This session teaches you to match a task to a large language model, a small language model, a multimodal model or one of the Foundry Tools, and to prove the choice with the model catalog rather than a hunch. It also sets up how the whole course works, and it puts a budget alert on your subscription before you deploy a single thing. That order is deliberate.
IN YOUR SUBSCRIPTION
Creates
One cost budget with email alerts, set at the scope of your subscription in Cost Management. No Foundry resource, project or model deployment is created today. Browsing the model catalog creates nothing.
Cost
Nothing billable is deployed in this session. Learn’s Plan and manage costs page for Foundry says that when you create a Foundry resource, you pay for the Azure services you use, and that Foundry has no pricing-calculator page of its own because it is made of several optional services. For what those services cost, use the Microsoft Foundry pricing page (azure.microsoft.com/en-us/pricing/details/ai-foundry) and the Azure pricing calculator.
Clean-up
Nothing to delete today. Keep the budget for the whole course. When you finish the course, remove it from the Azure portal: Subscriptions → your subscription → Budgets → select the budget and delete it.
The 45-Minute Session
0:00 – 8:00
How this course works
Welcome. I am R. Wingo; I wrote this course and I mark it. AI-103 is about building AI apps and agents in Python on Microsoft Foundry, so there is one track: your own Azure subscription. You pay for what you use, so every teaching session opens with a lab box: what it creates, whether it is billed, and how to delete it.
Each session runs for 45 minutes: a short why, timed steps, then The exact names box. That box lists the identifiers Microsoft prints (services, deployment types, packages, classes, methods, roles), each linked to the Learn page I checked it against. Every name also goes onto the printable AI-103 cheat sheet. Learn them letter for letter.
Every session ends with one assignment: real work in your own subscription, a short written explanation and evidence. You submit one document per session, and I mark it against the published rubric and send back a written letter. The pass mark is 70. A confident description with no evidence is capped, so show what happened.
Part of the course
What it is
What you need to pass
Session assignments
One per session, marked against its rubric
70 out of 100
Pop quizzes and practice exams
Closed-book papers marked on submission, with the reasoning returned
70, and you can resit
The marked Final
50 questions in 100 minutes, drawn in proportion to Microsoft’s domain weights
700 out of 1000
Microsoft’s AI-103 exam
Booked and sat with Microsoft in your own name
700 or greater, as the study guide states
Coach Ritchie, the AI assistant in the side panel, helps you think through an error or two look-alike services. He never marks or writes your work, and he switches off during quizzes and exams. To reach me, use the “Ask R. Wingo” tab: one question, the session number, and what you have tried.
The house rules, which I will repeat until they are habits: use the exact name; evidence beats description; delete what you create; never paste a key into a document or a screenshot; report a blocker the same day; the pass mark is 70.
I would rather read an honest “this failed, and here is the error” than a polished paragraph about something you never ran.
8:00 – 16:00
Before anything else: a budget and an alert
Think of a budget as a smoke alarm, not a sprinkler. It tells you when spending crosses a line you chose; it does not put the fire out. Learn is explicit: when a threshold is exceeded, “Resources aren’t affected, and your consumption isn’t stopped.” Deleting what you create is still your job.
Open the Azure portal, search for Subscriptions, select your subscription, then select Budgets in the menu. Select Add. In the Create budget window, check the scope is your subscription.
Give the budget a name such as ai103-course. Choose a Monthly reset period, an expiration date after the course ends, and a budget amount you are comfortable with for eight weeks of small experiments. The portal shows a graph with a suggested amount based on forecast; you can change it. Select Next.
On the alerts page, add an Actual cost alert at, say, 50% and 90% of the budget, and a Forecasted alert at 100%. Learn defines Forecasted alerts as advance notice that your spending trend is likely to exceed the budget. Enter your own email address as the recipient, then select Create.
THE EXAM LINE
Budgets notify; they never stop resources. Actual cost alerts fire on money already accrued; forecasted alerts fire on the projected trend. To stop spending, you delete or scale down what you created.
At the time of writing, Learn says cost data typically arrives within 8–24 hours, budgets are evaluated every 24 hours, and a budget holds up to five thresholds and five email addresses. An alert is a safety net, not a real-time meter.
To create a budget you need contributor-level permission on the scope. On your own subscription as Owner, you have it.
Set the alert today, while nothing is running. The day you need it is the day you forgot something.
16:00 – 26:00
Four ways to meet a task: LLM, small model, multimodal model, Foundry Tool
Picture a hospital hiring (illustrative). A senior consultant reasons through anything but costs more; a junior doctor handles routine questions quickly; a radiologist reads images; and a dedicated machine transcribes dictation. Choosing a model is the same exercise.
Learn’s model catalog describes its range this way: “foundation models, reasoning models, small language models, multimodal models, domain-specific models, and industry models.” Keep those words; the exam uses them.
Option
What it is
Choose it when
Large language model (LLM)
A general-purpose generative model with broad knowledge and strong reasoning
The task is open-ended: drafting, multi-step reasoning, agent work
Small language model
A compact generative model, such as Microsoft’s Phi family in the catalog
The task is narrow and repetitive, and cost or speed matter more than breadth
Multimodal model
A model that accepts more than text, for example text and images
The input is a photo, a scanned form, a chart or a screenshot, and the model must reason over it
Foundry Tools
Prebuilt APIs and models such as Speech, Translator, Language, Content Understanding, Document Intelligence, Vision and Content Safety
A tool already does the task: speech to text, translation, harmful-content detection
Foundry Tools is the current name. Learn’s What is Microsoft Foundry? page lists the rename: what was Azure AI Services is now Foundry Tools. Learn defines them as tools that help you build applications “with out-of-the-box and prebuilt and customizable APIs and models.” Individual tools carry the suffix, for example Azure Speech in Foundry Tools and Azure Translator in Foundry Tools.
THE EXAM LINE
When a scenario describes a well-defined capability (speech to text, translation, detecting harmful content), the expected answer is usually the matching Foundry Tool, not a general-purpose LLM.
The trap also runs the other way. “Read this complaint, decide which department owns it and draft a reply” needs judgement: that is LLM work. And if the input is an image, the model must be multimodal, or it cannot see it.
For every task ask: what is the input? How open-ended is the output? How often does it run? Does a Foundry Tool already do this?
The best answer is the smallest thing that does the job well. That is true on the exam and on the invoice.
26:00 – 36:00
Microsoft Foundry and the model catalog: compare before you choose
Microsoft Foundry, Learn says, “unifies agents, models, and tools under a single management grouping”. Its earlier names were Azure AI Studio and Azure AI Foundry, which you will still meet in older material and the Foundry (classic) portal. Use the current name.
The model catalog is “the hub for discovering and using a wide range of models”, in two categories: Foundry Models sold by Azure and Foundry Models from partners and community. Some partner models need an Azure Marketplace subscription before you deploy them.
Hands-on: go to ai.azure.com and sign in. Make sure the New Foundry toggle is on. Select Discover in the upper-right navigation, then Models. If the portal asks you to create a project before you can browse, stop there: we create the project in Session 2, and you can use the Learn model pages for today’s memo.
Open any model to see its model card. Learn lists Quick facts as one of its sections, and benchmark data sits on the card’s Benchmarks tab. Read the input types, the context window and the supported deployment options.
From Discover, select Go to leaderboard. The Model leaderboard page shows the leaders for quality, safety, throughput and estimated cost. Tick two or three models and select Compare for a side-by-side view with tabs such as Performance benchmarks, Model details, Supported endpoints and Feature support.
THE EXAM LINE
Model leaderboards compare models on quality, safety, cost and performance (latency and throughput) using public benchmarks. For your own scenario, Learn recommends evaluating on your own data as well.
One number worth recognising: the Quality index, which Learn describes as ranging from zero to one, higher being better. A leaderboard is a shortlist, not a verdict: public benchmarks do not know your data.
Screenshot the comparison you actually used. A memo that says “I compared them” with no evidence earns less than one that shows it.
36:00 – 45:00
Wrap-up: write it down, then write the memo
Write down: the four options and when each wins; the two catalog categories; what a budget does not do; the rename to Foundry Tools.
Your assignment is a model-selection memo for four tasks from your own work, each matched to an option and a specific model or tool, justified from the model card or leaderboard.
Make at least one of the four tasks a case where a Foundry Tool beats a generative model, and at least one where the input is an image or a document. That is where marks are won and lost.
Clean-up: nothing was deployed, so there is nothing to delete. Keep the budget running for the whole course.
Next session we choose the Foundry service for a solution (models, agents, search, Content Understanding) and create your Foundry project.
If the budget page refused to save, that is a blocker. Tell me today, not in Week 3.
The exact names
As Microsoft prints them — the exam and the marker both expect these, letter for letter.
Microsoft Foundry
service
Microsoft’s platform that brings agents, models and tools together under one management grouping.
A general-purpose generative model trained on a very large body of text, strong at open-ended reasoning and writing.
Small language model
A compact generative model that trades breadth for speed and lower cost on narrow, repeated tasks.
Model card
The catalog page for one model: its quick facts, inputs and outputs, benchmarks and deployment options.
Budget alert
An email sent when actual or forecasted cost crosses a percentage of a budget you set. It never stops a resource.
Self-Check — Before You Submit
1. A clinic needs doctors’ dictated notes turned into text, reliably, thousands of times a day. Which is the most appropriate choice?
A. A large reasoning model prompted to transcribe
B. Azure Speech in Foundry Tools
C. A small language model fine-tuned on medical text
D. Azure Translator in Foundry Tools
B. Azure Speech in Foundry Tools — Speech to text is a well-defined capability that Azure Speech in Foundry Tools provides directly. A text-only language model cannot take audio as input at all, and Translator translates text between languages rather than transcribing speech.
2. Your Actual cost alert fires at 90% of the monthly budget. What happens to the model deployments in your subscription?
A. They are paused until the next reset period
B. They are scaled down to the lowest capacity
C. Nothing: they keep running and you receive an email
D. They are deleted after 24 hours
C. Nothing: they keep running and you receive an email — Learn states that when budget thresholds are exceeded, resources are not affected and consumption is not stopped. The alert only notifies; stopping spend means deleting or scaling down resources yourself.
3. You want to shortlist three chat models by quality, safety, throughput and estimated cost before deploying one. Where do you go in the Foundry portal?
A. The Model leaderboard, then Compare
B. Cost analysis in Cost Management
C. The Budgets page of the subscription
D. The Foundry Tools overview page
A. The Model leaderboard, then Compare — The Model leaderboard ranks models on exactly those metrics, and Compare opens a side-by-side view. Cost analysis shows money you have already spent, not how models compare with each other.
Today’s Assignment
Write a model-selection memo that matches four tasks from your own work to the right kind of model or Foundry Tool, with evidence from the catalog and proof that your budget alert is in place.
Pick four real tasks from your job or an organisation you know. Describe each in one or two sentences: input, output, and how often it runs.
For each task, choose one option (large language model, small language model, multimodal model, or a Foundry Tool) and name the specific model or tool you would use, exactly as the catalog or Learn prints it.
Justify each choice in 60–120 words using what you read on the model card or the Model leaderboard: input types, quality, cost, throughput, or the fact that a Foundry Tool already does the job.
At least one task must be best served by a Foundry Tool, and at least one must involve an image or a document as input.
Add a paragraph on the hardest trade-off and what you would test on your own data first.
Keep the explanation between 300 and 700 words. Never include keys, secrets or credentials in the document or any screenshot.
Evidence to include
A screenshot of your budget in Cost Management showing its name, reset period and alert conditions (crop out your subscription ID and email address if you prefer).
A screenshot of the Model leaderboard or a Compare view with the models you considered.
A screenshot of at least one model card you relied on, showing its inputs or benchmarks.
Names your answer must use exactly Foundry Toolssmall language modelsmultimodal modelsmodel catalogModel leaderboardMicrosoft Foundry
Never include a key, a connection string or a token. Crop them out of every screenshot. If one is exposed, the letter will tell you to rotate it.
How this is marked — the rubric
Each of the four choices fits its task and the justification uses real catalog facts, including one Foundry Tool case and one image or document case
35
Uses the exact names from this session’s names box and the exact model or tool names as Microsoft prints them
25
Evidence: screenshots show the budget with its alert conditions and the leaderboard, Compare view or model card that was used
25
The trade-off paragraph is honest and names a concrete test on the student’s own data; no keys or secrets appear
15
Total · pass mark 70
100
Submitting session 1 Write your answer in Word or Google Docs, with your screenshots pasted in. The top of the document must carry the line Session: 1 (the template has it ready, under the Course line), or the submission is refused. Upload the Word file (.docx), or switch to the Google Doc tab and paste your document’s share link.
Marked against the rubric above and returned as a written letter by email; the mark appears on your progress page. Do the self-check above before you submit.
Skills Covered
Choosing LLMs and small modelsMultimodal modelsFoundry ToolsModel catalog and leaderboardsBudgets and cost alerts
A · Plan and manage an Azure AI solution · 25–30%SESSION 2
Choosing the Foundry service, and the retrieval and indexing method
Session 2 of 40 · 45-minute session
Skills measured — Microsoft’s wording
Choose the appropriate Foundry services for generative tasks, grounding, vector search, agent workflows, or multimodal processing
Choose an appropriate method for retrieval and indexing
Why This Matters
An AI-103 question rarely asks “what is Azure AI Search?”. It describes a solution (answer staff questions from policy PDFs, route invoices, run an agent that books repairs) and asks which Foundry service fits. The same is true at work: pick the wrong service and you spend weeks building what a managed feature already does. Today you learn to map generative tasks, grounding, vector search, agent workflows and multimodal processing to the right service, to choose between keyword, vector, hybrid and semantic retrieval, and you create the Foundry project the rest of the course runs on.
IN YOUR SUBSCRIPTION
Creates
A resource group; a Foundry resource (resource provider and type Microsoft.CognitiveServices/accounts, kind AIServices), which the portal creates for you; and a Foundry project (Microsoft.CognitiveServices/accounts/projects) as its child. No model is deployed and no search service is created.
Cost
Learn’s Plan and manage costs page says that when you create a Foundry resource, you pay for the Azure services you use, such as Azure OpenAI and the Foundry Tools. With nothing deployed, you should see no usage yet. Check the Microsoft Foundry pricing page and the Azure pricing calculator for current rates, and watch Cost analysis. Azure AI Search, discussed but not created today, has its own pricing page.
Clean-up
Keep this project: Sessions 3, 4 and 5 use it. When you are finished with it, delete the whole resource group in the Azure portal: Resource groups → your group → Delete resource group, then confirm. To delete only a project, in the Foundry portal select Manage → Project details → the trash can icon. Learn warns that a deleted project cannot be recovered.
The 45-Minute Session
0:00 – 8:00
Match the need to the Foundry service
Think of Foundry as a workshop. Models are the power tools, the agent service is the foreman choosing the next tool, search is the stores room, and Foundry Tools are specialist jigs built for one job. Real solutions use several.
Foundry Models (a model deployment called from your app)
The model catalog is where you discover, evaluate and deploy the model that does the generating
Agent workflows: a model that uses tools and keeps a conversation
Foundry Agent Service
Learn calls it a managed platform for building, deploying and scaling AI agents
Grounding an agent in enterprise content
Foundry IQ knowledge bases (built on Azure AI Search)
Permission-aware answers with citations from several knowledge sources
Vector, keyword and hybrid search over your own index
Azure AI Search
It holds the index and runs full-text, vector, hybrid and semantically ranked queries
Multimodal processing of documents, images, audio and video into structured output
Azure Content Understanding in Foundry Tools
Analyzers turn any modality into Markdown or JSON matching your schema
A well-defined prebuilt capability (speech, translation, harmful content)
The matching Foundry Tool
The capability exists already; you do not need to prompt a model for it
Within Foundry Agent Service there are two build approaches. Prompt agents are defined entirely through configuration (instructions, model, tools) and Foundry runs them. Hosted agents are code-based agents you build with a framework such as Agent Framework or LangGraph and ship as a container image or a .zip file.
THE EXAM LINE
Foundry Agent Service runs agents; Azure AI Search stores and retrieves indexed content; Foundry IQ gives agents knowledge bases built on agentic retrieval; Content Understanding turns multimodal content into structured output.
A multimodal model and Content Understanding are not the same choice. Use a multimodal model when a person or agent asks a question about one image. Use Content Understanding when you need to ingest many documents, images, audio or video files into a consistent, schema-shaped output.
Read the scenario for its verbs. “Generate” points to a model, “find” points to search, “act” points to an agent, “extract” points to Content Understanding.
8:00 – 18:00
Retrieval: keyword, vector, hybrid and semantic ranking
Learn defines retrieval-augmented generation as “a pattern that extends LLM capabilities by grounding responses in your proprietary content.” The model only answers as well as the passages you retrieve for it, so the retrieval method matters more than most people expect.
Method
How it matches
Choose it when
Full-text (keyword) search
Terms in the query against terms in an inverted index, scored with BM25
Numeric embeddings of the query against embeddings of the content; the nearest neighbours win
Meaning matters more than wording, including multilingual content and other content types
Hybrid search
Full-text and vector queries in one request, merged with Reciprocal Rank Fusion (RRF)
You want both precision and conceptual matching. This is the usual starting point for RAG
Semantic ranker
A secondary ranking pass over the BM25- or RRF-ranked results using Microsoft’s language understanding models; can return captions and answers
Relevance of the top results is what counts, on top of keyword or hybrid search
Learn’s hybrid page puts the trade-off plainly: vector search finds conceptually similar content even with no keyword match, while keyword search gives precision, and some queries (product codes, dates, names) do better with keyword search because it finds exact matches.
THE EXAM LINE
Hybrid search runs full-text and vector queries in a single request and merges the results with Reciprocal Rank Fusion (RRF). The semantic ranker re-ranks those results; it does not retrieve on its own.
Two facts that catch candidates: vector fields are not filterable, so you add a filterable text or numeric field alongside them; and the semantic ranker is a premium feature billed by usage, with a free plan subject to limits. Check the Azure AI Search pricing page for the current terms.
Illustrative: a Lagos bank’s staff ask “what is the same-day transfer limit?”. Keyword search finds the exact phrase; vector search also finds “instant payment ceiling”. Hybrid gets both; the semantic ranker puts the best first.
When a question says “best relevance for natural-language questions”, think hybrid plus semantic ranking before you think anything exotic.
18:00 – 26:00
Indexing: integrated vectorization, Content Understanding, classic RAG or agentic retrieval
Retrieval is only as good as the index behind it. In Azure AI Search, an indexer pulls raw data from a supported data source and drives the pipeline. Integrated vectorization extends that pipeline so that chunking and embedding happen during indexing, and the query is vectorised at query time.
The pieces have exact names. For chunking, Learn lists the Text Split skill and the Azure Content Understanding skill. For embeddings, the AzureOpenAIEmbedding skill, among others. At query time a vectorizer, such as the Azure OpenAI vectorizer, turns the user’s text into a vector. To try it without code, Learn points you to the Import data wizard in the Azure portal.
For mixed content (scans, photos, recordings), Azure Content Understanding in Foundry Tools uses generative AI to process documents, images, video and audio into a user-defined output. Its core component is the analyzer, which fixes the extraction settings and field schema. Output can be Markdown for search and retrieval, or structured JSON for automation.
Azure AI Search now describes two RAG approaches. Classic RAG uses hybrid search and semantic ranking, suits simpler needs, and is the choice when you need generally available features only. Agentic retrieval adds LLM-assisted query planning across several sources and returns structured responses for agents.
THE EXAM LINE
Choose agentic retrieval for agents, complex or conversational queries and new RAG builds. Choose classic RAG when you need only generally available features, simplicity, or fine-grained control of the query pipeline.
Foundry IQ sits on top of this. It lets you build a knowledge base made of knowledge sources (for example Azure Blob Storage, SharePoint, OneLake or public web data) that several agents can share, using agentic retrieval to return grounded answers with citations while enforcing user permissions.
If your answer mentions embeddings, name the skill that makes them and the vectorizer that matches them at query time. Markers notice.
26:00 – 38:00
Hands-on: create your Foundry resource and project
Check your role first. To create the project for yourself, Learn says you need a role that can create a Foundry resource, such as Foundry Account Owner or Foundry Owner, on the subscription or resource group. As Owner of your own subscription, you are covered. Learn notes these roles were recently renamed from Azure AI Account Owner and Azure AI Owner.
Sign in at ai.azure.com with the New Foundry toggle on. The current project shows in the upper-left corner. Select the project name, then Create new project. Name it, for example ai103-course.
Open the advanced options before you create. Choose a Resource group (create a new one called rg-ai103 so clean-up is one action later) and a Location. Pick a region you will keep for the whole course; Session 3 checks model availability in it. Then select Create and watch the progress.
Learn explains what just happened: you create a Foundry project on a Foundry resource, the portal creates that resource automatically, and projects are Azure child resources of it. The first project is the default project, marked with the tag “default”.
When it finishes, open the project’s Home page. You will see the project endpoint and an API key. Copy the endpoint into a private note; you need it in Session 4. Do not copy the key. We use Microsoft Entra ID authentication throughout, and Learn confirms you don’t need the API key when you do.
Finally, open the Azure portal, go to Resource groups → rg-ai103, and confirm the Foundry resource is there. Screenshot the resource list and the project Home page, cropping out the key.
One resource group per course or experiment. When you want it gone, one delete removes everything in it.
38:00 – 45:00
Wrap-up: the choices to write down, and your assignment
Write down: which service does generating, which does acting, which does finding, and which does extracting; the four retrieval methods and when each wins; what RRF merges; and the difference between classic RAG and agentic retrieval.
Your assignment is a service-selection table for a real solution you would build, with the retrieval and indexing method chosen and justified.
Clean-up: keep rg-ai103 and its project for Sessions 3 to 5. Nothing is deployed yet, so it should not be generating usage. Check Cost analysis tomorrow to see for yourself.
If project creation failed, copy the exact error text, check your role on the subscription, and send it to me through “Ask R. Wingo” the same day.
A table is only as good as its “why” column. Every row should survive the question “why not the alternative?”
The exact names
As Microsoft prints them — the exam and the marker both expect these, letter for letter.
Foundry Agent Service
service
The managed platform for building, deploying and scaling AI agents.
Giving a model relevant passages from your own content so its answer is based on them rather than on its training alone.
Embedding
A list of numbers representing the meaning of a piece of content, so similar meanings sit close together.
Indexer
The Azure AI Search component that pulls data from a source and runs it through skills into an index.
Foundry project
A development boundary inside a Foundry resource where a team builds and evaluates its use cases.
Self-Check — Before You Submit
1. A manufacturer needs to ingest thousands of scanned delivery notes, photos of damaged parts and recorded supplier calls into one consistent JSON schema. Which service fits best?
A. Foundry Agent Service with a prompt agent
B. Azure Translator in Foundry Tools
C. Azure AI Search with the semantic ranker only
D. Azure Content Understanding in Foundry Tools
D. Azure Content Understanding in Foundry Tools — Content Understanding processes documents, images, audio and video into a user-defined output using analyzers. The semantic ranker only re-orders search results; it does not extract fields from any content.
2. Users search a parts catalogue with natural questions, but also type exact part numbers. Which retrieval approach gives the best starting point?
A. Vector search only
B. Hybrid search, with the semantic ranker on top
C. Keyword search only
D. The semantic ranker on its own, without a query
B. Hybrid search, with the semantic ranker on top — Hybrid search combines keyword precision for exact part numbers with vector matching for meaning, and the semantic ranker then improves the order. The ranker cannot stand alone; it re-ranks results that a query has already retrieved.
3. Your team needs RAG for an internal tool, and the security policy allows only generally available features. Which approach does Learn point you to?
A. Classic RAG with hybrid search and semantic ranking
B. Agentic retrieval with a knowledge base
C. A hosted agent with no retrieval
D. A small language model with a longer prompt
A. Classic RAG with hybrid search and semantic ranking — Learn recommends classic RAG when you need generally available features only. Agentic retrieval is the recommendation for agents and new builds, but it is not the answer when the constraint is GA features only.
Today’s Assignment
Design the service selection for a real AI solution you would build, choose its retrieval and indexing method, and show your new Foundry project exists.
Describe the solution in 80–120 words: who uses it, what goes in (text, PDFs, images, audio) and what comes out. Use an organisation you know; label invented details as illustrative.
Build a table with one row per need (at least four: generating, grounding or search, agent workflow, multimodal or prebuilt processing). For each row give the service you choose, its exact name, and one sentence on why it beats the obvious alternative.
Choose the retrieval method (keyword, vector, hybrid, with or without the semantic ranker) and say why, using an example query from your users.
Choose the indexing approach (integrated vectorization with named skills, Content Understanding analyzers, or both) and say whether you would use classic RAG or agentic retrieval, and why.
Keep the explanation between 300 and 700 words. Crop the API key out of the project Home page; never include keys, secrets or credentials anywhere in the submission.
Evidence to include
A screenshot of the Foundry project Home page showing the project name and endpoint, with the API key cropped out.
A screenshot of the resource group in the Azure portal showing the Foundry resource.
Your service-selection table itself, complete with the “why” column.
Names your answer must use exactly Foundry Agent ServiceAzure Content Understanding in Foundry ToolsHybrid searchSemantic rankerIntegrated vectorizationAgentic retrieval
Never include a key, a connection string or a token. Crop them out of every screenshot. If one is exposed, the letter will tell you to rotate it.
How this is marked — the rubric
Each service choice fits its need and the “why” column rules out a plausible alternative
30
The retrieval and indexing choices are justified with a realistic example query and the right RAG approach
25
Uses the exact names from this session’s names box for every service, feature and skill
20
Evidence: screenshots show the project Home page (key cropped) and the Foundry resource in its resource group
25
Total · pass mark 70
100
Submitting session 2 Write your answer in Word or Google Docs, with your screenshots pasted in. The top of the document must carry the line Session: 2 (the template has it ready, under the Course line), or the submission is refused. Upload the Word file (.docx), or switch to the Google Doc tab and paste your document’s share link.
Marked against the rubric above and returned as a written letter by email; the mark appears on your progress page. Do the self-check above before you submit.
Skills Covered
Choosing Foundry servicesKeyword, vector and hybrid retrievalSemantic rankerIntegrated vectorizationCreating a Foundry project
A · Plan and manage an Azure AI solution · 25–30%SESSION 3
Designing the Azure infrastructure, and choosing deployment options
Session 3 of 40 · 45-minute session
Skills measured — Microsoft’s wording
Design Azure infrastructure for AI apps and agent-based solutions
Choose appropriate deployment options
Why This Matters
Architecture questions are where AI-103 separates people who have clicked through a demo from people who could run a production system. You will be asked where a project lives, which Azure resources an agent needs for its data, how identity and networking are decided up front, and which deployment type keeps data inside the EU or gives predictable throughput. Get these wrong at work and you rebuild, because regions, data zones and network isolation are hard to change later. Today you design the infrastructure deliberately and read your own project’s wiring to see the design in the real thing.
IN YOUR SUBSCRIPTION
Creates
Nothing new. You read the Foundry resource and project you created in Session 2: its connected resources in the Foundry portal, and the models and deployment types it can offer, with the Azure CLI.
Cost
This session creates nothing, so it adds nothing new to your bill. The Session 2 resources remain; Learn’s cost page says you pay for the Azure services you use. Check Cost analysis under Cost Management, and the Microsoft Foundry pricing page for rates.
Clean-up
Nothing to delete. Keep rg-ai103 for Sessions 4 and 5. Do not connect a new Application Insights or storage resource today; if you did by mistake, remove it from Resource groups → rg-ai103.
The 45-Minute Session
0:00 – 9:00
The shape of a Foundry solution
Picture an office building. The Foundry resource is the building: it has the address, the security desk and the utility contracts. Each Foundry project is a floor let to one team, with its own door. The connected resources (storage, Key Vault, AI Search, Application Insights) are separate buildings next door, reached by a covered walkway: joined up, but governed on their own terms.
In Azure terms, from Learn’s architecture page: the Foundry resource has resource provider and type Microsoft.CognitiveServices/accounts with kind AIServices, and supports agents, evaluations, Azure OpenAI, Speech, Vision, Language and Content Understanding. A project is Microsoft.CognitiveServices/accounts/projects, a subresource that acts as a development boundary.
Learn separates two kinds of action, and so should your role design: control plane actions, such as creating deployments and projects, are distinct from data plane actions, such as building agents, running evaluations and uploading files. You can scope role assignments at the resource or the project.
THE EXAM LINE
Foundry resource: Microsoft.CognitiveServices/accounts, kind AIServices. Foundry project: Microsoft.CognitiveServices/accounts/projects. Connected resources such as Storage, Key Vault and AI Search keep their own governance boundaries.
Agents need somewhere to keep their data. With Basic agent setup, the service stores threads, messages and files in Microsoft-managed multitenant storage with logical separation. With Standard agent setup you bring your own resources: Azure Cosmos DB for NoSQL for messages, conversation history and agent metadata; Azure Storage for uploaded files; and Azure AI Search for the vector stores the agent creates.
Choose Standard setup when the scenario says data sovereignty, enterprise security policy or project-level isolation. Choose Basic when it says quick start or prototype.
Draw the building before you draw the arrows. Most bad designs are a missing box, not a wrong arrow.
9:00 – 17:00
Region, identity and networking: decide them up front
Region. Learn’s region page gives a checklist to answer “yes” to before choosing a production region: is the model available there, is there enough quota for expected traffic, are the dependent services (Speech, Content Safety, agent tools) available, does compliance require a sovereign cloud, and have you checked both the docs and the portal for the same subscription and tenant.
Identity. Use Microsoft Entra ID, not keys. The built-in roles were recently renamed; Learn lists Foundry User (the least-privilege role for developers building and testing agents), Foundry Project Manager, Foundry Account Owner, Foundry Owner and Foundry Agent Consumer (for principals that only interact with agents). The old names began “Azure AI”; you may still see them, and Learn says the role IDs and core permissions did not change.
Workloads get a managed identity. Learn’s architecture page says you can assign managed identities at either scope, resource or project, to support secure automation and service access.
Networking. For inbound isolation you use a private endpoint. The network access options Learn describes are Disabled (a private endpoint is required) and Selected networks (specific IP addresses and virtual networks). For agent outbound isolation, Foundry injects the agent client into a subnet of your own virtual network. At the time of writing, Learn says that subnet must be delegated to Microsoft.App/environments and be /27 or larger.
THE EXAM LINE
Private endpoint for inbound isolation; virtual network injection into a delegated subnet for agent outbound isolation. Least privilege for developers is Foundry User, formerly Azure AI User.
An illustrative design: a European hospital group wants a triage assistant. Region inside the EU with the chosen model available; Standard agent setup with its own Cosmos DB, Storage and AI Search; public network access disabled with private endpoints; developers as Foundry User on the project only.
If you would not be comfortable reading the design aloud to the security team, it is not finished.
17:00 – 26:00
Deployment options: Serverless API or managed compute
Before the deployment type comes the deployment option: who runs the compute? Learn’s deployment overview compares two.
Capability
Serverless API
Managed compute (preview at the time of writing)
Which models
All Foundry Models, including Foundry Models sold by Azure and select partner and community models
Open-source and partner models from the catalog, NVIDIA NIM, and industry models
Deployment resource
Foundry resource
Foundry project
Data processing options
Regional, data zone, global
Global
Content filtering
Built-in and customizable
Not available in public preview
Billing basis
Token usage or provisioned throughput units
Hourly per accelerator SKU
Learn’s recommendation is direct: use Serverless API whenever possible; it is the preferred option and supports the widest range of capabilities and deployment types. Some Learn pages call the same thing “serverless deployment”; treat the two phrases as the same option.
Choose Managed compute when the model you need is only offered that way, typically an open-source, partner or custom model. It is billed per hour of accelerator SKU; Learn mentions auto-scale and scale-to-zero aligned to traffic, so check how your deployment is configured before you leave it running.
THE EXAM LINE
Serverless API is the preferred deployment option: billed on token usage or provisioned throughput units, with regional, data zone and global processing. Managed compute is billed hourly per accelerator SKU.
Per-token and per-hour bills behave very differently. Know which billing basis you chose before you close the laptop.
26:00 – 36:00
Deployment types: where data is processed and how you pay
Within Serverless API there are three categories: standard (pay per token), provisioned (reserved capacity) and batch (asynchronous requests). Each comes in global, data zone or regional flavours. For every type, Learn says data stored at rest remains in the designated Azure geography; what changes is where inferencing is processed.
Deployment type (SKU)
Where inferencing is processed
Choose it when
Global Standard (GlobalStandard)
Any Azure region where the model is deployed
General workloads. Learn says start here for most workloads: new models launch here first and region coverage is broadest
Data Zone Standard (DataZoneStandard)
Within the Microsoft-specified data zone: US, EU or Asia Pacific
Compliance requires processing inside the EU, US or APAC data zone, with pay-per-token billing
Standard (Standard)
Within the Azure geography of the deployment
Geography compliance at low volume
Global, Data Zone or Regional Provisioned (GlobalProvisionedManaged, DataZoneProvisionedManaged, ProvisionedManaged)
Global, data zone or regional, matching the name
Predictable high throughput on reserved provisioned throughput units (PTUs)
Global Batch or Data Zone Batch (GlobalBatch, DataZoneBatch)
Global or data zone
Large asynchronous jobs with a separate enqueued token quota and a 24-hour target turnaround, not real-time traffic
Developer (DeveloperTier)
Any Azure region
Evaluating fine-tuned models only: no SLA or data-residency guarantee, and a fixed 24-hour lifetime
THE EXAM LINE
Global Standard is the default starting point. Data Zone types keep processing inside a data zone. Provisioned types reserve throughput in PTUs. Batch types trade real-time response for cost on asynchronous jobs.
Watch the naming trap: the portal label is “Data Zone Standard”, the SKU you type in code is DataZoneStandard, and the provisioned SKUs end in Managed. Learn prints both forms; the exam can use either.
Batch is cheaper than Global Standard per Learn’s comparison. For the actual figure, read the pricing page. I will not quote it.
When a scenario mentions the EU Data Boundary, the answer almost always contains the words “Data Zone”.
36:00 – 45:00
Hands-on: read your project’s wiring, then wrap up
In the Foundry portal (New Foundry toggle on), open your project. Select Manage in the upper-right navigation, then Project details, then the Connected resources tab. Note what is connected; on a new project the list may be short, which is itself useful evidence.
Now check what your resource can deploy. Install the Azure CLI (Learn asks for version 2.60 or later for these commands) and jq, then run the command below, modelled on Learn’s Deploy models using Azure CLI and Bicep page. The sku column shows a deployment type available for each model.
bashlist-models.shtype it yourself
# Sign in and choose the subscription that holds rg-ai103
az login
az account set --subscription "<subscription-id>"
accountName="<your-foundry-resource-name>"
resourceGroupName="rg-ai103"
# Which models, versions and deployment types (SKUs) can this resource deploy?
az cognitiveservices account list-models \
-n $accountName \
-g $resourceGroupName \
| jq '.[] | { name: .name, format: .format, version: .version, sku: .skus[0].name, capacity: .skus[0].capacity.default }'
WHAT YOU SHOULD SEE
{
"name": "<a model name>",
"format": "<publisher format>",
"version": "<version>",
"sku": "<a deployment type SKU>",
"capacity": <default capacity>
}
... one object per model version (your list depends on your region)
Pick the model you would use for your Session 1 memo and confirm it appears with the deployment type your design needs. If it does not, that is a real design finding: change the region, the deployment type or the model, and say which.
Write down: the two resource types; Basic versus Standard agent setup and the three bring-your-own resources; the renamed Foundry roles; the two deployment options; and the deployment types with their SKUs.
Your assignment is an infrastructure design with a justified deployment type. Clean-up: nothing was created today, so nothing to delete.
A design that says “I checked, and the model is not offered as Data Zone Standard in my region” is worth more than one that assumes it is.
The exact names
As Microsoft prints them — the exam and the marker both expect these, letter for letter.
Microsoft.CognitiveServices/accounts
concept
The Azure resource type of a Foundry resource, with kind AIServices.
Control plane actions create and configure resources such as deployments and projects; data plane actions use them, such as building agents or uploading files.
Data zone
A Microsoft-defined boundary (US, EU or Asia Pacific) inside which Data Zone deployment types process prompts and responses.
Provisioned throughput unit (PTU)
A normalised unit of reserved model processing capacity used by provisioned deployment types.
Private endpoint
A network interface with a private IP address in your virtual network, used to reach a service without the public internet.
Self-Check — Before You Submit
1. A bank in Frankfurt must keep model inference processing inside the EU and wants to pay per token. Which deployment type should it choose?
A. Global Standard
B. Global Batch
C. Data Zone Standard
D. Developer
C. Data Zone Standard — Data Zone Standard processes prompts and responses only within the chosen data zone, such as the EU, and is billed per token. Global Standard is tempting because it is the default, but it may process data in any Azure region.
2. Your agent must keep all conversation history and files in resources your company owns and controls. What do you configure?
A. Standard agent setup with your own Cosmos DB for NoSQL, Storage and AI Search
B. Basic agent setup with a larger model
C. Managed compute for the model deployment
D. The Developer deployment type
A. Standard agent setup with your own Cosmos DB for NoSQL, Storage and AI Search — Standard agent setup brings your own Azure Cosmos DB for NoSQL, Azure Storage and Azure AI Search for agent data. Basic setup stores data in Microsoft-managed multitenant storage, which fails the ownership requirement.
3. Which statement about deployment options matches Learn’s guidance?
A. Managed compute is preferred because it supports every deployment type
B. Serverless API is preferred whenever possible, and managed compute is billed hourly per accelerator SKU
C. Serverless API is billed hourly whether or not it is used
D. Managed compute offers regional, data zone and global processing
B. Serverless API is preferred whenever possible, and managed compute is billed hourly per accelerator SKU — Learn recommends Serverless API whenever possible because it supports the widest range of capabilities and deployment types. Managed compute is billed per accelerator hour and offers global processing only.
Today’s Assignment
Produce an infrastructure design for an AI app or agent you would build, with a justified deployment option and deployment type, checked against what your own Foundry resource can actually deploy.
Describe the workload in 60–100 words: users, data sensitivity, expected traffic, and any residency rule. Use a real or clearly illustrative organisation.
Draw or tabulate the design: Foundry resource, projects, connected resources, Basic or Standard agent setup (with the bring-your-own resources named if Standard), region, identity (which roles for which people and which managed identity) and networking (public access setting, private endpoints, any virtual network injection).
Choose the deployment option (Serverless API or Managed compute) and the deployment type, and justify both against residency, throughput and cost behaviour. Name the SKU as well as the display name.
Show what you checked: the Connected resources tab of your project, and the list-models output for the model you chose, and state whether it supports your chosen deployment type in your region.
Keep the explanation between 300 and 700 words. Never include keys, secrets, credentials or connection strings in the document or screenshots.
Evidence to include
A screenshot of your project’s Connected resources tab (Manage → Project details).
The output of az cognitiveservices account list-models (pasted as text or a screenshot), with the line for your chosen model highlighted.
Your design diagram or table.
Names your answer must use exactly Global StandardData Zone StandardServerless APIstandard agent setupFoundry UserMicrosoft.CognitiveServices/accounts
Never include a key, a connection string or a token. Crop them out of every screenshot. If one is exposed, the letter will tell you to rotate it.
How this is marked — the rubric
The design is complete and coherent: resource and project structure, agent setup, region, identity and networking all fit the stated workload
30
The deployment option and type are justified against residency, throughput and cost, with the SKU named
25
Uses the exact names from this session’s names box, including role and deployment type names
20
Evidence: the Connected resources screenshot and the list-models output are included and the availability finding is stated
25
Total · pass mark 70
100
Submitting session 3 Write your answer in Word or Google Docs, with your screenshots pasted in. The top of the document must carry the line Session: 3 (the template has it ready, under the Course line), or the submission is refused. Upload the Word file (.docx), or switch to the Google Doc tab and paste your document’s share link.
Marked against the rubric above and returned as a written letter by email; the mark appears on your progress page. Do the self-check above before you submit.
Skills Covered
Foundry resource and project structureBasic and Standard agent setupIdentity and networking designServerless API and managed computeDeployment types
A · Plan and manage an Azure AI solution · 25–30%SESSION 4
Hands-on: configuring model and agent deployments
Session 4 of 40 · 45-minute session
Skills measured — Microsoft’s wording
Configure model and agent deployments
Why This Matters
This is the first session where your subscription starts doing real work, and the first where a small mistake can cost money or break an app a month later. AI-103 expects you to configure a model deployment precisely (its name, type, capacity, version policy and guardrail) and to know what an agent is in the current Foundry Agent Service: a named definition with immutable versions. At work, these settings decide whether an app survives a model upgrade or a traffic spike. Today you deploy one model in the portal or with the CLI, create one agent from Python, and record every value that matters.
IN YOUR SUBSCRIPTION
Creates
One model deployment (a child of your Foundry resource, Microsoft.CognitiveServices/accounts/deployments) and one prompt agent with one or two agent versions and a conversation, inside your Foundry project.
Cost
Billed. Use a Global Standard deployment: Learn’s deployment types page lists it as pay-per-token, so you pay for the tokens your prompts and responses use. Do not choose a provisioned type in this course; those are billed on reserved throughput. Check the Microsoft Foundry pricing page for the model you pick, and keep your prompts short. Your Session 1 budget alert is your safety net.
Clean-up
Delete the agent version once your evidence is captured, with delete_agent.py below. Keep the model deployment for Session 5, then delete it: Foundry portal → Build → Models → open the deployment → delete; or az cognitiveservices account deployment delete --deployment-name <name> -n <resource> -g rg-ai103.
The 45-Minute Session
0:00 – 7:00
What a deployment is, and the four settings that matter
A model in the catalog is like a job description; a deployment is the person you hired, with a name badge, a desk and working hours. Your code never calls the model by its catalog name. Learn says it plainly: during inference, the deployment name is used in the model parameter to route the request.
By default the portal names the deployment after the model, and you can change it. You can also deploy the same model several times under different deployment names, for example to test different content filter settings side by side.
Setting
What it controls
Values to recognise
Deployment type
Where inference is processed and how it is billed
GlobalStandard, DataZoneStandard, Standard, provisioned and batch SKUs (Session 3)
Capacity (rate limit)
The Tokens-per-Minute (TPM) assigned to this deployment, which also sets its Requests-Per-Minute (RPM)
Drawn from your quota; --sku-capacity in the CLI
Version update policy
What happens when Microsoft releases or retires a model version
The named collection of content-safety controls applied to inputs and outputs
Microsoft.DefaultV2 by default
THE EXAM LINE
Your code passes the deployment name, not the catalog model name, in the model parameter. One model can have several deployments with different names and settings.
Name deployments for their purpose, not just the model. When the model changes, the purpose usually does not.
7:00 – 17:00
Deploy a model in the Foundry portal, and read the settings
Sign in at ai.azure.com with New Foundry on, and open your project. Select Discover, then Models, and pick the model from your Session 1 memo (a general chat model sold by Azure is the easiest start). Review its model card.
Select Deploy → Custom settings (not Default settings), so you see every choice. Set the deployment name, choose Global Standard, keep the capacity low, and note the version, the version update policy and the guardrail shown. Portal labels move from time to time; match each field to the four settings in the table above. Select Deploy.
Some catalog models come from partners and community; for those the portal asks you to subscribe through Azure Marketplace and select Agree and Proceed. Models sold by Azure do not need this.
When it finishes you land in the playground. Send one short prompt, then open the Code tab to see how the deployment is called. To manage deployments later, select Build, then Models; confirm the status shows Succeeded.
Version update policy, as Learn defines it: OnceNewDefaultVersionAvailable upgrades the deployment within two weeks of a new default version; OnceCurrentVersionExpired upgrades when the retirement date is reached; NoAutoUpgrade never upgrades, and the deployment stops working at retirement.
THE EXAM LINE
NoAutoUpgrade gives stability until retirement, then the deployment stops working. OnceNewDefaultVersionAvailable follows the new default within two weeks. The REST property is versionUpgradeOption.
Quota. Learn says quota is assigned to your subscription per region, per model and per deployment type, in units of Tokens-per-Minute (TPM); a deployment’s TPM becomes its rate limit, and an RPM limit is set in proportion. To see it, select Manage → Quota and read the Token per minute tab. A 429 (Too Many Requests) response means you hit a limit: add retry logic, or request more quota.
Screenshot the deployment details before you forget. Evidence captured now saves an hour of rebuilding later.
17:00 – 24:00
The same deployment from the Azure CLI
Portals are for learning; pipelines use code. Learn documents model deployment with the Azure CLI (az cognitiveservices, part of the core CLI) and with Bicep. Learn lists the Cognitive Services Contributor role, or equivalent permissions on the Foundry resource, as the requirement for creating deployments this way.
Take the model name, version and format from the list-models output you ran in Session 3. Learn’s own example deploys Phi-4-mini-instruct with format Microsoft, version 1, capacity 1 and SKU GlobalStandard, a small language model you can use as your second model in Session 5.
bashdeploy-model.shtype it yourself
accountName="<your-foundry-resource-name>"
resourceGroupName="rg-ai103"
# Create a deployment. The deployment name is yours; the model name is the catalog's.
az cognitiveservices account deployment create \
-n $accountName \
-g $resourceGroupName \
--deployment-name "<your-deployment-name>" \
--model-name "<model-name-from-list-models>" \
--model-version "<version-from-list-models>" \
--model-format "<format-from-list-models>" \
--sku-capacity 1 \
--sku-name GlobalStandard
# Check it succeeded, then list everything deployed on the resource
az cognitiveservices account deployment show \
--deployment-name "<your-deployment-name>" \
-n $accountName \
-g $resourceGroupName \
| jq '.properties.provisioningState'
az cognitiveservices account deployment list -n $accountName -g $resourceGroupName
In Bicep, the same deployment is a Microsoft.CognitiveServices/accounts/deployments resource, and Learn’s template sets the guardrail with the raiPolicyName property, defaulting to Microsoft.DefaultV2. That is how a pipeline pins a guardrail to a deployment.
If the CLI says the SKU is not supported for this model, believe it. Go back to list-models and pick a combination that exists.
24:00 – 37:00
Configure an agent: definition, versions and endpoint
Learn defines an agent as “a persisted orchestration definition that combines AI models, instructions, code, tools, parameters, and optional safety or governance controls.” Agents are identified by agent name and agent version, and each saved version is immutable: any change, even one prompt edit, creates a new version.
Terminology is changing, so be precise. In the current agent model, Learn says every agent has a stable endpoint from the moment you create it, with no separate publish step, and its version_selector decides which version the endpoint serves: Always use latest (the default) or pinned to a specific version. Older pages describe publishing an agent as an Agent Application with its own deployment; Learn now labels that the legacy experience.
Guardrails follow the agent too. If you assign a custom guardrail to an agent, it is used; otherwise the agent inherits the guardrail of its model deployment.
Set up your machine. You need Python and the Azure CLI, and your account needs at least Foundry User on the project. The project endpoint comes from the project Home page.
bashsetup.shtype it yourself
pip install "azure-ai-projects>=2.3.0" azure-identity
az login
# From the project Home page. Never put the API key here.
export FOUNDRY_PROJECT_ENDPOINT="https://<resource-name>.services.ai.azure.com/api/projects/<project-name>"
# The DEPLOYMENT name you chose, not the catalog model name
export FOUNDRY_MODEL_NAME="<your-deployment-name>"
Now create a prompt agent in code. This follows the shape of Learn’s Create a prompt agent quickstart, with the endpoint and deployment read from environment variables.
pythoncreate_agent.pytype it yourself
import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition
project = AIProjectClient(
endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
credential=DefaultAzureCredential(),
)
# Create (or add a new version of) a prompt agent
agent = project.agents.create_version(
agent_name="helpdesk-agent",
definition=PromptAgentDefinition(
model=os.environ["FOUNDRY_MODEL_NAME"], # your deployment name
instructions="You answer IT helpdesk questions in three sentences or fewer.",
),
)
print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")
# Get an OpenAI client pre-bound to the agent, and hold a two-turn conversation
openai = project.get_openai_client(agent_name=agent.name)
conversation = openai.conversations.create()
response = openai.responses.create(
conversation=conversation.id,
input="My laptop will not join the office Wi-Fi. What should I check first?",
)
print(response.output_text)
response = openai.responses.create(
conversation=conversation.id,
input="I checked that. What next?",
)
print(response.output_text)
WHAT YOU SHOULD SEE
Agent created (id: <agent-id>, name: helpdesk-agent, version: 1)
<first answer from your model>
<follow-up answer that builds on the first>
THE EXAM LINE
A prompt agent is created with project.agents.create_version and a PromptAgentDefinition (model plus instructions). Agent versions are immutable; the conversation object keeps history across turns.
Change one word in the instructions, run the script again, and watch the version number go up. That is immutable versioning in one line of output.
37:00 – 45:00
Wrap-up: record the values, clean up the agent
Write down: deployment name versus model name; the three version update policies; what TPM and RPM are and where quota lives; the default guardrail name; and how an agent is identified.
In the portal, open your agent and check the version list and the Publish dropdown, where Learn says the version selector lives. Screenshot it.
Your assignment is evidence of one model deployment and one agent, with their exact configuration values.
Once your screenshots are saved, delete the agent version. Keep the model deployment: Session 5 calls it.
pythondelete_agent.pytype it yourself
import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
project = AIProjectClient(
endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
credential=DefaultAzureCredential(),
)
# Use the name and version printed by create_agent.py
project.agents.delete_version(agent_name="helpdesk-agent", agent_version="<version-printed-earlier>")
If DefaultAzureCredential fails to get a token, run az login again and check your role on the project in Access control (IAM). If that does not fix it, send me the exact error the same day.
Delete the agent, keep the deployment, write both down. Tidy habits now are cheap habits later.
The exact names
As Microsoft prints them — the exam and the marker both expect these, letter for letter.
Custom settings
portal
The Deploy option that shows every deployment setting instead of the defaults.
The name you give a deployed model; your code passes it in the model parameter to route requests.
Quota
The TPM allowance your subscription has per region, per model and per deployment type, shared among your deployments.
Guardrail
A named collection of controls that detects risks at chosen intervention points and decides what action to take.
Agent version
An immutable snapshot of an agent’s configuration; any change creates a new version.
Self-Check — Before You Submit
1. A logistics firm’s app must never change model behaviour without a release, but the team accepts that it must act before the version retires. Which version update policy fits?
A. OnceNewDefaultVersionAvailable
B. OnceCurrentVersionExpired
C. Always use latest
D. NoAutoUpgrade
D. NoAutoUpgrade — NoAutoUpgrade never upgrades automatically, so behaviour only changes when the team redeploys; at retirement the deployment stops working. Always use latest is an agent version selector, not a model deployment policy.
2. Your code calls a deployment named support-chat that runs a model whose catalog name is different. What goes in the model parameter?
A. The catalog model name
B. support-chat
C. The model version number
D. The Foundry resource name
B. support-chat — Learn states that the deployment name is used in the model parameter to route requests to that deployment. Passing the catalog model name is the classic mistake when the two names differ.
3. You change one sentence in a prompt agent’s instructions and save. What does Foundry Agent Service do?
A. Creates a new agent version; earlier versions stay unchanged
B. Overwrites the current version in place
C. Deletes the conversation history
D. Creates a new agent with a new name
A. Creates a new agent version; earlier versions stay unchanged — Agent versions are immutable snapshots, so any change, even a single prompt edit, creates a new version under the same agent name. Nothing is overwritten, which is what makes rollback possible.
Today’s Assignment
Deploy one model and create one prompt agent in your own project, and document their exact configuration values with evidence.
Deploy one model with Global Standard, in the portal with Custom settings or with the CLI. Record: deployment name, model name, model version, deployment type and SKU, capacity (TPM), version update policy and guardrail.
Explain in your own words why the deployment name, not the model name, goes in the model parameter, and which version update policy you would choose for a production app and why.
Create a prompt agent with create_agent.py (adapt the instructions to a task from your own work). Then change the instructions slightly and run it again so you have two versions, and record the agent name and both version numbers.
Explain which version the agent’s endpoint serves by default, how you would pin a version, and which guardrail the agent uses and why.
Delete the agent version(s) afterwards and say so. Keep the explanation between 300 and 700 words. Crop out any key, endpoint key or token; never include keys, secrets or credentials.
Evidence to include
A screenshot of the deployment details (portal) or the CLI output of deployment show or deployment list, showing the deployment name, model, SKU and state.
The terminal output of create_agent.py from both runs, showing the agent name and version numbers and the model’s answers.
A screenshot of the agent in the Foundry portal showing its versions or the Publish dropdown.
Names your answer must use exactly Custom settingsVersion update policyTokens-per-Minute (TPM)Microsoft.DefaultV2PromptAgentDefinitioncreate_versionversion_selector
Never include a key, a connection string or a token. Crop them out of every screenshot. If one is exposed, the letter will tell you to rotate it.
How this is marked — the rubric
The deployment is configured as asked and every value (name, model, version, SKU, capacity, update policy, guardrail) is recorded correctly
30
The agent works, two versions exist, and the explanation of versions, default endpoint behaviour and guardrail inheritance is correct
25
Uses the exact names from this session’s names box for settings, classes and methods
20
Evidence: screenshots and terminal output show the deployment and both agent runs, with no keys visible, and clean-up is stated
25
Total · pass mark 70
100
Submitting session 4 Write your answer in Word or Google Docs, with your screenshots pasted in. The top of the document must carry the line Session: 4 (the template has it ready, under the Course line), or the submission is refused. Upload the Word file (.docx), or switch to the Google Doc tab and paste your document’s share link.
Marked against the rubric above and returned as a written letter by email; the mark appears on your progress page. Do the self-check above before you submit.
Skills Covered
Model deployment settingsDeploying with the Azure CLIQuota and rate limitsVersion update policyCreating prompt agents
B · Implement generative AI and agentic solutions · 30–35%SESSION 5
First code: connect an app to a Foundry project and call deployed models
Session 5 of 40 · 45-minute session
Skills measured — Microsoft’s wording
Configure an application to connect to a Foundry project
Deploy and consume LLMs, small models, code models, and multimodal models
Why This Matters
Everything so far has been choosing and configuring. This is where your own code talks to your own project, and the exam checks the details: which package, which client class, which credential, which endpoint, and which API for which model. Those details are also the difference between an app that works on your laptop and one that runs safely in production without a single key in its configuration. By the end of this session you will have connected a Python app to your Foundry project with keyless authentication and called two different deployed models, one of them with an image.
IN YOUR SUBSCRIPTION
Creates
One more model deployment, a small language model, alongside the Session 4 deployment, both on your Foundry resource. A local Python virtual environment on your machine. No new Azure resource types.
Cost
Billed per token on Global Standard deployments, for every prompt and response you send, including image input. The scripts send a handful of short requests. Check the Microsoft Foundry pricing page for both models before you run anything, and keep the image small.
Clean-up
When your evidence is saved, delete both model deployments: Foundry portal → Build → Models → open each deployment → delete; or az cognitiveservices account deployment delete --deployment-name <name> -n <resource> -g rg-ai103. Keep the project and resource group for Week 2; if you are pausing the course, delete rg-ai103 from Resource groups instead.
The 45-Minute Session
0:00 – 8:00
What “connect to a Foundry project” means
The project endpoint is the address of your team’s floor; DefaultAzureCredential is your staff pass; your role decides which doors open. No key is involved.
The address has a fixed shape, shown on the project Home page: https://<resource-name>.services.ai.azure.com/api/projects/<project-name>. Learn calls the Foundry SDK a thin-client SDK that exposes all Foundry project APIs through that single project endpoint. In Python it is the azure-ai-projects package, and its client class is AIProjectClient.
The SDK gives you two clients. The project client is for Foundry-native operations such as listing connections, reading project properties and enabling tracing. The OpenAI-compatible client, from get_openai_client(), is for work built on OpenAI concepts: the Responses API, agents, evaluations and fine-tuning.
SDK
Use it when
Endpoint
Foundry SDK (azure-ai-projects)
Building apps with agents, evaluations or other Foundry-specific features
Working with a specific tool such as Vision, Speech or Language
Tool-specific endpoints
Authentication: Learn recommends Microsoft Entra ID with DefaultAzureCredential. On your laptop it uses your az login session; in production, a managed identity with the right role. Your account needs at least Foundry User on the project.
THE EXAM LINE
Connect an app with azure-ai-projects: AIProjectClient(endpoint=project endpoint, credential=DefaultAzureCredential()), then get_openai_client() for Responses calls. Keyless via Microsoft Entra ID is the recommended authentication.
If you can explain the endpoint, the credential and the role in one breath, you understand the connection. The rest is syntax.
8:00 – 17:00
Set up, then make the first call
Deploy a second, small language model now, exactly as in Session 4 (portal Custom settings or the CLI), on Global Standard. Learn’s CLI page uses Phi-4-mini-instruct as its example, and the Phi models appear on Learn’s Foundry Models from partners and community page under the Microsoft heading.
Then prepare your machine. The SDK overview asks for Python 3.10 or later. Learn’s current quickstart installs azure-ai-projects>=2.3.0 with azure-identity; we add openai for the second client. The last two variable names below are mine, so you can tell them apart from Microsoft’s.
bashsetup.shtype it yourself
# Python 3.10 or later. A virtual environment keeps course packages apart.
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install "azure-ai-projects>=2.3.0" azure-identity openai
pip show azure-ai-projects # note the version for your evidence
az login
az account show # right subscription and tenant?
export FOUNDRY_PROJECT_ENDPOINT="https://<resource-name>.services.ai.azure.com/api/projects/<project-name>"
export FOUNDRY_MODEL_NAME="<your-llm-deployment-name>"
# My own variable names for the second model (not Microsoft's):
export FOUNDRY_OPENAI_BASE_URL="https://<resource-name>.openai.azure.com/openai/v1/"
export SMALL_MODEL_DEPLOYMENT="<your-small-model-deployment-name>"
# PowerShell equivalent: $env:FOUNDRY_PROJECT_ENDPOINT = "https://..."
Now the first call, modelled on Learn’s Get started with Microsoft Foundry SDK quickstart, with the endpoint and deployment read from environment variables as the SDK reference does. The second call uses previous_response_id, which Learn’s Responses how-to uses to chain one response to the last.
pythonconnect.pytype it yourself
import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
# Format: https://<resource-name>.services.ai.azure.com/api/projects/<project-name>
project = AIProjectClient(
endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
credential=DefaultAzureCredential(),
)
# The OpenAI-compatible client for this project (Responses API, agents, evaluations)
openai = project.get_openai_client()
response = openai.responses.create(
model=os.environ["FOUNDRY_MODEL_NAME"], # deployment name, not catalog name
input="In one sentence, what does a Foundry project endpoint identify?",
)
if not response.output_text or not response.output_text.strip():
raise RuntimeError("Response output text was empty.")
print(f"Response output: {response.output_text}")
# Keep a stateless multi-turn thread going without an agent
follow_up = openai.responses.create(
model=os.environ["FOUNDRY_MODEL_NAME"],
previous_response_id=response.id,
input="Now say it for a finance manager, in plain English.",
)
print(f"Follow-up: {follow_up.output_text}")
WHAT YOU SHOULD SEE
Response output: <one sentence from your model about the project endpoint>
Follow-up: <the same idea, rewritten for a finance manager>
If it fails, read the error before you change anything. Learn’s troubleshooting list: DefaultAzureCredential failed to retrieve a token means run az login and check your role under Access control (IAM); 404 Not Found usually means the endpoint format or project name is wrong; AttributeError or ModuleNotFoundError means check the version with pip show azure-ai-projects.
Print the version of the SDK in your evidence. When Learn changes a sample, the version is what lets us both see why.
17:00 – 28:00
Two models, two APIs: Responses and Chat Completions
Here is the rule that trips people up. Learn’s endpoints page says the Responses API works with Azure OpenAI models and with Foundry Models sold by Azure that support it. If a deployment does not support it, the request returns 400 Model not supported, and you use the Chat Completions API with client.chat.completions.create instead.
Learn’s guidance on which to prefer is also clear: for new applications use the Responses API; use Chat Completions when you need its message-based interface or are maintaining an existing application. The Chat Completions shape uses a messages list with system and user roles.
For the OpenAI SDK route you build the client yourself: get_bearer_token_provider turns DefaultAzureCredential into a token provider for the scope https://ai.azure.com/.default, and the base_url is your resource’s /openai/v1/ route. Learn notes the v1 API does not need an api-version parameter.
pythontwo_models.pytype it yourself
import os
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from azure.ai.projects import AIProjectClient
from openai import OpenAI
PROMPT = "Classify this ticket as BILLING, DELIVERY or OTHER, then give one reason: " \
"'My parcel left Lagos on Monday and still has not arrived.'"
credential = DefaultAzureCredential()
# Model 1: the LLM deployment, via the project's client and the Responses API
project = AIProjectClient(
endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
credential=credential,
)
llm = project.get_openai_client()
r = llm.responses.create(model=os.environ["FOUNDRY_MODEL_NAME"], input=PROMPT)
print("LLM:", r.output_text)
# Model 2: the small-model deployment, via the OpenAI SDK on the /openai/v1/ route
token_provider = get_bearer_token_provider(credential, "https://ai.azure.com/.default")
slm = OpenAI(base_url=os.environ["FOUNDRY_OPENAI_BASE_URL"], api_key=token_provider)
completion = slm.chat.completions.create(
model=os.environ["SMALL_MODEL_DEPLOYMENT"],
messages=[
{"role": "system", "content": "You are a concise support triage assistant."},
{"role": "user", "content": PROMPT},
],
)
print("Small model:", completion.choices[0].message.content)
WHAT YOU SHOULD SEE
LLM: DELIVERY. <the model's one-line reason>
Small model: DELIVERY. <the small model's reason>
Compare the two answers. For narrow classification a small model may be good enough; for open-ended reasoning the larger one may earn its cost. Show the evidence rather than assume. If your small model supports the Responses API, you may use it; say which you used.
THE EXAM LINE
Responses API for new apps and supported models; if a deployment returns 400 Model not supported, call chat.completions.create with a messages list. Both routes accept Microsoft Entra ID tokens.
Same prompt, two models, side by side. That is the cheapest model evaluation you will ever run, and it beats an opinion.
28:00 – 37:00
Code models and multimodal models
A code model is consumed exactly like any other chat model: deploy it, then pass its deployment name. The difference is what you ask of it. Learn’s Foundry Models sold by Azure page lists codex models alongside the general models, with their input and output types; check the model card for which API it supports before you write the call.
A multimodal model accepts an image alongside text. In the Responses API the input becomes a list with one user message whose content holds an input_text part and an input_image part. The image can be a URL or, as here, a base64 data URL, following the shape in Learn’s Responses how-to.
Check the model card first: the deployment in FOUNDRY_MODEL_NAME must be a model whose inputs include images. If it is not, deploy one that is, and point the variable at it.
pythondescribe_image.pytype it yourself
import base64
import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
project = AIProjectClient(
endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()
# Any photo of your own that contains nothing private
with open("photo.jpg", "rb") as image_file:
base64_image = base64.b64encode(image_file.read()).decode("utf-8")
response = openai.responses.create(
model=os.environ["FOUNDRY_MODEL_NAME"], # a deployment whose model accepts images
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "What is in this image? Two sentences."},
{"type": "input_image", "image_url": f"data:image/jpeg;base64,{base64_image}"},
],
}
],
)
print(response.output_text)
WHAT YOU SHOULD SEE
<two sentences describing your photo>
THE EXAM LINE
For image understanding, send a user message whose content combines an input_text part and an input_image part (URL or base64 data URL) to a multimodal model deployment.
The images you send are data. Use a photo with no faces, documents or anything private, and never an image that contains a key or password on screen. Later in the course we deal with text hidden inside images that tries to instruct the model.
If the answer describes a picture you did not send, check which deployment name the variable holds. It is nearly always that.
37:00 – 45:00
Wrap-up: Pop Quiz 1, the assignment and clean-up
Write down: the project endpoint format; azure-ai-projects, AIProjectClient, DefaultAzureCredential, get_openai_client; when to use the OpenAI SDK route; the Responses versus Chat Completions rule; and the input_image shape.
This session closes Week 1 and opens Pop Quiz 1: Planning and First Code. It covers Sessions 1 to 5. Sit it before Session 6, closed book, with Coach Ritchie switched off. It is how you find out what has stuck.
Your assignment is a working script that calls two different deployed models, with output and an explanation.
Clean-up, once your evidence is saved: delete both model deployments (Build → Models, or the CLI). Keep rg-ai103 and the project for Week 2. Deactivate the virtual environment with deactivate.
If a call failed and the troubleshooting list did not fix it, send me the exact error and SDK version through “Ask R. Wingo” today.
Week 1 done: you chose, designed, deployed and called. Everything from here builds on these four verbs.
The exact names
As Microsoft prints them — the exam and the marker both expect these, letter for letter.
azure-ai-projects
package
The Python package for the Foundry SDK, which works through the project endpoint.
The URL of one Foundry project, in the form https://<resource-name>.services.ai.azure.com/api/projects/<project-name>.
Keyless authentication
Signing requests with a Microsoft Entra ID token from your identity or a managed identity, so no API key is stored anywhere.
Responses API
The OpenAI-style API Learn recommends for new applications, used by Foundry for model calls and agents.
Base64 data URL
An image encoded as text inside a URL (data:image/jpeg;base64,...), so it can travel inside a JSON request.
Self-Check — Before You Submit
1. A developer’s Python app must connect to a Foundry project without storing any key. Which combination is right?
A. The openai package with the API key from the project Home page
B. azure-ai-projects with AIProjectClient and an API key string
C. azure-ai-projects with AIProjectClient, the project endpoint and DefaultAzureCredential
D. azure-identity alone, calling the model by its catalog name
C. azure-ai-projects with AIProjectClient, the project endpoint and DefaultAzureCredential — AIProjectClient takes the project endpoint and a credential, and DefaultAzureCredential signs requests with Microsoft Entra ID, so no key is stored. The first option works technically but stores a key, which the scenario rules out.
2. A call to responses.create on one of your deployments returns 400 Model not supported. What does Learn tell you to do?
A. Add an api-version parameter to the request
B. Use the Chat Completions API with chat.completions.create
C. Switch the deployment type to Global Batch
D. Replace DefaultAzureCredential with an API key
B. Use the Chat Completions API with chat.completions.create — Learn says that when a deployment does not support the Responses API, you call client.chat.completions.create instead. The error concerns the model’s API support, not authentication or the deployment type.
3. An insurer wants an app that looks at a photo of a damaged car and answers a question about it. What must the request contain?
A. A single string input naming the image file
B. A system message telling the model to open the file
C. An embedding of the image passed in the model parameter
D. A user message whose content has an input_text part and an input_image part, sent to a multimodal model deployment
D. A user message whose content has an input_text part and an input_image part, sent to a multimodal model deployment — The Responses API takes images as input_image content parts, by URL or base64 data URL, alongside input_text, and the deployment must be a model that accepts images. A file name in text gives the model nothing to see.
Today’s Assignment
Build and run a Python script that connects to your Foundry project with keyless authentication and calls two different deployed models, and explain what you built.
Deploy two different models on Global Standard: one large language model and one small language model (or a code model, if your work needs one). Record both deployment names and their catalog model names.
Write a script, starting from connect.py and two_models.py, that sends the same prompt from your own work to both deployments. Use AIProjectClient and DefaultAzureCredential; read every endpoint and deployment name from environment variables.
Add one multimodal call: send a harmless photo of your own with input_image to a deployment whose model accepts images, and print the answer.
Explain (300–700 words): how the app connects to the project, why no key is needed, which API you used for each model and why, how the two answers differed, and which model you would put into production for this task.
Include your full code, with no endpoint values, keys, secrets or credentials in it; they belong in environment variables only. Crop any of them out of screenshots.
Delete both deployments after capturing your evidence, and say that you did.
Evidence to include
Terminal output showing both models’ answers to the same prompt, and the multimodal answer.
The output of pip show azure-ai-projects showing the installed version.
A screenshot of your deployments list (Build → Models) showing both deployments before you deleted them.
Names your answer must use exactly azure-ai-projectsAIProjectClientDefaultAzureCredentialget_openai_clientchat.completions.createinput_image
Never include a key, a connection string or a token. Crop them out of every screenshot. If one is exposed, the letter will tell you to rotate it.
How this is marked — the rubric
The code runs and calls two different deployed models plus one image request, using keyless authentication and environment variables only
35
The explanation is correct about the connection, the credential, the choice of Responses or Chat Completions, and the production model choice
25
Uses the exact package, class, method and parameter names from this session’s names box
15
Evidence: terminal output for all calls, the SDK version, and the deployments screenshot, with no keys or endpoint values visible; clean-up stated
25
Total · pass mark 70
100
Submitting session 5 Write your answer in Word or Google Docs, with your screenshots pasted in. The top of the document must carry the line Session: 5 (the template has it ready, under the Course line), or the submission is refused. Upload the Word file (.docx), or switch to the Google Doc tab and paste your document’s share link.
Marked against the rubric above and returned as a written letter by email; the mark appears on your progress page. Do the self-check above before you submit.
ASSESSMENT NOW OPEN
Pop Quiz 1 — Planning and First Code opens now. Sit it before the next session. It is how you find out what has stuck, and practice papers may be resat as often as you like.