McAfee-Secured Website

Exam Code: AI-300

Exam Name: Operationalizing Machine Learning and Generative AI Solutions

Certification Provider: Microsoft

Corresponding Certification: Microsoft Certified: Machine Learning Operations Engineer Associate

100% Microsoft AI-300 Guaranteed Success With Testking Training Materials

Get Real AI-300 Exam Questions & Expert Verified Answers as Experienced on the Real Exam!

213 Questions & Answers with Testing Engine

"Operationalizing Machine Learning and Generative AI Solutions Exam", also known as AI-300 exam, is a Microsoft certification exam.

Pass your tests with the always up-to-date AI-300 Exam Engine. Your AI-300 training materials keep you at the head of the pack!

Satisfaction Guaranteed

Money Back Guarantee

Testking provides hassle-free money back guarantee with our products. That is because we have 100% trust in the abilities of our professional and experience product team, and our record is a proof of that.

99.6% PASS RATE
Was: $137.49
Now: $124.99

Microsoft AI-300 Practice Test 69

Question 680

A retrieval step takes four seconds but logs record only total response duration. How should tracing be improved?

  1. Capture appropriately redacted retrieval query, selected documents, and model-generation spans.
  2. Configure appropriate trace sampling and retention while keeping critical failures fully observable.
  3. Apply sensitive-data redaction and least-privilege access to traces.
  4. Instrument retrieval and generation as separate timed spans.

Explanation

Correct Answer

D:

Stage-level timing identifies the slow component instead of attributing all latency to the model service.

Incorrect Answers

A:

Capture appropriately redacted retrieval query, selected documents, and model-generation spans. This is useful for the distinct issue: A RAG response hallucinates a citation, but logs contain only the generated answer and not retrieved chunks. The relevant technical rationale or evidence for that issue is: RAG tracing reveals whether failure arose in retrieval or unsupported answer generation. Here the reported issue is: A retrieval step takes four seconds but logs record only total response duration. The relevant response is: Instrument retrieval and generation as separate timed spans. The first result cannot verify this different correction: Stage-level timing identifies the slow component instead of attributing all latency to the model service.

B:

Configure appropriate trace sampling and retention while keeping critical failures fully observable. It addresses another case: An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. For that case, the distinguishing justification or acceptance check is: Selective sampling controls volume without eliminating incident evidence for high-severity application errors. The present case instead states: A retrieval step takes four seconds but logs record only total response duration. It calls for Instrument retrieval and generation as separate timed spans. Showing success for the other case would not establish: Stage-level timing identifies the slow component instead of attributing all latency to the model service.

C:

The alternative, Apply sensitive-data redaction and least-privilege access to traces, belongs to a different technical condition: A tracing agent captures raw customer prompts including social security numbers into an unrestricted monitoring dashboard. There the source-specific mechanism or proof is: Observability must preserve useful diagnostics without turning logs into an uncontrolled store of private data. The condition asked about here is: A retrieval step takes four seconds but logs record only total response duration. A suitable correction is Instrument retrieval and generation as separate timed spans; the targeted justification or result is: Stage-level timing identifies the slow component instead of attributing all latency to the model service.

Question 681

An agent uses a tool to update an order but its audit trace lacks the tool arguments and authorization outcome. What should be recorded safely?

  1. Annotate inference traces with authorized per-request token counts and model identifiers.
  2. Include model deployment and prompt revision identifiers in trace attributes.
  3. Capture redacted tool intent, authorization decision, and execution result in trace metadata.
  4. Record token counts and relevant input-size metrics with errors.

Explanation

Correct Answer

C:

Controlled action metadata supports auditing side effects without exposing unnecessary customer secrets.

Incorrect Answers

A:

Annotate inference traces with authorized per-request token counts and model identifiers. A separate source case supports that approach when: An engineer wants to correlate cost anomalies with a specific user request but token usage exists only in aggregate billing reports. The supporting rationale or observable result is: Per-request token telemetry connects cost spikes to actual execution paths without guessing from aggregate invoices. This question describes a different issue: An agent uses a tool to update an order but its audit trace lacks the tool arguments and authorization outcome. Address it through Capture redacted tool intent, authorization decision, and execution result in trace metadata, with the required justification or evidence: Controlled action metadata supports auditing side effects without exposing unnecessary customer secrets.

B:

Include model deployment and prompt revision identifiers in trace attributes. This is useful for the distinct issue: Two deployment versions run simultaneously, but traces omit the model version. The relevant technical rationale or evidence for that issue is: Version attributes make behavior differences attributable to the actual code and model that handled each request. Here the reported issue is: An agent uses a tool to update an order but its audit trace lacks the tool arguments and authorization outcome. The relevant response is: Capture redacted tool intent, authorization decision, and execution result in trace metadata. The first result cannot verify this different correction: Controlled action metadata supports auditing side effects without exposing unnecessary customer secrets.

D:

Record token counts and relevant input-size metrics with errors. It addresses another case: An LLM error appears sporadically only on large prompts, but request sizes are absent from logs. For that case, the distinguishing justification or acceptance check is: Token usage helps correlate context-limit or processing failures with unusually large inference requests. The present case instead states: An agent uses a tool to update an order but its audit trace lacks the tool arguments and authorization outcome. It calls for Capture redacted tool intent, authorization decision, and execution result in trace metadata. Showing success for the other case would not establish: Controlled action metadata supports auditing side effects without exposing unnecessary customer secrets.

Question 682

An LLM error appears sporadically only on large prompts, but request sizes are absent from logs. What telemetry should be added?

  1. Assign and propagate a correlation identifier through the entire inference request.
  2. Record token counts and relevant input-size metrics with errors.
  3. Create nested spans for each tool invocation under the parent agent request trace.
  4. Capture appropriately redacted retrieval query, selected documents, and model-generation spans.

Explanation

Correct Answer

B:

Token usage helps correlate context-limit or processing failures with unusually large inference requests.

Incorrect Answers

A:

Assign and propagate a correlation identifier through the entire inference request. That operation would be relevant if: A customer reports a wrong AI answer, but support has no request identifier to trace its execution. Its corresponding reason or verification is: End-to-end identifiers connect user-visible results with model, retrieval, and tool diagnostics. However the problem in this question is: An LLM error appears sporadically only on large prompts, but request sizes are absent from logs. The requirement instead calls for Record token counts and relevant input-size metrics with errors; the question-specific check is: Token usage helps correlate context-limit or processing failures with unusually large inference requests.

C:

Create nested spans for each tool invocation under the parent agent request trace. A separate source case supports that approach when: An agent invokes three tools, and a final failure provides no clue which tool returned an exception. The supporting rationale or observable result is: Hierarchical traces identify individual tool latency, errors, and dependencies in multi-step execution. This question describes a different issue: An LLM error appears sporadically only on large prompts, but request sizes are absent from logs. Address it through Record token counts and relevant input-size metrics with errors, with the required justification or evidence: Token usage helps correlate context-limit or processing failures with unusually large inference requests.

D:

Capture appropriately redacted retrieval query, selected documents, and model-generation spans. This is useful for the distinct issue: A RAG response hallucinates a citation, but logs contain only the generated answer and not retrieved chunks. The relevant technical rationale or evidence for that issue is: RAG tracing reveals whether failure arose in retrieval or unsupported answer generation. Here the reported issue is: An LLM error appears sporadically only on large prompts, but request sizes are absent from logs. The relevant response is: Record token counts and relevant input-size metrics with errors. The first result cannot verify this different correction: Token usage helps correlate context-limit or processing failures with unusually large inference requests.

Question 683

An incident report includes inconsistent timestamps across retrieval, inference, and tool services. What observability standard should be established?

  1. Use consistent time synchronization and propagated distributed tracing context.
  2. Annotate inference traces with authorized per-request token counts and model identifiers.
  3. Enforce documented retention periods and secure deletion for sensitive observability data.
  4. Configure appropriate trace sampling and retention while keeping critical failures fully observable.

Explanation

Correct Answer

A:

Aligned timestamps and trace context let responders reconstruct causal order across multiple services.

Incorrect Answers

B:

The alternative, Annotate inference traces with authorized per-request token counts and model identifiers, belongs to a different technical condition: An engineer wants to correlate cost anomalies with a specific user request but token usage exists only in aggregate billing reports. There the source-specific mechanism or proof is: Per-request token telemetry connects cost spikes to actual execution paths without guessing from aggregate invoices. The condition asked about here is: An incident report includes inconsistent timestamps across retrieval, inference, and tool services. A suitable correction is Use consistent time synchronization and propagated distributed tracing context; the targeted justification or result is: Aligned timestamps and trace context let responders reconstruct causal order across multiple services.

C:

Enforce documented retention periods and secure deletion for sensitive observability data. That operation would be relevant if: Production logs include customer prompts, but data-protection policy requires short retention. Its corresponding reason or verification is: Log collection needs data lifecycle governance just as production application storage does. However the problem in this question is: An incident report includes inconsistent timestamps across retrieval, inference, and tool services. The requirement instead calls for Use consistent time synchronization and propagated distributed tracing context; the question-specific check is: Aligned timestamps and trace context let responders reconstruct causal order across multiple services.

D:

Configure appropriate trace sampling and retention while keeping critical failures fully observable. A separate source case supports that approach when: An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. The supporting rationale or observable result is: Selective sampling controls volume without eliminating incident evidence for high-severity application errors. This question describes a different issue: An incident report includes inconsistent timestamps across retrieval, inference, and tool services. Address it through Use consistent time synchronization and propagated distributed tracing context, with the required justification or evidence: Aligned timestamps and trace context let responders reconstruct causal order across multiple services.

Question 684

A failed request cannot be reproduced because the prompt and index versions were changed after it ran. What trace metadata should be retained?

  1. Capture appropriately redacted retrieval query, selected documents, and model-generation spans.
  2. Capture redacted tool intent, authorization decision, and execution result in trace metadata.
  3. Use consistent time synchronization and propagated distributed tracing context.
  4. Record immutable prompt, model, and knowledge-index versions used for the request.

Explanation

Correct Answer

D:

Versioned dependencies are required to reproduce output behavior after application components evolve.

Incorrect Answers

A:

Capture appropriately redacted retrieval query, selected documents, and model-generation spans. It addresses another case: A RAG response hallucinates a citation, but logs contain only the generated answer and not retrieved chunks. For that case, the distinguishing justification or acceptance check is: RAG tracing reveals whether failure arose in retrieval or unsupported answer generation. The present case instead states: A failed request cannot be reproduced because the prompt and index versions were changed after it ran. It calls for Record immutable prompt, model, and knowledge-index versions used for the request. Showing success for the other case would not establish: Versioned dependencies are required to reproduce output behavior after application components evolve.

B:

The alternative, Capture redacted tool intent, authorization decision, and execution result in trace metadata, belongs to a different technical condition: An agent uses a tool to update an order but its audit trace lacks the tool arguments and authorization outcome. There the source-specific mechanism or proof is: Controlled action metadata supports auditing side effects without exposing unnecessary customer secrets. The condition asked about here is: A failed request cannot be reproduced because the prompt and index versions were changed after it ran. A suitable correction is Record immutable prompt, model, and knowledge-index versions used for the request; the targeted justification or result is: Versioned dependencies are required to reproduce output behavior after application components evolve.

C:

Use consistent time synchronization and propagated distributed tracing context. That operation would be relevant if: An incident report includes inconsistent timestamps across retrieval, inference, and tool services. Its corresponding reason or verification is: Aligned timestamps and trace context let responders reconstruct causal order across multiple services. However the problem in this question is: A failed request cannot be reproduced because the prompt and index versions were changed after it ran. The requirement instead calls for Record immutable prompt, model, and knowledge-index versions used for the request; the question-specific check is: Versioned dependencies are required to reproduce output behavior after application components evolve.

Question 685

An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. What safer approach is available?

  1. Apply sensitive-data redaction and least-privilege access to traces.
  2. Record token counts and relevant input-size metrics with errors.
  3. Configure appropriate trace sampling and retention while keeping critical failures fully observable.
  4. Record immutable prompt, model, and knowledge-index versions used for the request.

Explanation

Correct Answer

C:

Selective sampling controls volume without eliminating incident evidence for high-severity application errors.

Incorrect Answers

A:

Apply sensitive-data redaction and least-privilege access to traces. This is useful for the distinct issue: A tracing agent captures raw customer prompts including social security numbers into an unrestricted monitoring dashboard. The relevant technical rationale or evidence for that issue is: Observability must preserve useful diagnostics without turning logs into an uncontrolled store of private data. Here the reported issue is: An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. The relevant response is: Configure appropriate trace sampling and retention while keeping critical failures fully observable. The first result cannot verify this different correction: Selective sampling controls volume without eliminating incident evidence for high-severity application errors.

B:

Record token counts and relevant input-size metrics with errors. It addresses another case: An LLM error appears sporadically only on large prompts, but request sizes are absent from logs. For that case, the distinguishing justification or acceptance check is: Token usage helps correlate context-limit or processing failures with unusually large inference requests. The present case instead states: An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. It calls for Configure appropriate trace sampling and retention while keeping critical failures fully observable. Showing success for the other case would not establish: Selective sampling controls volume without eliminating incident evidence for high-severity application errors.

D:

The alternative, Record immutable prompt, model, and knowledge-index versions used for the request, belongs to a different technical condition: A failed request cannot be reproduced because the prompt and index versions were changed after it ran. There the source-specific mechanism or proof is: Versioned dependencies are required to reproduce output behavior after application components evolve. The condition asked about here is: An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. A suitable correction is Configure appropriate trace sampling and retention while keeping critical failures fully observable; the targeted justification or result is: Selective sampling controls volume without eliminating incident evidence for high-severity application errors.

Question 686

An AI service has healthy model calls but its agent workflow often fails to complete user tasks. What should distributed tracing reveal?

  1. Capture redacted tool intent, authorization decision, and execution result in trace metadata.
  2. Trace orchestration state transitions and completion outcomes, not only model API calls.
  3. Instrument retrieval and generation as separate timed spans.
  4. Configure appropriate trace sampling and retention while keeping critical failures fully observable.

Explanation

Correct Answer

B:

Successful inference spans cannot establish that downstream agent decisions and tool execution completed correctly.

Incorrect Answers

A:

Capture redacted tool intent, authorization decision, and execution result in trace metadata. A separate source case supports that approach when: An agent uses a tool to update an order but its audit trace lacks the tool arguments and authorization outcome. The supporting rationale or observable result is: Controlled action metadata supports auditing side effects without exposing unnecessary customer secrets. This question describes a different issue: An AI service has healthy model calls but its agent workflow often fails to complete user tasks. Address it through Trace orchestration state transitions and completion outcomes, not only model API calls, with the required justification or evidence: Successful inference spans cannot establish that downstream agent decisions and tool execution completed correctly.

C:

Instrument retrieval and generation as separate timed spans. This is useful for the distinct issue: A retrieval step takes four seconds but logs record only total response duration. The relevant technical rationale or evidence for that issue is: Stage-level timing identifies the slow component instead of attributing all latency to the model service. Here the reported issue is: An AI service has healthy model calls but its agent workflow often fails to complete user tasks. The relevant response is: Trace orchestration state transitions and completion outcomes, not only model API calls. The first result cannot verify this different correction: Successful inference spans cannot establish that downstream agent decisions and tool execution completed correctly.

D:

Configure appropriate trace sampling and retention while keeping critical failures fully observable. It addresses another case: An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. For that case, the distinguishing justification or acceptance check is: Selective sampling controls volume without eliminating incident evidence for high-severity application errors. The present case instead states: An AI service has healthy model calls but its agent workflow often fails to complete user tasks. It calls for Trace orchestration state transitions and completion outcomes, not only model API calls. Showing success for the other case would not establish: Successful inference spans cannot establish that downstream agent decisions and tool execution completed correctly.

Question 687

Production logs include customer prompts, but data-protection policy requires short retention. What trace lifecycle control must be applied?

  1. Enforce documented retention periods and secure deletion for sensitive observability data.
  2. Assign and propagate a correlation identifier through the entire inference request.
  3. Configure appropriate trace sampling and retention while keeping critical failures fully observable.
  4. Trace orchestration state transitions and completion outcomes, not only model API calls.

Explanation

Correct Answer

A:

Log collection needs data lifecycle governance just as production application storage does.

Incorrect Answers

B:

Assign and propagate a correlation identifier through the entire inference request. That operation would be relevant if: A customer reports a wrong AI answer, but support has no request identifier to trace its execution. Its corresponding reason or verification is: End-to-end identifiers connect user-visible results with model, retrieval, and tool diagnostics. However the problem in this question is: Production logs include customer prompts, but data-protection policy requires short retention. The requirement instead calls for Enforce documented retention periods and secure deletion for sensitive observability data; the question-specific check is: Log collection needs data lifecycle governance just as production application storage does.

C:

Configure appropriate trace sampling and retention while keeping critical failures fully observable. A separate source case supports that approach when: An application generates huge trace volumes and exceeds monitoring budgets, prompting developers to disable all tracing. The supporting rationale or observable result is: Selective sampling controls volume without eliminating incident evidence for high-severity application errors. This question describes a different issue: Production logs include customer prompts, but data-protection policy requires short retention. Address it through Enforce documented retention periods and secure deletion for sensitive observability data, with the required justification or evidence: Log collection needs data lifecycle governance just as production application storage does.

D:

Trace orchestration state transitions and completion outcomes, not only model API calls. This is useful for the distinct issue: An AI service has healthy model calls but its agent workflow often fails to complete user tasks. The relevant technical rationale or evidence for that issue is: Successful inference spans cannot establish that downstream agent decisions and tool execution completed correctly. Here the reported issue is: Production logs include customer prompts, but data-protection policy requires short retention. The relevant response is: Enforce documented retention periods and secure deletion for sensitive observability data. The first result cannot verify this different correction: Log collection needs data lifecycle governance just as production application storage does.

Question 688

An engineer wants to correlate cost anomalies with a specific user request but token usage exists only in aggregate billing reports. What should spans include?

  1. Enforce documented retention periods and secure deletion for sensitive observability data.
  2. Record immutable prompt, model, and knowledge-index versions used for the request.
  3. Instrument retrieval and generation as separate timed spans.
  4. Annotate inference traces with authorized per-request token counts and model identifiers.

Explanation

Correct Answer

D:

Per-request token telemetry connects cost spikes to actual execution paths without guessing from aggregate invoices.

Incorrect Answers

A:

The alternative, Enforce documented retention periods and secure deletion for sensitive observability data, belongs to a different technical condition: Production logs include customer prompts, but data-protection policy requires short retention. There the source-specific mechanism or proof is: Log collection needs data lifecycle governance just as production application storage does. The condition asked about here is: An engineer wants to correlate cost anomalies with a specific user request but token usage exists only in aggregate billing reports. A suitable correction is Annotate inference traces with authorized per-request token counts and model identifiers; the targeted justification or result is: Per-request token telemetry connects cost spikes to actual execution paths without guessing from aggregate invoices.

B:

Record immutable prompt, model, and knowledge-index versions used for the request. That operation would be relevant if: A failed request cannot be reproduced because the prompt and index versions were changed after it ran. Its corresponding reason or verification is: Versioned dependencies are required to reproduce output behavior after application components evolve. However the problem in this question is: An engineer wants to correlate cost anomalies with a specific user request but token usage exists only in aggregate billing reports. The requirement instead calls for Annotate inference traces with authorized per-request token counts and model identifiers; the question-specific check is: Per-request token telemetry connects cost spikes to actual execution paths without guessing from aggregate invoices.

C:

Instrument retrieval and generation as separate timed spans. A separate source case supports that approach when: A retrieval step takes four seconds but logs record only total response duration. The supporting rationale or observable result is: Stage-level timing identifies the slow component instead of attributing all latency to the model service. This question describes a different issue: An engineer wants to correlate cost anomalies with a specific user request but token usage exists only in aggregate billing reports. Address it through Annotate inference traces with authorized per-request token counts and model identifiers, with the required justification or evidence: Per-request token telemetry connects cost spikes to actual execution paths without guessing from aggregate invoices.

Question 689

A RAG assistant misses policy exceptions because the ingestion job stores 18-page manuals as single vectors. What should the retriever designer change first?

  1. Verify ingestion change detection and refresh the index entries for the revised document version.
  2. Apply enforced tenant and authorization filters in retrieval before documents enter model context.
  3. Filter or rank by verified effective-version metadata while excluding superseded document revisions.
  4. Split source manuals into coherent section-level chunks with headings and measured overlap.

Explanation

Correct Answer

D:

Smaller coherent sections surface relevant exceptions without embedding unrelated manual chapters in the same vector.

Incorrect Answers

A:

Verify ingestion change detection and refresh the index entries for the revised document version. It addresses another case: A knowledge page was corrected yesterday but retrieved excerpts still contain the deleted error. For that case, the distinguishing justification or acceptance check is: Retrieval cannot reflect corrected knowledge until obsolete chunks and embeddings have been replaced or invalidated. The present case instead states: A RAG assistant misses policy exceptions because the ingestion job stores 18-page manuals as single vectors. It calls for Split source manuals into coherent section-level chunks with headings and measured overlap. Showing success for the other case would not establish: Smaller coherent sections surface relevant exceptions without embedding unrelated manual chapters in the same vector.

B:

The alternative, Apply enforced tenant and authorization filters in retrieval before documents enter model context, belongs to a different technical condition: A tenant-specific RAG search sometimes returns documents belonging to another customer. The model is instructed to ignore them, but they remain in context. There the source-specific mechanism or proof is: Prompt instructions cannot replace access-controlled retrieval of only documents the requester is entitled to read. The condition asked about here is: A RAG assistant misses policy exceptions because the ingestion job stores 18-page manuals as single vectors. A suitable correction is Split source manuals into coherent section-level chunks with headings and measured overlap; the targeted justification or result is: Smaller coherent sections surface relevant exceptions without embedding unrelated manual chapters in the same vector.

C:

Filter or rank by verified effective-version metadata while excluding superseded document revisions. That operation would be relevant if: The assistant answers a 2026 policy query using a superseded 2023 procedure stored beside the current version. Its corresponding reason or verification is: Version-aware retrieval prevents obsolete but semantically similar policy language from displacing current approved guidance. However the problem in this question is: A RAG assistant misses policy exceptions because the ingestion job stores 18-page manuals as single vectors. The requirement instead calls for Split source manuals into coherent section-level chunks with headings and measured overlap; the question-specific check is: Smaller coherent sections surface relevant exceptions without embedding unrelated manual chapters in the same vector.

Question 690

A benefits answer cites a chunk that ends just before the sentence containing the required exclusion. How can the index preserve this cross-boundary context?

  1. Evaluate stricter relevance thresholds on a held-out question and document relevance set.
  2. Increase candidate top-k and measure recall before imposing a bounded context budget.
  3. Add controlled overlap or parent-section context around boundary-sensitive chunks.
  4. Apply enforced tenant and authorization filters in retrieval before documents enter model context.

Explanation

Correct Answer

C:

Boundary context keeps the qualification beside the rule instead of losing it in adjacent retrieval units.

Incorrect Answers

A:

Evaluate stricter relevance thresholds on a held-out question and document relevance set. It addresses another case: A legal RAG assistant cites unrelated contracts because similarity filtering is too permissive. For that case, the distinguishing justification or acceptance check is: Thresholds should reject known irrelevant chunks while preserving relevant contract clauses under representative queries. The present case instead states: A benefits answer cites a chunk that ends just before the sentence containing the required exclusion. It calls for Add controlled overlap or parent-section context around boundary-sensitive chunks. Showing success for the other case would not establish: Boundary context keeps the qualification beside the rule instead of losing it in adjacent retrieval units.

B:

The alternative, Increase candidate top-k and measure recall before imposing a bounded context budget, belongs to a different technical condition: A product-support bot retrieves only one chunk per query and misses second-step configuration details. The index contains both steps. There the source-specific mechanism or proof is: A larger candidate pool can expose missing relevant steps, but quality and latency must be measured rather than assumed. The condition asked about here is: A benefits answer cites a chunk that ends just before the sentence containing the required exclusion. A suitable correction is Add controlled overlap or parent-section context around boundary-sensitive chunks; the targeted justification or result is: Boundary context keeps the qualification beside the rule instead of losing it in adjacent retrieval units.

D:

Apply enforced tenant and authorization filters in retrieval before documents enter model context. That operation would be relevant if: A tenant-specific RAG search sometimes returns documents belonging to another customer. The model is instructed to ignore them, but they remain in context. Its corresponding reason or verification is: Prompt instructions cannot replace access-controlled retrieval of only documents the requester is entitled to read. However the problem in this question is: A benefits answer cites a chunk that ends just before the sentence containing the required exclusion. The requirement instead calls for Add controlled overlap or parent-section context around boundary-sensitive chunks; the question-specific check is: Boundary context keeps the qualification beside the rule instead of losing it in adjacent retrieval units.

Operationalizing Machine Learning and Generative AI Solutions (AI-300) Practice Tests