Task 2.1: Implement generative AI apps and agents by using Foundry

• AIn each user prompt, typed by the students along with their question

  Incorrect

  User prompts carry the student's own request. Relying on students to repeat the rules is unreliable, and they could simply leave them out.

• BIn a fine-tuning dataset used to retrain the model before launch

  Incorrect

  Retraining isn't needed to set a role and a few rules. The system prompt handles that without any training data.

• CIn the system prompt that the application sends with each request

  Correct

  The system prompt sets the role, tone and constraints the model follows for the whole conversation, and the application controls it, not the student.

• DIn the deployment's tokens-per-minute rate limit settings

  Incorrect

  Rate limits control how much traffic a deployment accepts. They have no effect on how the model behaves or what it says.

System prompts set the behavior, tone and constraints of the model and are usually set by the application. User prompts carry the specific question, and the model answers them while following the system prompt.

• ATell the model to answer from the excerpts and to say when they don't contain the answer

  Correct

  Grounding instructions plus an explicit fallback tell the model what to do when the context is insufficient, instead of guessing.

• BRaise the temperature so the model considers a wider range of possible answers

  Incorrect

  A higher temperature makes output more random. It makes invented details more likely, not less.

• CStop sending the excerpts so the model answers from what it learned in training

  Incorrect

  The model's training doesn't include the company's private policies, so removing the excerpts removes the facts it needs.

• DTell the model to sound confident and give a full answer each time a question is asked

  Incorrect

  Pushing for confident, complete answers encourages the model to fill gaps rather than admit that the information is missing.

A grounded prompt includes the retrieved content plus instructions to answer from it, acknowledge when it's insufficient and cite sources. Telling the model what to do when it lacks information is a key part of a reliable system message.

• ARun the AI Red Teaming Agent against the deployment and reuse its generated attack prompts as code

  Incorrect

  The AI Red Teaming Agent probes a deployment with adversarial prompts to find safety risks. It doesn't produce a client application.

• BCopy the generated Python sample from the playground's code view, or open it in VS Code

  Correct

  The playground exports multilingual code samples for the deployment and settings you tested, and Open in VS Code imports the sample, endpoint and key for you.

• CSave the playground chat as an evaluation dataset and run an evaluation against the deployment

  Incorrect

  Evaluations score quality and safety of outputs. They're a useful next step, but they don't give you client code.

• DWrite REST calls from scratch by reading the API reference and copying the key from the Azure portal

  Incorrect

  Calling the REST API directly works, but it's slower and you must recreate the settings by hand; the playground already generates matching code.

The model playground is a bridge between experimentation and code. After you test prompts and parameters, its code view gives you a sample that calls your deployment with the same settings, which you can use as the start of a lightweight client.

• A"gpt-5-mini", the name of the underlying model

  Incorrect

  The base model name only works if the deployment happens to have the same name. Here it was named "support-chat".

• B"2025-08-07", the version of the deployed model

  Incorrect

  The version is a property of the deployment, not the identifier you put in the request.

• CThe name of the Foundry project that contains the deployment

  Incorrect

  The project is identified by the endpoint URL. The model parameter names the deployment to call.

• D"support-chat", the name of the deployment

  Correct

  Requests name the deployment you created, which can differ from the underlying model's name.

When you deploy a model you give the deployment a name, and requests refer to that deployment name. If you don't customize it, it matches the model name, which is why the two are easy to confuse.

• ACreate a TextAnalyticsClient with the resource endpoint and a key, then call its detect_language() method for each prompt

  Incorrect

  TextAnalyticsClient belongs to the Azure Language SDK and runs fixed text analysis tasks. It doesn't chat with a deployed model.

• BCreate a SpeechConfig with the resource key and endpoint, then start a SpeechRecognizer that listens to the microphone

  Incorrect

  SpeechConfig and SpeechRecognizer come from the Speech SDK and turn spoken audio into text. They don't send prompts to a chat model.

• CCreate an AIProjectClient with the project endpoint, call get_openai_client(), then call responses.create()

  Correct

  The Foundry SDK connects to the project endpoint and hands you an OpenAI-compatible client for calling deployed models through the Responses API.

• DCreate a ContentUnderstandingClient, then call begin_analyze() with an analyzer ID for each prompt

  Incorrect

  ContentUnderstandingClient runs Content Understanding analyzers on documents and media. It isn't used for chatting with a model.

The Foundry SDK exposes a project client for Foundry operations and an OpenAI-compatible client for calling models with the Responses API; most apps use both. A typical lightweight client creates the project client, gets the OpenAI client and calls responses.create().

• AUse Microsoft Entra ID through DefaultAzureCredential and assign the identity a Foundry role

  Correct

  Entra ID removes the key from the code and supports managed identities, conditional access and granular role-based access, which Microsoft recommends for production.

• BKeep the API key in the script but rotate it to a new value each week in the portal

  Incorrect

  Rotation limits how long a leaked key is useful, but the secret stays in the code and a shared key still can't tell users apart.

• CMove the API key into a .env file and load it with load_dotenv() when the script starts

  Incorrect

  A .env file keeps the key out of the source text, which is fine for prototypes, but it's still one shared key with coarse access and no per-user traceability.

• DChange the model deployment to the Data Zone Standard type so requests stay inside a data zone

  Incorrect

  Data Zone deployment types control where inference is processed. They don't change how the client authenticates.

Foundry supports Microsoft Entra ID and API keys. Keys are convenient for quick evaluation but give coarse access without per-user traceability; Entra ID with role assignments is the recommended choice for production.

• AA longer system prompt that describes the HR system and its data in detail

  Incorrect

  A description of the HR system shapes how the model talks about it, but text alone can't read live data or submit anything.

• BTools that let the model call the HR system to read data and take actions

  Correct

  An agent combines a model, instructions and tools. Tools are what let it act on external systems, such as reading a balance or submitting a request.

• CA higher maximum output token limit for longer and fuller answers

  Incorrect

  Allowing longer responses changes their length, not the model's ability to reach the HR system.

• DA second deployment of the same model in another Azure region

  Incorrect

  Another deployment adds capacity or resilience. It doesn't give the model any way to act.

Agents build on models: a model provides reasoning, instructions define the role, and tools let the agent call APIs, functions or other systems to retrieve information and take actions.

• AAdd the agent's instructions to the start of each user message

  Incorrect

  Repeating instructions doesn't bring back the earlier question.

• BCreate a new version of the agent before each question so its definition stays current

  Incorrect

  Agent versions capture changes to instructions, model or tools. A new version carries no conversation history.

• CLower the temperature so the agent's answers stay consistent from one turn to the next

  Incorrect

  Temperature affects randomness in wording. It can't supply the missing earlier turn.

• DCreate a conversation once and pass its ID with each request to the agent

  Correct

  A conversation stores the input and output items of earlier turns, so each new response runs with the history in context.

In Foundry Agent Service, an agent supplies reusable behavior, a conversation persists history across turns, and a response is one unit of execution. Reusing the same conversation is what lets the agent answer follow-up questions in context.

• ACode Interpreter, for the calculations and charts

  Correct

  Code Interpreter lets the agent write and run Python in a sandbox for data analysis and chart generation on uploaded files.

• BFunction calling, for the recent competitor announcements

  Incorrect

  Function calling would need the team to write and host code that fetches announcements. Web search returns current public results directly.

• CWeb search, for the recent competitor announcements

  Correct

  Web search grounds answers in current public web content with inline citations, which suits last week's announcements.

• DImage generation, for the charts

  Incorrect

  Image generation creates pictures from prompts. It doesn't compute values from the CSV data, so the charts wouldn't be accurate.

• EA Content Understanding analyzer, for the growth rate calculations

  Incorrect

  Content Understanding extracts structured data from content. It doesn't calculate growth rates or draw charts.

Match each requirement to a tool: Code Interpreter runs Python for data analysis and charts, and web search brings in current public information.

• ARaise the temperature to the top of its range for more creative writing

  Incorrect

  A very high temperature makes output more random. It doesn't fix missing information about audience and format.

• BState the audience, tone, format and length, such as three short bullet points for beginner trail runners

  Correct

  Clear, specific prompts that give the audience and the format you want produce more relevant, usable output than vague requests.

• CLeave out product details so the model isn't constrained by them

  Incorrect

  Leaving out context gives the model less to work with, which tends to make the copy more generic.

• DInclude a short example of existing copy written in the style you want

  Correct

  An example (one-shot or few-shot) shows the model the style and shape of output you expect for this request.

• EAdd the words "be original" to the end of the prompt

  Incorrect

  A vague instruction adds no audience, format or content to work from. Specific instructions work better than general ones.

Better prompts are clear and specific, add context such as topic, audience and format, ask for structure, and use examples to show the style you want. The examples condition the model for that request without changing it permanently.

• AA URL whose query string carries the API key and the prompt text

  Incorrect

  The URL identifies the endpoint and API version. The key or token goes in a header, and the prompt goes in the JSON body.

• BHeaders with authentication, plus a JSON body with the model and input

  Correct

  REST requests carry metadata such as authentication in headers and the data, such as the model and prompt, in a JSON body.

• CAn SSML document that describes how the model should speak

  Incorrect

  SSML is for text to speech, not for sending prompts to a model.

• DA binary gRPC message that carries the key and the prompt

  Incorrect

  Foundry endpoints expose REST interfaces: HTTP requests with headers and a JSON body, and JSON responses.

Applications talk to Foundry endpoints with REST requests: headers hold metadata such as authentication and data format, and a JSON body holds the data. Responses also come back as JSON. SDKs build these calls for you.

• AAn app that downloads the model's weights and runs inference on the user's laptop

  Incorrect

  Running the model locally is a different pattern; a lightweight client calls a remote service.

• BA large web platform with its own databases, queues and user management

  Incorrect

  Heavy backends and frameworks are what a lightweight client avoids.

• CA script that trains a new model each time a user asks a question

  Incorrect

  Clients send requests for inference; they don't train models.

• DA small app that sends input to the remote model and shows the result

  Correct

  Lightweight clients keep state and compute mostly on the server, with a small code footprint and minimal configuration.

A lightweight client is a small, minimal app, such as a single Python file or CLI, that collects input, calls a remote API and displays results, leaving the model and heavy work on the server.

• Aiso6391_name

  Incorrect

  iso6391_name holds a language code in Azure Language language detection results.

• Bprimary_language

  Incorrect

  primary_language belongs to Azure Language language detection results.

• Cmarkdown

  Incorrect

  markdown appears in Content Understanding analysis results, not in Responses API output.

• Doutput_text

  Correct

  output_text gives the generated text of the response, as the Foundry quickstart samples show.

The Responses API returns a response object whose output_text property holds the generated text, which is what a simple chat client prints or shows to the user.

• AA multi-agent system of specialized, collaborating agents

  Correct

  In multi-agent systems, several agents with their own specialties work together, communicating through prompts.

• BA single model call with a very long system prompt

  Incorrect

  One model call doesn't divide the work among specialized agents.

• CA batch deployment that processes reports overnight

  Incorrect

  A batch deployment is a model deployment type, not a way of splitting work across agents.

• DA retrieval index shared by several chat apps

  Incorrect

  A shared index supplies knowledge but doesn't describe agents working together.

Instead of one agent doing everything, multiple agents can collaborate, each with its own specialty: one gathers data, another analyzes it and a third takes action, much like a human team.