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

Exam identity and study focus

This independent Quick Reference supports candidates preparing for the Microsoft Microsoft Azure AI Apps and Agents Developer Associate (AI-103) exam. Use it as a compact review of high-yield design choices, implementation patterns, and troubleshooting points for Azure AI apps and agent-based solutions.

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

Azure AI Foundry concepts

Foundry development checklist

• Create or select the Azure AI project/resource.
• Deploy or select a suitable model.
• Define the app pattern: direct model call, RAG, agent, or workflow.
• Configure connections to data sources, indexes, tools, and storage.
• Build prompts with clear instructions, grounding rules, and output constraints.
• Add content safety and input/output validation.
• Evaluate with representative prompts and expected outcomes.
• Deploy through an app/API layer with managed identity where possible.
• Monitor traces, latency, token use, model errors, safety flags, and user feedback.

Azure OpenAI and model interaction reference

Building blocks

Model parameter quick reference

Prompt design checklist

Minimal Azure OpenAI call pattern

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)

Exam points:

• Prefer Microsoft Entra ID and managed identities for production when supported.
• API keys are easier for quick tests but increase secret-management risk.
• The model deployment name is a frequent source of 404 or deployment-not-found errors.
• Token budget includes instructions, history, retrieved context, tool schemas, and response.

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]

Chunking and indexing decisions

Azure AI Search components

Retrieval modes

RAG retrieval snippet

## 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
)

RAG failure-to-fix table

Agents and tool calling

Agent concepts

Agent vs function vs workflow

Tool/function calling pattern

## 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])

Tool-calling traps:

• Validate tool arguments even if the schema is strict.
• Apply authorization before executing the requested action.
• Treat tool outputs and retrieved documents as untrusted text.
• Use idempotency keys or confirmation for actions that change state.
• Log tool traces without exposing secrets or sensitive data.
• Set max iterations to avoid runaway agent loops.

Azure AI services quick grid

Security, identity, and governance

Identity and access choices

Data and prompt security checklist

• Classify data before sending it to model, search, logging, or evaluation systems.
• Use least privilege for app identity to Search, Storage, Key Vault, and AI resources.
• Apply user-level or tenant-level filters before retrieval.
• Remove or mask sensitive data in logs and traces.
• Do not put secrets in prompts, tool schemas, system messages, or source documents.
• Validate model output before database writes, API calls, or user-visible actions.
• Use human approval for high-impact operations.
• Treat prompt injection as an application security issue, not just a prompt wording issue.

Prompt injection defenses

Evaluation and responsible AI

Quality and safety evaluation matrix

Responsible AI controls

Deployment and operations

Production readiness checklist

Troubleshooting quick table

Common AI-103 exam traps

Rapid review checklist

Before practice, make sure you can explain:

• When to use Azure AI 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.

Next step for practice

Use this Quick Reference as a checklist while completing hands-on Azure AI Foundry, Azure OpenAI, Azure AI Search, and agent labs. Then move into timed AI-103-style practice questions that force you to choose the best service, pattern, security control, and troubleshooting action for each scenario.