Welcome to Part 4 of our complete study series for the AI-103 Certification. This module covers the highest-weighted area on the exam: Implement Generative AI and Agentic Solutions (30–35%). In Microsoft Foundry (formerly Azure AI Foundry), mastering Retrieval-Augmented Generation (RAG) means knowing how to chunk documents, build vector indexes in Azure AI Search, combine hybrid search with Semantic Ranker, and orchestrate modern workflows using Microsoft Agent Framework.
 |
| Microsoft Foundry RAG & Workflows: AI-103 Certification Practice Questions |
In this free AI-103 practice exam module, you will solve 20 realistic scenarios covering chunking strategies, vector embeddings, Reciprocal Rank Fusion (RRF), Semantic Ranker, Foundry IQ, and workflow orchestration. Each question provides full explanations for all options.
Microsoft Foundry RAG & Workflows Practice Questions (Part 4)
Q1: Deterministic RAG Summarization (Temperature Parameter)
You have an Azure AI Foundry project that contains an AI agent. The agent uses a Retrieval-Augmented Generation (RAG) pattern to generate summaries from retrieved policy documents.
Users report that some of the generated responses omit required regulatory clauses, even when those clauses are clearly present in the retrieved context.
You need to improve the completeness and factual accuracy of the responses.
Solution: You increase the value of the temperature parameter on the model deployment.
Does this meet the goal?
• B is correct: The temperature parameter controls the randomness and creativity of the model's responses. Increasing it causes the model to generate more diverse and less deterministic text, which can lead to a higher rate of hallucinations and further deviation from the retrieved factual content. To ensure the model accurately includes specific regulatory clauses from the context, you should decrease the temperature (closer to 0) to make the output more focused and deterministic, or update the system prompt to explicitly instruct the model not to omit clauses.
• A is incorrect: Increasing the temperature parameter will not resolve the issue.
Q2: Guaranteed Schema Validation (Structured Outputs)
A legal-tech RAG application retrieves contract clauses and must extract specific fields — party names, effective date, termination notice period — into a strictly valid JSON object that a downstream billing system parses automatically. Free-form prompt instructions asking the model to "return JSON" occasionally produce malformed JSON or extra commentary text outside the JSON object.
Which configuration should the team apply to guarantee schema-valid output?
• Why D is correct: Structured outputs let you define a strict JSON schema that the model's response is constrained to follow, guaranteeing a parseable, schema-conformant object every time — rather than hoping a natural-language instruction is consistently obeyed.
• Why A is incorrect: Higher temperature increases output randomness, making inconsistent or malformed formatting more likely, not less.
• Why B is incorrect: A larger context window allows more input/output tokens; it has no bearing on whether the output conforms to a specific schema.
• Why C is incorrect: Additional few-shot examples can improve consistency somewhat, but without schema enforcement, the model can still occasionally deviate — examples alone don't guarantee validity the way a constrained schema does.
Q3: Handling RAG Retrieval Quality & Relevance Thresholds (Yes/No)
For each of the following statements about handling retrieval results in a RAG application, select Yes if the statement is true. Otherwise, select No.
1. Configuring a minimum relevance/similarity score threshold, below which no retrieved chunks are passed to the model, helps the application recognize when a user's question falls outside its knowledge base rather than forcing a weak or irrelevant chunk into the prompt.
2. If retrieval returns no chunks above the relevance threshold, the best practice is to silently omit the retrieved-context section from the prompt and let the model answer from its own general knowledge instead.
3. A system prompt instruction telling the model to explicitly state that it doesn't have enough information, combined with a relevance threshold at retrieval time, together reduce the chance of a fabricated answer when the knowledge base genuinely lacks relevant content.
• Statement 1 is Yes: Without a relevance threshold, a retriever will still return its "best available" chunks even when none of them are actually relevant, and the model may treat weakly-related content as if it were valid grounding. A threshold lets the application detect the "no good match" case explicitly.
• Statement 2 is No: Silently falling back to the model's general knowledge defeats the purpose of a RAG architecture meant to ground answers strictly in the organization's own content, and risks producing an answer that sounds authoritative but isn't backed by the knowledge base at all — the opposite of the reliability RAG is meant to provide.
• Statement 3 is Yes: Combining a retrieval-time relevance threshold (to detect when there's no good match) with an explicit system-prompt instruction to admit insufficient information (rather than guess) addresses the problem from both the retrieval and generation sides, meaningfully reducing fabricated answers in the no-match case.
Q4: Enterprise Grounding Architecture (Foundry IQ Knowledge Bases)
A development team is building a RAG solution in Microsoft Foundry. The application must generate answers exclusively based on corporate policy documents that have already been ingested and indexed inside an Azure AI Search service.
Which built-in Foundry capability lets you connect this search index to an agent so it can retrieve from it and ground its responses, with citations, at query time?
• B is correct: Foundry IQ is Foundry's managed knowledge layer, built on Azure AI Search. You connect your existing search index as a knowledge source inside a Foundry IQ knowledge base, then attach that knowledge base to an agent. At query time, Foundry IQ's agentic retrieval runs the query against the source, applies semantic reranking, and returns a grounded, cited response — no custom retrieval orchestration required.
• A is incorrect: Document Intelligence extracts text, tables, and key-value pairs from documents. It's an ingestion/preparation tool, not the mechanism that connects an already-indexed search index to an agent at query time.
• C is incorrect: Prompt flow can build a fully custom RAG pipeline, but the question asks for the built-in Foundry capability — Foundry IQ is the turnkey option.
• D is incorrect: the semantic ranker reranks results inside Azure AI Search itself; it isn't the integration layer that attaches an index to an agent as a knowledge source.
Note: Azure OpenAI "On Your Data" offered similar grounding for Chat Completions-based apps, but it's deprecated and scheduled for retirement on October 14, 2026 — Microsoft's own migration guidance points to Foundry IQ.
Q5: Evaluating Hallucinations & Factual Support (Groundedness Metric)
During the automated quality evaluation of a Retrieval-Augmented Generation (RAG) system, evaluators observe that the model occasionally outputs statements that appear confident and fluent, but cannot be verified by any information contained in the retrieved reference context (hallucinations).
Which AI evaluation metric in Azure AI Foundry directly quantifies the degree to which the generated completion is factually supported by the retrieved source documents?
• Why C is correct: Groundedness measures how well the generated response is anchored in the retrieved reference context chunks. A low groundedness score indicates that the model fabricated claims or introduced external, unverified knowledge (hallucination) that was not present in the source documents.
• Why A is incorrect: Coherence evaluates the logical consistency, structure, and flow of the generated answer, regardless of whether the content is factually accurate or derived from the retrieved documents. A completely fabricated hallucination can still have a high coherence score.
• Why B is incorrect: Relevance evaluates how well the generated answer addresses the user's specific prompt or question. A response can be highly relevant to the query while remaining ungrounded in the retrieved text.
• Why D is incorrect: Fluency assesses the grammatical accuracy, syntax, vocabulary choice, and readability of the output text. It does not measure factual grounding or source fidelity.
Q6: Multi-Turn Conversational Search (Query Rewriting Pattern)
A multi-turn RAG chat application lets users ask follow-up questions. In one session, a user first asks "What's the refund window for electronics?" and then asks "What about for furniture instead?" The retrieval step sends this second message directly to Azure AI Search as-is, and the search returns poor results because the query has no explicit mention of "refund window."
Which design change should the team make to fix this specific failure mode?
• Why D is correct: This is the standard "query rewriting" or "condense question" pattern for multi-turn RAG: the model uses the conversation history to reformulate an ambiguous, context-dependent follow-up into a standalone, fully-specified query, which the retriever can then match effectively against the index.
• Why A is incorrect: Raising the similarity threshold would make the retriever even less likely to return results for a vague, underspecified query — it doesn't address the root cause of the query being ambiguous.
• Why B is incorrect: Chunk overlap affects how content is split at index time; it has no ability to infer that "furniture" in the user's new message relates to a "refund window" concept from an earlier turn.
• Why C is incorrect: Appending the full raw conversation history to the search query typically introduces noisy, unfocused text that dilutes keyword and vector relevance, rather than producing the crisp, standalone query a rewriting step would generate.
Q7: Core Architectural Benefits of RAG (Yes/No)
An organization is reviewing architectural strategies to ensure their generative AI applications deliver accurate, up-to-date business information.
For each of the following statements regarding the primary architectural benefits of Retrieval-Augmented Generation (RAG), select Yes if the statement is true. Otherwise, select No.
1. RAG enables language models to ground their responses in private, proprietary enterprise knowledge that was not part of the base model's public training data.
2. Implementing RAG eliminates the need to update base foundation models whenever organizational policies or product catalogs change.
3. The primary objective of RAG is to accelerate database backup speeds and lower cold storage persistence latency across storage accounts.
• Statement 1 is Yes: Foundation models only know the public information available up to their training cutoff date. RAG overcomes this limitation by retrieving relevant chunks from internal corporate knowledge bases at inference time and injecting them into the prompt context, allowing the model to produce accurate, proprietary answers.
• Statement 2 is Yes: Because RAG dynamically pulls updated content from a search index at runtime, business data can be updated, added, or deleted continuously in the index without requiring expensive and time-consuming model fine-tuning or retraining cycles.
• Statement 3 is No: RAG is an AI inference pattern designed for context retrieval and factual generation; it has no relationship to database replication, storage backup operations, or disk I/O performance.
Q8: Exact Terms vs. Semantic Intent (Hybrid Search in Azure AI Search)
An enterprise customer support search engine must answer technical queries about industrial machinery. Users search using a combination of natural language questions (e.g., "how do I reset a hydraulic valve") and exact alphanumeric serial codes (e.g., "Model-TX-902B-v2").
Which retrieval strategy combines full-text BM25 keyword matching with dense vector similarity to achieve optimal grounding relevance across both query types?
• Why A is correct: Hybrid search in Azure AI Search executes both dense vector search (capturing semantic intent and conceptual meaning) and traditional full-text BM25 lexical search (capturing exact keywords, rare acronyms, and alphanumeric part numbers) in parallel. The results are merged and ranked into a single unified result list using algorithms like Reciprocal Rank Fusion (RRF), delivering the highest retrieval accuracy for mixed-nature queries.
• Why B is incorrect: Round-robin scoring is a generic load distribution or alternating selection method; it is not a relevance ranking or search algorithm in Azure AI Search.
• Why C is incorrect: Pure full-text search relies solely on lexical keyword matching. It struggles with synonyms, multi-lingual queries, and semantic intent where users describe concepts without using the exact matching words.
• Why D is incorrect: Exact-match filtering (such as OData $filter expressions) only includes documents with identical field values (boolean matching); it does not compute relevance scores or evaluate semantic similarity.
Q9: Handling Incomplete RAG Outputs (Evaluation vs. Prompt Engineering)
You have an Azure AI Foundry project that contains an AI agent. The agent uses a Retrieval-Augmented Generation (RAG) pattern to generate summaries from retrieved policy documents.
Users report that some of the generated responses omit required regulatory clauses, even when those clauses are clearly present in the retrieved context.
You need to improve the completeness and factual accuracy of the responses.
Solution: You configure an evaluation flow that scores responses for completeness and blocks any responses that fall below a defined threshold.
Does this meet the goal?
• B is correct: While evaluating for completeness is a valid practice for testing and observability, blocking responses that fall below a threshold does not improve the agent's ability to generate complete summaries. It simply results in the user receiving an error or a blocked message instead of a helpful answer. To actually improve the completeness of the generated responses, you should refine the system prompt (metaprompt) to explicitly mandate the inclusion of all regulatory clauses, or lower the model's temperature to make outputs more deterministic.
• A is incorrect: Blocking responses does not train or instruct the model to generate better, more complete answers.
Q10: Tuning Knowledge Source Cutoffs (Relevance & Similarity Thresholds)
A customer support RAG application grounds an agent through a Foundry IQ knowledge base connected to an Azure AI Search index. Users report that the assistant frequently refuses to answer valid product questions with a fallback message. Telemetry confirms Azure AI Search is returning relevant chunks, but they're being filtered out by an overly strict minimum relevance/similarity threshold before reaching the model.
You need to reduce the aggressiveness of this filtering to increase recall, without turning relevance filtering off entirely. What should you do?
• B is correct: when a relevance/similarity threshold is set too high, chunks that are genuinely useful but score just below the cutoff get discarded before the model ever sees them — producing false "not found" refusals. Lowering the threshold lets more borderline-relevant chunks through, directly increasing recall.
• A is incorrect: temperature controls output randomness at generation time; it has no effect on which chunks retrieval returns.
• C is incorrect: returning more chunks doesn't help if the relevant ones are still filtered out below the threshold before that top-k cut is applied.
• D is incorrect: disabling grounding entirely reintroduces the exact hallucination risk RAG exists to prevent, and doesn't address the over-filtering itself.
Note: Azure OpenAI "On Your Data" exposed this same control as a runtime parameter named strictness (1–5, default 3). That specific parameter belongs to a service retiring October 14, 2026 — the underlying concept (a tunable minimum relevance threshold) carries over to Azure AI Search / Foundry IQ knowledge source configuration, but isn't a single named 1–5 knob in the new architecture.
Q11: Mitigating RAG Hallucinations (Groundedness & Retrieval Quality - Select 2)
An e-commerce RAG chatbot answers customer questions about electronics. During user acceptance testing, evaluators discover that the chatbot frequently hallucinates warranty terms and return policies that do not exist anywhere in the source catalog documentation.
Which TWO actions should the engineering team take to directly detect and prevent these ungrounded responses? (Select TWO.)
• Why A and D are correct:
- Evaluation & Detection (A): The Groundedness evaluator in Azure AI Foundry quantitatively measures the percentage of claims in the generated response that are substantiated by the retrieved reference text. It provides the metric needed to systematically detect and score hallucinations.
- Prevention & Quality (D): Preventing ungrounded responses requires fixing the two root causes of RAG hallucinations: ensuring the search engine actually retrieves the authoritative policy text (via hybrid search and semantic reranking) and instructing the model in the system prompt to strictly decline answering if the information is absent from the retrieved chunks (e.g., "Only answer using the facts provided in the sources; if unknown, state that you do not have that information").
• Why the other options are incorrect:
- Why B is incorrect: Increasing sampling temperature increases stochastic randomness and creativity, which drastically worsens hallucinations and factual fabrications.
- Why C is incorrect: Adding regions and expanding TPM quotas increases throughput and request limits; it does not change model behavior or improve factual grounding.
- Why E is incorrect: Text-to-image models generate pictures from prompts; they cannot serve conversational text answers for customer support.
Q12: Ingestion & Chunking Optimization (Token Size & Overlap Strategy)
A team is indexing a set of 400-page technical maintenance manuals for a RAG application. Each manual contains multi-step procedures where a single logical step is often described across two or three consecutive paragraphs, sometimes spanning a page break.
The team initially chunks the documents into very small, fixed-size chunks of 100 tokens with no overlap between chunks, and finds that retrieved chunks frequently cut a procedure step in half, causing the model to generate incomplete or contradictory instructions.
Which chunking adjustment should the team make to address this specific failure mode?
• Why C is correct: When a coherent unit of meaning (a procedure step) is larger than the chunk size, splitting it produces fragments that lose necessary context. Sizing chunks closer to the natural unit of meaning, and adding overlap between consecutive chunks, ensures that content near a boundary is still fully present in at least one retrieved chunk.
• Why A is incorrect: Making chunks even smaller increases the chance that a single step gets split across even more fragments, worsening the exact problem described.
• Why B is incorrect: Chunking by file extension has nothing to do with the internal structure or length of the content within a document; it wouldn't address mid-procedure splitting at all.
• Why D is incorrect: Indexing an entire 400-page manual as one chunk would exceed practical embedding and context-window limits, and would return an enormous, mostly irrelevant block of text for every query instead of a focused, relevant passage.
Q13: Evaluating Query Alignment (Relevance Metric)
During automated quality testing of a conversational assistant, the evaluation pipeline observes that while the model’s responses are grammatically sound and logically organized, they repeatedly fail to address the specific inquiry submitted by the user.
Which evaluation metric in Azure AI Foundry should the team analyze to quantify how directly and completely the model's generated answer addresses the user's input prompt?
• Why C is correct: Relevance evaluates how pertinent and targeted the generated completion is to the user's input prompt. An answer that ignores the user's core intent or veers off into unrelated subjects receives a low relevance score, even if the text is fluent and grammatically flawless.
• Why A is incorrect: Groundedness measures whether claims in the model's response are factually substantiated by retrieved source reference documents in a RAG pipeline. A model can generate a response that is strictly grounded in retrieved documents yet completely irrelevant to what the user actually asked.
• Why B is incorrect: Coherence measures the logical flow, structural unity, and internal consistency of the response. A completely off-topic response can still be highly coherent.
• Why D is incorrect: Fluency assesses linguistic syntax, grammar, spelling, and sentence readability. It does not measure whether the content answers the user's question.
Q14: Embedding Model Migration & Dimensionality Mismatch
A team migrates their RAG application from an older embedding model that outputs 1536-dimensional vectors to a newer embedding model that outputs 3072-dimensional vectors. They update the application code to call the new embedding model, but leave the existing Azure AI Search vector index field configuration unchanged. Indexing new documents begins failing immediately.
What is the most likely cause of the failure?
• Why A is correct: A vector field in an Azure AI Search index is defined with a fixed number of dimensions matching the embedding model used at index-creation time. Switching to a model with a different output dimensionality produces vectors that no longer match that fixed field definition, causing indexing to fail until the field (or a new index) is defined with the new, correct dimensionality.
• Why B is incorrect: Azure AI Search does not automatically detect or adapt to embedding model changes; the vector field schema is fixed at creation and must be explicitly updated or recreated by the developer.
• Why C is incorrect: TPM quota is a rate limit on model inference calls; it produces throttling (HTTP 429) errors, not a dimension-mismatch indexing failure, and nothing in the scenario points to a quota issue.
• Why D is incorrect: Vector fields do enforce a specific, fixed dimensionality set at field creation — this constraint is exactly why the migration described causes a failure.
Q15: Re-ranking Hybrid Search Results (Semantic Ranker Layer)
An Azure AI Search-backed RAG application currently uses hybrid search (keyword + vector, merged with Reciprocal Rank Fusion). The team notices that while the top results are usually topically related to the query, the single most relevant passage is often ranked third or fourth instead of first, because RRF only considers each result's rank position in the original lists, not how much better one match is than another.
Which additional Azure AI Search capability should be layered on top of the existing hybrid query to reorder results using a deeper semantic understanding of query-to-passage relevance?
• Why this is correct: The semantic ranker applies a deep learning re-ranking model on top of an initial hybrid (or full-text) result set, evaluating the semantic relevance of each candidate passage to the query more precisely than rank-based fusion alone, and reordering results accordingly — directly addressing the "right topic, wrong order" problem described.
• Why "Increase the value of k in the vector query" is incorrect: Raising k returns more candidate vector matches into the pool being fused, but it does not change how RRF ranks the results already returned — the ordering problem described isn't solved by retrieving more candidates.
• Why "Switch to a smaller, faster embedding model" is incorrect: A smaller model affects retrieval speed and potentially recall quality, but it doesn't add a re-ranking step, and there's no indication embedding quality — rather than fusion ranking — is the cause of the ordering issue described.
Q16: Grounded Responses & Source Citations (Foundry IQ Knowledge Bases)
You are building a RAG chat application in Microsoft Foundry. Business requirements dictate that users must be able to click on references within chat responses to verify the exact source documents used to generate the answer.
Which design approach should you implement to meet this requirement?
• C is correct: to provide verifiable citations, you need a framework that retrieves documents and explicitly pairs the generated text with source metadata. Foundry IQ returns extractive data paired with citations, so agents can trace generated claims back to specific source documents — the same citation-pairing role Azure OpenAI "On Your Data" used to serve before its deprecation (retiring October 14, 2026). A custom orchestration flow can achieve the same pairing manually if you need behavior Foundry IQ doesn't cover.
• A is incorrect: a high temperature increases randomness; it doesn't make the model aware of real source documents or their URLs.
• B is incorrect: Content Safety filters harmful content — it has no mechanism to know or append actual source document references.
• D is incorrect: reducing max_tokens truncates output length; it has no relationship to citation accuracy or metadata.
Q17: Azure AI Search Indexing Architecture (Matching)
Match each indexing description to the corresponding Azure AI Search indexing concept. Each concept is used exactly once.
1. Automatically pulls content from a supported data source (such as Blob Storage) on a defined schedule and populates the index, without the application pushing documents itself.
2. Applies an AI enrichment pipeline (such as OCR, key phrase extraction, or entity recognition) to content during indexing, before it's written to the index.
3. Lets an application directly upload or update documents in the index in real time, used when data isn't in a supported data source or immediate freshness is required.
4. Defines where embeddings are stored in the index, including their dimensionality and the similarity metric used for vector search.
• 1 → Indexer: An indexer is the pull-based component that connects to a supported data source and automatically crawls and ingests content into the index on a schedule, removing the need for the application to manage ingestion itself.
• 2 → Skillset: A skillset is attached to an indexer to run enrichment steps — like extracting text from images or recognizing entities — transforming raw content into richer, more searchable fields as part of the indexing pipeline.
• 3 → Push API: The Push API lets an application send documents directly to the index via a REST/SDK call, which is the right approach when content doesn't live in a data source an indexer supports, or when near-real-time updates are required.
• 4 → Vector field: The vector field in the index schema is where embeddings are stored, and its configuration — dimensionality and similarity metric (such as cosine) — must match the embedding model producing those vectors.
Q18: Reducing Redundant Token Spend (Semantic Caching Pattern)
A high-traffic customer support RAG application observes that many users ask near-duplicate questions worded differently (e.g., "How do I reset my password?" and "What's the process to change my password?"). Each of these currently triggers a full retrieval-plus-generation cycle, driving up both latency and token cost, even though a very similar question was just answered minutes earlier.
Which approach should the team implement to reduce redundant cost and latency for these near-duplicate queries?
• Why B is correct: Semantic caching compares the embedding of an incoming query against previously seen queries and returns a cached response when they're similar enough (above a configurable similarity threshold), even if the wording differs — directly addressing "same question, different phrasing" cases the way exact-match caching cannot. This is available as a built-in policy in Azure API Management for Azure OpenAI, and as a pattern using a vector-capable cache such as Azure Managed Redis.
• Why A is incorrect: Chunk size affects indexing granularity; it has no mechanism to recognize that two differently-worded queries are asking the same thing, so it doesn't reduce redundant generation calls.
• Why C is incorrect: An exact-text cache key only matches queries with identical wording, so "How do I reset my password?" and "What's the process to change my password?" would be treated as entirely different, uncached requests — missing exactly the case described.
• Why D is incorrect: Raising TPM quota increases how much throughput is allowed; it does nothing to avoid the redundant work itself, so cost and latency per redundant query stay the same.
Q19: Multi-Turn Context Window Budgeting (Conversation Summarization)
A multi-turn RAG chat application keeps appending every prior user and assistant message to each new request, alongside the system prompt and freshly retrieved context. After roughly 30 turns, requests begin failing because the combined prompt exceeds the model's context window.
Which approach should the team implement to handle long conversations without losing the ability to reference earlier context?
• Why A is correct: Summarizing older turns compresses their information into far fewer tokens while preserving the gist of earlier context, letting the application keep recent turns (usually most relevant for continuity), the system prompt, and retrieved grounding content all within the token budget indefinitely.
• Why B is incorrect: Removing the system prompt discards the model's behavioral instructions and constraints — including any grounding or safety instructions — which typically causes worse or inconsistent behavior, not just a loss of history.
• Why C is incorrect: Dropping retrieved context defeats the purpose of the RAG architecture; the application would stop grounding answers in source documents specifically once conversations get long, which is backwards from the goal.
• Why D is incorrect: Switching billing/deployment tier (Standard vs PTU) does not change a specific model's fixed context window size — that's a property of the model itself, not the deployment type.
Q20: Enforcing Output Consistency (Few-Shot In-Context Prompting)
A pharmaceutical company is building a clinical trial report analyzer using Azure OpenAI. The model must extract adverse event descriptions from trial documents and classify each event's severity using the industry-standard MedDRA grading scale (Grade 1–5). The team observes that zero-shot prompting produces inconsistently formatted severity classifications and occasionally uses non-MedDRA terminology. A prompt engineer proposes adding three examples to the prompt that each demonstrate a raw adverse event description paired with the correctly formatted MedDRA grade and rationale before presenting the actual input.
What is the primary benefit of this few-shot example approach compared to the zero-shot approach?
• Why this answer is correct:
- In-Context Learning: Few-shot prompting works via in-context learning. By prepending concrete demonstration pairs (raw input → target MedDRA output + rationale), the attention mechanism guides the model to mimic the exact schema, syntax, and controlled terminology demonstrated in the examples.
- Eliminates Format Variance: Large language models often hallucinate or use synonyms (e.g., calling a Grade 3 event "Severe" or "Critical") in zero-shot scenarios. Providing few-shot examples anchors the generation process strictly to the defined grading scale (Grade 1–5) and required schema without ambiguity.
• Why the other options are incorrect:
- Why "It increases the model's token limit..." is incorrect: Few-shot prompting does not expand the model’s architectural context window (e.g., 128k tokens). In fact, adding demonstration examples consumes available context tokens, slightly reducing the space remaining for the target document payload.
- Why "It causes the model to retrieve MedDRA grade definitions from an external medical database..." is incorrect: Few-shot examples are static text patterns included directly in the prompt body. They do not invoke runtime search queries, vector lookups, or external database calls (which would require a RAG architecture or function-calling tool).
- Why "It fine-tunes the underlying model weights..." is incorrect: Few-shot prompting modifies only the prompt text at inference time; it does not execute backward passes, calculate loss gradients, or alter the model's underlying weights. Weight adjustments require an explicit model fine-tuning job.
Azure AI Search Modes & Re-ranking Cheat Sheet
Domain 2 tests your ability to match search patterns to real business data. Use this reference table to choose the right retrieval mechanism for your official Microsoft AI-103 credential:
| Search Mode | Core Mechanism & Strengths | Known Limitation | Best Exam Use Case |
|---|---|---|---|
| Full-Text (BM25) | Lexical matching. Excellent for exact product codes, SKUs, serial numbers, and rare domain acronyms. | Misses conceptual matches, synonyms, and user queries with typos or paraphrased wording. | Querying catalog items by exact alphanumeric part numbers. |
| Vector Search (HNSW) | Dense mathematical embeddings. Captures conceptual intent and meaning across languages. | Can miss exact alphanumeric strings or unique serial codes that look like random numbers. | Conversational queries where users describe a problem in plain English. |
| Hybrid Search (RRF) | Runs BM25 and vector queries in parallel. Merges both result lists using Reciprocal Rank Fusion. | Fuses results strictly by rank position (1st, 2nd, 3rd) rather than semantic relevance score. | General enterprise search handling mixed queries (both codes and descriptions). |
| Hybrid + Semantic Ranker | Applies deep learning cross-encoders on top of hybrid results to re-rank chunks by true semantic relevance. | Adds slight query latency and consumes semantic ranker units. | Fixing the "right topic, wrong order" issue where the best answer is ranked 3rd or 4th. |
Document Chunking Strategies Compared
How you split documents during ingestion directly controls retrieval accuracy and model context window budgets:
| Strategy | How It Works | When to Choose It |
|---|---|---|
| Fixed-Size (No Overlap) | Splits text strictly every N tokens (e.g., 200 tokens). | Short, uniform documents like standalone FAQs. Avoid for multi-step procedures because it cuts sentences in half. |
| Fixed-Size + Token Overlap | Splits text into chunks while repeating a set number of tokens (e.g., 10% overlap) across adjacent chunk boundaries. | Technical manuals, policies, and contracts where a single rule or procedure spans across consecutive paragraphs. |
| Semantic Chunking | Uses NLP models to detect natural topic transitions, splitting text only when the subject changes. | Long-form reports and articles with clear chapter headers and distinct conceptual sections. |
| Integrated Vectorization (GA) | Automates document parsing, chunking, and embedding generation inside the Azure AI Search indexer pipeline. | Production cloud RAG systems. Eliminates the need to write custom pre-processing code before indexing. |
Key Takeaways for AI-103 Domain 2 (RAG & Workflows)
• RRF vs. Semantic Ranker: Reciprocal Rank Fusion (RRF) blends keyword and vector lists based purely on their position on the page, not how good the match is. To fix the "right topic, wrong order" problem and bring the single best passage to position #1, you must layer the Semantic Ranker on top of your hybrid query.
• Architecture Shift (Prompt Flow Retirement): Microsoft ended active feature development on Prompt Flow in April 2026, and the feature retires permanently in April 2027. Modern AI-103 architectures build graph-based workflows using the Microsoft Agent Framework, tracing executions with DevUI and OpenTelemetry.
• Grounding Migration (Foundry IQ): Azure OpenAI "On Your Data" is deprecated and scheduled for retirement on October 14, 2026. The modern, turnkey standard for grounding agents with verifiable document citations is Foundry IQ Knowledge Bases connected directly to Azure AI Search.
• Vector Field Dimensions: The dimensionality of a vector field in Azure AI Search (such as 1536 for older models or 3072 for text-embedding-3-large) is immutable once created. If you switch embedding models, you cannot push mismatched vectors into an existing field; you must create a new vector field or rebuild the index.
• Multi-Turn Query Rewriting: Never send raw follow-up messages (like "What about for furniture?") directly to your search index. Use the language model to condense the conversation history into a standalone query (e.g., "What is the refund policy for furniture?") before calling the retriever.
Frequently Asked Questions (Foundry RAG & Search FAQ)
Here are straightforward answers to the most common RAG and workflow architecture questions tested on the AI-103 exam:
Is Azure OpenAI On Your Data still the right way to ground a Foundry agent?
No. Azure OpenAI On Your Data is deprecated and retires on October 14, 2026. Microsoft's official replacement is Foundry IQ, a managed knowledge layer built on Azure AI Search that attaches knowledge sources to agents and automatically returns cited, grounded answers.
Should I still learn Prompt Flow for the AI-103 exam?
Feature development on Prompt Flow ended in April 2026, and it retires in April 2027. Microsoft Agent Framework is the generally available replacement for building graph-based workflows in Foundry, which is the core framework tested on modern AI-103 exams.
What is the difference between hybrid search and the semantic ranker in Azure AI Search?
Hybrid search runs keyword and vector queries in parallel, merging results by rank position using Reciprocal Rank Fusion (RRF). The semantic ranker is a separate secondary step that uses deep cross-encoder models to re-evaluate and reorder those results by true semantic meaning.
Is Integrated Vectorization in Azure AI Search still in preview?
No, Integrated Vectorization is now generally available (GA). It automates document cracking, data chunking, and embedding generation directly inside the Azure AI Search indexer pipeline, removing the need for custom external code to vectorize documents before ingestion.
What is the difference between Groundedness and Relevance evaluation metrics?
Groundedness measures whether an answer's claims are factually supported by retrieved source text (detecting hallucinations). Relevance measures whether the answer directly addresses the user's question. A response can be completely grounded in source text while remaining completely irrelevant to the prompt.
Next Step in Your AI-103 Certification Journey
Congratulations on completing Part 4 of our free AI-103 practice exam! By working through these 20 scenario-based AI-103 quiz questions, you now have a solid command of enterprise RAG architecture, vector search mechanics, Semantic Ranker re-ranking, and modern workflow orchestration inside Microsoft Foundry.
