AI-103 — Microsoft Azure AI Apps and Agents Developer Associate Quick Review

Quick Review purpose

This Quick Review is for candidates preparing for Microsoft Azure AI Apps and Agents Developer Associate (AI-103), exam code AI-103. It is an independent review aid, not a Microsoft document, and is designed to help you refresh the highest-yield concepts before using topic drills, mock exams, original practice questions, and detailed explanations.

Use it to check whether you can make the right design choice under exam-style wording: which Azure AI capability to use, how to ground a generative AI app, how to secure an agent, how to troubleshoot retrieval quality, and how to evaluate and monitor an AI solution.

Fast exam orientation

For AI-103, expect practical developer scenarios rather than isolated definitions. A strong candidate can connect Azure AI services, model deployments, search, agents, security, safety, and operations into working application patterns.

Core architecture pattern for Azure AI apps

Most Azure AI apps and agents can be reviewed as a layered system.

    flowchart LR
	    A[User request] --> B[Authenticate and authorize]
	    B --> C[Classify intent and risk]
	    C --> D{Need enterprise context?}
	    D -- Yes --> E[Retrieve from Azure AI Search or data source]
	    D -- No --> F[Build prompt or agent state]
	    E --> F
	    F --> G{Need action/tool?}
	    G -- Yes --> H[Validate tool call and permissions]
	    H --> I[Execute tool]
	    I --> J[Return tool result to model]
	    G -- No --> K[Generate response]
	    J --> K
	    K --> L[Validate safety, schema, citations]
	    L --> M[Respond and log telemetry]

High-yield decision rules

Azure AI Foundry and model deployment review

Azure AI Foundry is central to building and managing modern Azure AI apps. For exam prep, focus on the development lifecycle rather than memorizing screen names.

Model lifecycle checklist

1. Define task: chat, summarization, classification, extraction, embedding, image/audio processing, agentic action, or multimodal reasoning.
2. Select model: balance capability, context length, modality, latency, throughput, region availability, and cost.
3. Deploy or connect: configure endpoint, deployment name, model version, and access controls.
4. Build prompt/app flow: instructions, context, tools, retrieval, output schema, and error handling.
5. Evaluate: quality, safety, groundedness, relevance, task success, latency, and token usage.
6. Deploy application: use environment configuration, secrets management, CI/CD, and least privilege.
7. Monitor and improve: collect telemetry, compare prompt/model versions, and run regression evaluations.

Common configuration settings

Prompting and structured generation

Prompting is not just wording. In production-style exam scenarios, it is part of a controlled application contract.

Strong prompt pattern

A strong prompt usually includes:

• Role or task: what the model should do.
• Authoritative context: retrieved content, user data, or tool results.
• Boundaries: what to ignore, when to refuse, and what not to infer.
• Output format: JSON schema, bullet list, table, or concise answer.
• Examples: when useful for style or edge cases.
• Citation rules: if answers must be grounded in retrieved sources.
• Safety rules: do not expose secrets, hidden instructions, or unauthorized data.

Prompting traps

Agents and tool use

An AI agent is more than a chat completion. It combines a model with instructions, tools, state, knowledge, and guardrails so it can pursue a goal over one or more steps.

Agent components

Agent versus workflow versus RAG

Tool/function calling flow

1. User asks for an outcome.
2. Application sends instructions, available tool schemas, and context to the model.
3. Model proposes a tool call and arguments.
4. Application validates:
   • Is the user authorized?
   • Is this tool allowed for this user and context?
   • Are arguments complete, typed, and within safe limits?
   • Could the call cause a high-impact side effect?
5. Application executes the tool if allowed.
6. Tool result is returned to the model.
7. Model produces a final response.
8. Application validates output and logs the interaction.

Exam shortcut: the model may select or propose a tool, but your application is responsible for enforcement, execution, retries, auditing, and side-effect control.

Retrieval-augmented generation and Azure AI Search

RAG is one of the highest-yield AI-103 patterns. It lets a generative model answer using data that was not part of its training data.

RAG pipeline

Azure AI Search review

RAG troubleshooting table

Azure AI services integration review

Not every task needs a general-purpose generative model. AI-103 scenarios may reward choosing a purpose-built Azure AI service.

Security, identity, and data protection

Security questions often test whether you know where enforcement belongs. A prompt can guide a model, but it cannot replace identity, authorization, networking, or validation.

Authorization rule to remember

If a user is not allowed to read or perform something outside the AI app, the AI app must not allow the model or agent to expose or perform it either. Enforce that before retrieval and before tool execution.

Responsible AI and safety controls

Responsible AI is practical in developer scenarios: detect risk, reduce harm, validate outputs, log decisions, and provide human oversight where needed.

Evaluation and monitoring

Quality evaluation is not optional for AI apps and agents. Traditional tests confirm that code runs; AI evaluations check whether outputs are useful, safe, grounded, and consistent.

What to evaluate before release

Runtime telemetry to monitor

Track more than HTTP success.

• Request volume and rate limits
• Latency by model, retrieval, and tool step
• Input/output token usage
• Retrieval hit rate and top document scores
• No-answer or fallback frequency
• Tool call success/failure rates
• Content safety flags
• User feedback and corrections
• Prompt version, model version, and deployment version
• Exceptions, retries, and throttling
• Cost trends by tenant, user group, or feature

Performance and cost review

Token usage matters because retrieved context, chat history, tool results, and generated output all increase latency and cost.

\[ \text{Approximate token cost} = \left(\frac{T_{in}}{1000}\times P_{in}\right) + \left(\frac{T_{out}}{1000}\times P_{out}\right) \]

Where \(T_{in}\) includes user input, system/developer instructions, retrieved context, conversation history, and tool results; \(T_{out}\) includes generated response tokens.

Troubleshooting patterns

Common AI-103 candidate mistakes

• Choosing fine-tuning when the scenario needs access to current private documents.
• Choosing RAG when the task is a simple fixed classification supported by Azure AI Language.
• Assuming vector search automatically enforces user permissions.
• Forgetting to mark metadata fields as filterable when filters are required.
• Treating content safety as the same thing as authentication or authorization.
• Passing full documents to the model instead of retrieving focused chunks.
• Ignoring citation requirements in grounded answers.
• Letting model-generated tool arguments execute without validation.
• Storing API keys in application code or exposing them to browser clients.
• Monitoring only service uptime and not groundedness, safety, retrieval quality, or cost.
• Using an agent for a fixed workflow that should be deterministic.
• Using a general chat model for document extraction without confidence handling or validation.
• Assuming lower temperature fixes wrong answers caused by bad retrieval.
• Forgetting that Azure-hosted model calls may use deployment names configured in Azure.
• Failing to handle throttling, transient failures, and timeout behavior.
• Overloading prompts with irrelevant history and context.
• Ignoring prompt injection in retrieved documents or tool outputs.
• Forgetting that a search index must be refreshed as source content changes.
• Allowing the model to infer missing facts instead of refusing or asking for clarification.
• Not testing edge cases with original practice questions and detailed explanations.

Rapid self-check before practice

You are ready for AI-103 question-bank practice if you can answer these without looking them up:

1. When would you choose RAG instead of fine-tuning?
2. What fields should a search index include for secure, citation-based RAG?
3. How does hybrid search differ from pure vector search?
4. What does semantic ranking improve, and what does it not do?
5. What happens between a model proposing a tool call and the tool actually running?
6. Which controls belong in code instead of prompts?
7. How would you reduce hallucinations in an enterprise document assistant?
8. What telemetry proves an AI app is working well, not merely online?
9. How would you handle a user request that requires a high-impact action?
10. Which Azure AI service fits speech, document extraction, translation, moderation, or entity detection scenarios?
11. How do managed identities and RBAC improve security compared with embedded keys?
12. What should you check first when an app returns 403, 404, 429, or context-length errors?

How to use this with topic drills and mock exams

Use this Quick Review as a map, then practice by topic:

For the best review sequence, do short topic drills first, read the detailed explanations carefully, then move to mixed mock exams. Your next step is to practice original AI-103 questions by weak area—especially agents, RAG with Azure AI Search, security, and responsible AI—until you can explain why each wrong answer is wrong.

Continue in IT Mastery

Use this Quick Review as a final concept map, then move into IT Mastery for focused topic drills, mixed practice sets, timed mock exams, and detailed explanations. The practice questions are original IT Mastery practice items; they are not official Microsoft questions, copied live-exam content, or exam dumps.