Developing AI Apps and Agents on Azure

The Foundry mental model — resource, project, tools

The hierarchy you must never invert, which of the three tools does what, when to reach for each SDK, and the six responsible-AI principles by name.

Choosing a model — the four leaderboard metrics

What each leaderboard metric actually measures and which direction is good, the token maths behind sizing, and why fluency and groundedness are not the same thing.

Deployment types — quota, cost and where inference runs

Reading a requirement and naming the deployment, why the UK is not a data zone, the difference between where data rests and where it is processed, and the lifecycle naming trap.

Auth, roles and quota — the keyless model

Identity over keys, the five built-in roles and the three wrong answers, and why the administrator who is Owner still cannot call the model.

Responsible AI — the process and the four layers

Map, measure, mitigate, manage — plus which control sits at which layer, content filters against Content Safety, and what a block actually returns on the wire.

Network isolation — private endpoints and VNet injection

Two directions, two mechanisms: inbound private endpoints and outbound VNet injection. Why DNS is where it usually breaks, and the two groundings that leave the boundary silently.

CI/CD and production monitoring

The four-step azd pipeline with an evaluation gate, the three legs of observability, and why drift needs a fixed dataset while continuous evaluation cannot detect it.

The two chat APIs — ChatCompletions vs Responses

Models are stateless, and these are the two ways to cope. Which endpoint talks to what, the one hard rule about keys, and the bridge pattern you will write constantly.

Prompt engineering and the model parameters

What each parameter actually controls, why reflection is not chain-of-thought, the order to reach for levers in, and the reasoning-model exception to temperature 0.

Prompt vs RAG vs fine-tune — the most-asked decision

Matching the symptom to the fix, what fine-tuning actually involves if the answer really is fine-tuning, and the single most reliable distractor on the paper.

Evaluating models and apps

The four evaluator families and what each catches, scoring and thresholds, and why groundedness — not relevance or fluency — is the metric that catches a confident lie.

Built-in agent tools — and the vector store numbers

Picking the tool from the phrasing, the exact lowercase type strings, the File Search setup and the vector store constants worth memorising.

Function calling — the round trip and the run states

The four-step dispatch loop, the run state machine and its edge cases, and the thing that is always wrong: the model never executes your function.

The four custom-tool options

Choosing by the constraint in the question, what Functions and Logic Apps share, and the one answer when an OpenAPI service already exists.

MCP — servers, clients and the approval round trip

Who does what, why the approval default explains most "it does nothing" reports, and the two silent failures — unreachable local servers and unhandled approval events.

Agents — what the Agent Service actually gives you

Why an agent is not a chat app, how conversation state is held, why the agent dictates the model, and the real answer to what the service buys you.

Foundry IQ — knowledge bases and agentic retrieval

Decompose, search in parallel, rerank, answer. Indexed against remote sources, permission-aware retrieval with the user’s own token, and the instruction people forget.

Workflows — executors, edges and events

The two primitives and the four edge types, plus the principle behind most workflow questions — push logic out of prompts and into control flow.

The Microsoft Agent Framework

What it inherited from Semantic Kernel and AutoGen, the creation sequence, and the one place where you do not write a dispatcher.

Multi-agent orchestration — the five patterns

Matching the scenario to the pattern by asking who decides what happens next, and how to tell group chat from Magentic when they look alike.

Publishing an agent to Microsoft 365 and Teams

What is created beneath the covers, the two publishing scopes and the governance gate between them, and the error code mapped to a missing role.

Reasoning over images with a multimodal model

Two easy marks — a text-only model cannot see, and the text and image parts must arrive in one message. Plus the coarser severity scale image-only content returns.

Generating and editing images and video

Which model and which call, why there is never a URL to read back, and the mask rule that is inverted from most people’s intuition.

Content Understanding for images and video

Picking the service from the job, building an analyzer against your own schema, and the single constraint that eliminates Pro mode from video scenarios.

Azure AI Language — match the feature to the task

Reading the verb to name the feature, extractive against abstractive summarisation, and the phrase that signals the Language service rather than a model.

The Azure Language MCP server

How a prompt reaches a language skill, why offloading narrow tasks beats reasoning your way to them, and the unhandled approval event that answers as if the tool did not exist.

Speech through the Azure OpenAI audio models

The two inferencing tasks and their exact calls, and the four requirements that mean the Speech service rather than the audio models.

The Speech SDK — config, recognizer, synthesizer, SSML

SpeechConfig is the connection, AudioConfig is where the audio lives — and the swap is the intended error. Plus SSML precedence and the MCP server’s constraints.

Voice Live, and translating text and speech

Real-time voice agents and the interruption event, translation against transliteration, and the config pair that replaces the one card 28 taught you.

Content Understanding — analyzers and field methods

The three field methods and their constraints, the value-location-confidence triple that makes automated processing trustworthy, and why verbatim from a video frame is not extract.

Azure AI Search — the four objects and the indexer pipeline

Which object is the scheduled one, the indexer stages in order, and the mapping people forget — the reason enriched fields arrive empty with no error.

Retrieval modes — keyword, vector, hybrid, semantic

Picking the mode from the requirement, why fused scores are small by design, and the distinction that decides it — vector retrieves, the semantic ranker reorders.

The decision tables — memorise these five

The five decisions that recur across every domain, gathered — plus the best single piece of technique: read the last sentence first, because the qualifier decides between two valid answers.

Every number, name and error code worth memorising

Every constant from the previous cards in one place, the six error codes and what to do about each, and why 429 and 403 are not interchangeable.

The ten traps, and how to take the exam

What to eliminate on sight, the confusable pairs, the sequences you may be asked to order, and how to sit it — one-way case studies, Learn in the exam, and finding the constraint.

Vector compression — making an index affordable

The three levers and what each saves, why compression is lossy and oversampling buys the accuracy back, and the counterintuitive case where quantization raises total storage.

Relevance tuning — when default ranking is wrong

Scoring profiles and the field types they need, what synonym maps do not apply to, and the two ways to silently kill semantic ranking.

Index operations and who is allowed to see what

Deletions are not detected automatically, four ways an indexer reports green and indexes nothing, the two-check security model — and the role answer third-party practice tests get wrong.