Implement Generative AI And Agentic Solutions practice questions

Increase the chunk size parameter in the document ingestion pipeline to 4000 tokens

Why it fails: Larger chunks do not resolve version ambiguity; they dilute the embedding with more unrelated text, worsening discrimination between similar titles. Chunk size tuning suits improving context completeness for long documents, not separating near-identical manual versions.

Decrease the temperature parameter of the Azure OpenAI generation model to 0.0

Why it fails: Temperature controls randomness in generated text, not which documents Azure AI Search returns, so retrieval of outdated manuals is unaffected. Setting temperature to 0.0 is correct when the requirement is deterministic, factual generation rather than retrieval ranking.

Switch the embedding model from text-embedding-ada-002 to text-embedding-3-small

Why it fails: Swapping embedding models changes vector dimensionality and semantic quality but does not encode document recency, so newer and older manuals still rank similarly. Model upgrades suit general semantic accuracy gains, not filtering by version or date.

Classic Azure OpenAI fine-tuned model deployment

Why it fails: Fine-tuned deployments train a custom model on your supplied examples, so your training data is incorporated into model weights rather than excluded from Microsoft's base-model training. The stem requires a deployment type whose terms guarantee prompts and completions are never used for training; fine-tuning addresses task specialisation, not data-privacy compliance.

Data Zone Standard deployment with model tuning enabled

Why it fails: Enabling model tuning means your data is used to train a custom model, which contradicts the requirement that prompt and completion data not be used to train base models. Data Zone Standard alone governs where data is stored and processed for residency; it is the right choice when data-residency boundaries, not training exclusion, are the compliance driver.

Provisioned Throughput deployment

Why it fails: Provisioned Throughput reserves dedicated capacity, measured in provisioned throughput units, to guarantee latency and quota; it makes no contractual statement about whether prompts and completions are excluded from base-model training. It is the correct selection when predictable performance under heavy, steady load matters rather than data-privacy guarantees.

Disable authentication on the external API and rely solely on network-level Azure VNet integration.

Why it fails: Network isolation does not satisfy the requirement for user-delegated authentication tokens.

Store the user's password in Azure Key Vault and have the plugin retrieve it on every tool call.

Why it fails: Retrieving user passwords inside a plugin defeats token-based OAuth flows and introduces severe security risks.

Hardcode the service account client secret inside the plugin configuration settings.

Why it fails: Hardcoding service accounts violates security best practices and fails user-delegated authorization.

Azure Cache for Redis with session state middleware

Why it fails: Redis session-state middleware persists per-session key-value data with expiry, not durable cross-session conversational history tied to a user identity. Redis suits caching and short-lived session state; long-term agent memory needs a persistent store the Azure AI Agent Service can query across sessions.

Azure Cosmos DB vector search collections

Why it fails: Cosmos DB vector search stores and retrieves embeddings for semantic similarity, but the Azure AI Agent Service's built-in memory feature already manages long-term conversational history without custom schema or embedding pipelines. Vector search suits custom RAG over your own corpus, not the agent's native memory requirement.

Azure AI Search index vector store

Why it fails: A vector index stores embeddings for semantic similarity search over documents, not structured per-user session history. It is tempting because Azure AI Search is the standard retrieval layer for RAG grounding, and would be correct for searching a knowledge base, but the Agent Service's own thread and memory store persists conversational turns across sessions.

Azure Cost Management budgeting alerts only

Why it fails: Cost Management alerts only notify when spending crosses budget thresholds; they aggregate at subscription or resource-group scope and expose no per-department token counts. It is tempting because chargeback is a cost concern, and budgets would suit tracking overall Azure spend, but token attribution requires Azure OpenAI's own metrics and logging.

Azure AI Content Safety severity reports

Why it fails: Content Safety reports classify harmful content categories and severity scores; they contain no token or usage telemetry. It is tempting because Content Safety is enabled on Azure OpenAI deployments and surfaces per-request data, but it would be the right choice for filtering or moderating prompts and completions, not for departmental chargeback.

Azure Advisor security recommendations

Why it fails: Azure Advisor security recommendations assess configuration posture and suggest remediations; they report no consumption data. It is tempting because Advisor covers Azure OpenAI resources and appears in the portal alongside them, but it would be correct for hardening deployments, whereas token chargeback needs usage metrics grouped by department.

The cost per token consumed during inference

Why it fails: Token cost is a billing metric reported by Azure OpenAI usage data, not a quality signal, and the groundedness pipeline never compares cost against source context. Cost tracking is genuinely useful for budget monitoring, but groundedness instead measures whether the response's claims are supported by the supplied source context.

The sentiment and tone of the user prompt

Why it fails: Sentiment and tone describe stylistic or affective qualities of text and require no source context, whereas groundedness compares response claims against the supplied context. Sentiment analysis is the right tool for gauging user satisfaction, but it cannot detect whether an LLM response is factually supported by the grounding document.

Azure SQL Database scalar User Defined Functions

Why it fails: Scalar UDFs execute T-SQL logic inside Azure SQL Database and cannot host or serve a Llama 3 model, so they cannot process inference requests at all. They are tempting because they extend database queries with custom computation, which suits data transformation scenarios, not GPU-backed model hosting.

Local developer workstation Docker container

Why it fails: A workstation Docker container runs on local hardware, so it cannot scale to high-concurrency production traffic or provide the managed GPU capacity Foundry offers. It is tempting because containers give reproducible local testing of open-source models, which suits development and experimentation rather than production inference.

Azure Functions consumption plan

Why it fails: Azure Functions consumption billing scales per execution and provides no GPU-backed model hosting, so latency and throughput for Llama 3 would suffer badly. It is tempting for event-driven glue code, but high-concurrency inference needs a provisioned or serverless GPU deployment in Foundry.

Azure SQL database transparent data encryption (TDE)

Why it fails: Transparent data encryption protects data at rest in Azure SQL, which does nothing to guard a public-facing chatbot against harmful prompts or outputs. It is tempting because encryption is a recognised security control, and TDE would be correct when the requirement is protecting stored database files from unauthorised physical or media access.

Azure DDoS network layer volumetric scrubbing

Why it fails: DDoS volumetric scrubbing defends network infrastructure against traffic floods, not the content-level harms a public-facing chatbot must mitigate. It is tempting because DDoS protection is a legitimate Azure security control, and it would be correct when the threat is volumetric network attacks against internet-facing endpoints.

Word count frequency

Why it fails: Word count frequency measures verbosity, not harm; it cannot flag violent, hateful or self-harm content. It is tempting because frequency analysis underpins readability and keyword extraction, and would suit tasks such as summarising or indexing documents, but content safety requires the dedicated harm-category severity scores.

BLEU machine translation score

Why it fails: BLEU compares n-gram overlap between generated and reference translations, so it scores linguistic accuracy rather than harmful content. It is tempting because it is the standard metric for machine translation quality evaluation, and would be the correct choice when assessing a translation model's output fidelity against reference text.

Model parameter count

Why it fails: Parameter count describes model size and capacity, revealing nothing about whether outputs contain harmful material. It is tempting because larger models often correlate with stronger general capability, and it would be relevant when selecting a model for compute budget or deployment sizing, not for Responsible AI harm evaluation.

Azure Data Factory

Why it fails: Azure Data Factory orchestrates data movement and ETL pipelines, not agent task sequencing, so it cannot define the workflow's step order or hand-offs. It is tempting because Data Factory genuinely coordinates multi-step activities, but agentic orchestration in Azure AI Foundry relies on the agent definitions, connected tools, and thread or run sequencing.

Azure Logic Apps integration

Why it fails: Logic Apps provides general-purpose connector-based automation, not the agent-native constructs that define sequential task orchestration inside Azure AI Foundry. It is tempting because Logic Apps genuinely chains actions across services, but the essential components are the agent, its tools, and the run or thread flow that sequences tasks.

Enable 'Content Safety' to bypass filtering.

Why it fails: Content safety is for filtering, not for enabling information access.

Increase the system prompt length in the model configuration.

Why it fails: Increasing prompt length does not solve retrieval or grounding issues.

Switch the model to a higher parameter count version.

Why it fails: Model size does not dictate data retrieval success.

Retrain the base LLM on the niche dataset.

Why it fails: Retraining alters the model's weights, which is costly and does not guarantee grounding on niche facts; RAG instead injects retrieved authoritative context into the prompt at query time. It is tempting because fine-tuning genuinely helps when you must teach a persistent output style or domain vocabulary.

Increase the system prompt length.

Why it fails: A longer system prompt adds instructions but no new factual grounding, so the model still fabricates niche answers. It is tempting because prompt engineering is a quick, low-effort change, and would be correct if the issue were tone, format, or instruction-following rather than missing knowledge.

Lower the temperature setting to 0.0.

Why it fails: Lowering temperature limits creativity but does not guarantee the model will use relevant data.

Azure OpenAI studio Playground.

Why it fails: The Playground supports ad-hoc single-prompt experimentation and chat testing, but it does not run multiple prompt variants against a dataset and score them side by side. That comparison is performed by the evaluation flow. The Playground is the right tool for interactively drafting and refining one prompt before formal evaluation.

Azure AI Content Safety.

Why it fails: Content Safety filters harmful text and images; it does not execute prompts or compare outputs across a dataset. It is tempting because it also sits within Azure AI Foundry and evaluates model interactions, but that evaluation targets safety categories, not prompt-variant quality for summarisation.

Azure AI Search.

Why it fails: Azure AI Search indexes and retrieves documents; it cannot run prompt variants or score their outputs against a dataset. It is tempting because Foundry evaluation flows often pair with a search index for grounding data, but retrieval is a separate concern from comparing prompt outputs.

Disable authentication for the API.

Why it fails: Disabling authentication is a severe security risk.

Hardcode the OAuth tokens in the tool definition.

Why it fails: This is a security vulnerability.

Request the user to provide credentials via the chat interface.

Why it fails: This is insecure and impacts the user experience.

The Data Scientist only.

Why it fails: A data scientist owns model experimentation and evaluation, not organisational accountability for ethical deployment, which spans policy, legal and governance sign-off. It is tempting because data scientists build the agent, and their involvement is correct for fairness metrics and bias testing within their remit.

The end user.

Why it fails: End users consume the agent and can report concerns, but they hold no authority over deployment decisions, risk assessments or compliance controls. It is tempting because user feedback surfaces harms in practise, and user acceptance testing is the right activity for validating usability before release.

The Azure Billing Admin.

Why it fails: The Azure Billing Admin manages subscriptions, cost management and payment methods, with no remit over AI ethics, risk or compliance. It is tempting because billing admins do govern Azure resource access, and that role is correct when the task concerns cost allocation or subscription-level spend.

The Azure OpenAI Playground history.

Why it fails: Playground history is for individual testing, not formal lifecycle management.

Azure AI Content Safety logs.

Why it fails: These are for monitoring, not lifecycle management.

The global search index.

Why it fails: This is a data source, not a lifecycle tool.

An Azure Data Factory instance.

Why it fails: Data Factory is a data integration service for pipelines and movement; a Foundry project instead requires a hub and an Azure AI Services or storage-backed connection. It is tempting because projects ingest data, and Data Factory would be correct when the requirement is orchestrating ETL between external stores.

A virtual machine.

Why it fails: A Foundry project requires a hub and a connected Azure AI Services resource, not compute. A VM is tempting because self-hosted models or custom training jobs need one, but the managed project itself provisions serverless endpoints without any virtual machine.

A dedicated Kubernetes cluster.

Why it fails: Foundry projects use managed online endpoints and serverless deployments, so no Kubernetes cluster is provisioned. A dedicated cluster is tempting for teams already running AKS inference workloads, but that is an infrastructure choice, not a prerequisite resource for creating the project.

Model Parameter count.

Why it fails: This is a hardware/model spec, not an effectiveness metric.

The number of times the model was restarted.

Why it fails: This is a system health metric, not an agent effectiveness metric.

Deleting and recreating the entire resource group.

Why it fails: Recreating the resource group rebuilds the whole environment rather than inspecting the flow's input processing, so it cannot isolate the fault and may destroy diagnostic evidence. It is tempting as a clean-slate reset for corrupted deployments, but input-processing faults need inspection of the flow's input mappings, schema validation and run logs.

Increasing the model temperature to see if the error persists.

Why it fails: Temperature governs the language model's sampling randomness, not how inputs are parsed, mapped or validated before the model call, so it cannot surface an input-processing fault. It is tempting because raising it changes outputs, but that is the correct lever when diagnosing overly deterministic or repetitive model responses.

The model is automatically retrained on new data.

Why it fails: Deployment does not trigger training.

All previous chat history is deleted from the server.

Why it fails: Chat history is independent of deployment state.