AI-103 — Microsoft Azure AI Apps and Agents Developer Associate Cheat Sheet

Use the tables for a quick pre-exam check. Expand a topic’s notes for explanations, examples, and additional distinctions.

High-yield architecture map

    flowchart LR
	    U[User or app client] --> A[AI app API / orchestration layer]
	    A --> ID[Microsoft Entra ID / managed identity]
	    A --> LLM[Azure OpenAI / model deployment]
	    A --> AG[Agent service or agent runtime]
	    AG --> T[Tools: functions, APIs, code, search, workflows]
	    A --> R[Retriever]
	    R --> S[Azure AI Search index]
	    S --> D[Blob, files, DBs, documents]
	    A --> CS[Content safety and policy checks]
	    A --> MON[Tracing, logs, evaluations, metrics]
	    LLM --> A
	    T --> AG
	    CS --> A

High-yield mental model:

1. Model generates or reasons.
2. Retrieval grounds answers in enterprise data.
3. Tools let the model or agent take actions.
4. Security controls identity, data access, networking, and secrets.
5. Evaluation proves quality, safety, and groundedness before and after release.
6. Observability helps troubleshoot latency, token use, model errors, unsafe outputs, and poor retrieval.

Service-selection matrix

Core app patterns

    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]

Microsoft Foundry concepts

Current Foundry runtime documentation distinguishes reusable agents, persistent conversations, and execution/output responses. Classic threads/runs examples belong to their matching API surface. Match the SDK and runtime before combining examples.

Azure OpenAI and model interaction reference

Building blocks

import os
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default"
)

client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    azure_ad_token_provider=token_provider,
    api_version=os.environ["AZURE_OPENAI_API_VERSION"]
)

response = client.chat.completions.create(
    model=os.environ["AZURE_OPENAI_CHAT_DEPLOYMENT"],  # Azure deployment name
    messages=[
        {"role": "system", "content": "Answer using concise technical language."},
        {"role": "user", "content": "Explain hybrid search in RAG."}
    ],
    temperature=0.2
)

print(response.choices[0].message.content)

RAG and Azure AI Search

RAG pipeline

    flowchart LR
	    A[Source documents] --> B[Load and crack documents]
	    B --> C[Clean, split, chunk]
	    C --> D[Enrich: OCR, metadata, extraction]
	    D --> E[Create embeddings]
	    E --> F[Index in Azure AI Search]
	    Q[User question] --> G[Embed / rewrite query]
	    G --> H[Retrieve: keyword, vector, hybrid]
	    F --> H
	    H --> I[Prompt with context + citations]
	    I --> J[Generate answer]
	    J --> K[Evaluate and monitor]

## Conceptual pattern: embed query, retrieve chunks, then pass context to the model.
query = "What is the refund exception process for enterprise customers?"

query_vector = embed(query)  # Use the same embedding strategy as the indexed chunks.

results = search_client.search(
    search_text=query,
    vector_queries=[
        {
            "vector": query_vector,
            "fields": "contentVector",
            "k_nearest_neighbors": 5
        }
    ],
    filter="department eq 'Support'",
    select=["content", "source", "page", "lastUpdated"],
    top=5
)

context = "\n\n".join(
    f"[{r['source']} p.{r['page']}]\n{r['content']}" for r in results
)

Agents and tool calling

Agent concepts

## Pseudocode: the app, not the model, executes tools.
messages = [
    {"role": "system", "content": "Use tools for account lookups. Do not invent account data."},
    {"role": "user", "content": "What is the status of order A123?"}
]

model_response = call_model(messages, tools=[get_order_status_schema])

if model_response.requests_tool:
    tool_name = model_response.tool_name
    args = validate_json(model_response.tool_arguments)

    if tool_name == "get_order_status":
        tool_result = get_order_status(order_id=args["order_id"])

    messages.append(model_response.as_message())
    messages.append({
        "role": "tool",
        "tool_call_id": model_response.tool_call_id,
        "content": sanitize(tool_result)
    })

    final_response = call_model(messages, tools=[get_order_status_schema])

Azure AI services quick grid

Security, identity, and governance

Identity and access choices

Evaluation and responsible AI

Quality and safety evaluation matrix

Deployment and operations

Production readiness checklist

Common AI-103 exam traps

Rapid review checklist

Before practice, make sure you can explain:

• When to use Microsoft Foundry, Azure OpenAI, Azure AI Search, Azure AI services, and Azure AI Content Safety.
• The difference between direct prompting, RAG, tool calling, and agents.
• How embeddings, chunking, metadata, filters, and hybrid search affect RAG quality.
• Why managed identity, RBAC, Key Vault, private networking, and data filtering matter.
• How to evaluate groundedness, relevance, safety, retrieval quality, and latency.
• How to troubleshoot auth errors, deployment-name issues, throttling, poor retrieval, hallucinations, and tool loops.
• Why prompt injection requires application-level defenses.

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.

Include visual, audio, and extraction work

AI-103 is broader than chat and RAG. The current study guide includes image/video generation and editing as well as visual understanding, speech and audio processing, translation, and information extraction. Distinguish producing new media from analyzing existing input. For extraction, check the required fields or Markdown and how the application validates the result.

High-yield decision rules

Microsoft Foundry and model deployment review

Microsoft 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.

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 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.

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

Performance and cost review

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

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

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?

Put the review into practice