AI-103 Implement text analysis solutions: 169 practice questions

12 of the 169 Implement text analysis solutions questions in the Certsqill AI-103 bank, shown in full below. Each one carries an explanation for every option, not just the correct one — the wrong answers are where the marks go.

Preparing for AI-103? Take the free 5-min readiness check →

1. Use structured outputs with a supported schema: Which implementation best meets both requirements?

1. Ask the model for a concise summary containing invoice details, then map the summary into required fields.

   A summary describes text broadly; it is not the task-specific entity-extraction approach needed for reliably producing the required invoice fields. Mapping a summary does not establish source support.
2. Run PII redaction on the invoice text, then use the redacted text to populate the required invoice fields.

   PII detection and redaction address sensitive-entity handling, not fixed structured extraction or verification of invoice values. Redaction may also remove information needed for extraction.
3. Use JSON mode for valid JSON, then treat successfully parsed fields as supported invoice facts.

   JSON mode targets valid JSON but does not provide the same schema constraint as structured outputs. Parsing success also does not prove that the fields are supported by the source text.
4. Use structured outputs with a supported schema, then validate extracted values against the source text. ✓

   Structured outputs constrain the response to the required JSON schema. Separate validation is still necessary because schema conformance does not establish that extracted values are factually supported by the invoice text.

Use structured outputs for the required shape, and independently validate extracted values against the invoice text.

2. Send the supported JSON schema with structured-output: What missing implementation is required?

1. Enable JSON mode, parse the returned text, and store the invoice fields after parsing.

   JSON mode targets valid JSON but does not provide the same schema constraint, so required fields and types are not assured.
2. Give entity-extraction instructions with examples, then parse the model’s narrative response into invoice fields.

   Entity-extraction instructions and examples improve the task, but parsing unconstrained narrative output does not meet the predictable schema requirement.
3. Send the supported JSON schema with structured-output requests, then validate business rules and handle incomplete responses. ✓

   Structured outputs constrain responses to the required supported schema. Business validation remains necessary because schema conformance does not establish factual correctness.
4. Detect and redact supported PII in invoice text before sending the text to the language model.

   PII detection and redaction address sensitive-information handling, not producing invoice entities in a constrained JSON structure.

Use structured outputs with a supported JSON schema; JSON mode, extraction prompting, and PII redaction do not supply that constraint.

3. Test PII categories and language on representative: What implementation best meets the PII requirement?

1. Add sentiment and tone analysis before redaction, then compare analyst judgments with generated summaries.

   Sentiment, tone, and summarization are different tasks and do not correct missed sensitive-entity detection.
2. Test PII categories and language on representative invoices, then restrict access to originals and logs. ✓

   This validates coverage for the observed domain-specific identifiers and protects unredacted material outside the displayed result.
3. Encrypt detected entities instead of redacting them, leaving source invoices and processing logs under existing access controls.

   Encryption is not the same as PII redaction, and unchanged access still exposes original sensitive content.
4. Return entity type, text, and confidence in JSON, then expose the original invoice.

   A schema constrains response structure but does not improve PII category coverage or protect the original invoice.

Validate PII coverage for the invoice language and domain, and protect originals and logs as well as redacted output.

4. Deploy a model/API combination that supports structured: Which prerequisite should you address?

1. Enable JSON mode, parse each response, and reject outputs that are not valid JSON before storing invoice fields.

   JSON mode targets valid JSON but does not provide the same schema-conformance guarantee. Parsing therefore does not address the missing structured-output prerequisite.
2. Add representative invoice examples and task-specific extraction instructions to the prompt.

   These are appropriate text-analysis practices, but the scenario states that instructions and representative tests already exist. Prompting cannot supply unsupported structured-output capability.
3. Validate schema conformance after generation and reject responses missing required invoice properties before storing extracted fields.

   Validation is necessary defense-in-depth, but it checks responses after generation. It cannot make an unsupported model and API combination enforce the schema.
4. Deploy a model/API combination that supports structured outputs for the required invoice schema. ✓

   Structured outputs require a supported model and API combination. The application can then constrain responses to the specified schema, while retaining its existing validation.

Choose a supported model and API combination before relying on structured outputs.

5. Use a supported model/API with task-specific extraction: Which targeted correction is best?

1. Use a supported model/API with task-specific extraction instructions, structured outputs, and representative-example evaluation; validate fields against email evidence and handle refusals. ✓

   This addresses both structural conformance and unsupported values. Task-specific instructions, representative evaluation, evidence validation, and refusal handling are required safeguards.
2. Run PII detection and redaction before extraction, then store the redacted output as the authoritative record for downstream processing.

   PII detection and redaction address sensitive-entity handling, not schema conformance or whether extracted fields are supported by the email.
3. Use JSON mode with an identical schema and parse responses, then treat every populated field as supported without evidence validation.

   JSON mode targets valid JSON but does not provide the same schema guarantee, and populated fields are not thereby supported by the source text.
4. Add sentiment analysis and require positive messages before accepting extracted contacts, while retaining the existing JSON parsing and schema checks.

   Sentiment measures tone or polarity and cannot verify contact-field support. Existing parsing also does not establish reliable schema or factual validation.

Use supported structured outputs, task-specific extraction instructions, evidence validation, representative testing, and refusal handling.

6. Run representative multilingual domain tests: Which implementation step best satisfies these requirements?

1. Encrypt redacted output and rely on encryption to remove sensitive content from source documents.

   Encryption protects data but does not perform detection or redaction, and it does not remove sensitive content from source documents.
2. Enable JSON mode for every response and store original documents in application logs for later auditing.

   JSON mode concerns output formatting, not PII detection or redaction. Logging originals also exposes sensitive data instead of protecting it.
3. Run representative multilingual domain tests, verify supported PII categories and redaction, then protect originals and logs. ✓

   This reproduces evaluation against realistic data, checks language and domain coverage, verifies redaction behavior, and protects sensitive source material and telemetry.
4. Use sentiment analysis on representative samples, then permit unreviewed display of documents classified as positive.

   Sentiment is a different analysis task and does not establish PII coverage. Displaying documents without protecting sensitive content violates the rollout requirement.

Evaluate representative language and domain examples, verify supported PII categories and redaction, and protect source data and logs.

7. Add task-specific entity definitions and representative: What targeted correction should the developer make?

1. Enable PII redaction for contract text, then measure whether sensitive entity categories improve extraction accuracy.

   PII detection and redaction address supported sensitive-entity categories and protection workflows, not general contract-entity extraction accuracy.
2. Rewrite the sentiment instructions and compare tone labels across the existing representative contract evaluation set.

   Sentiment and tone analysis are different tasks from entity extraction, so changing their instructions does not target the measured entity-field accuracy.
3. Replace structured outputs with JSON mode, then compare whether the same contract fields remain syntactically valid.

   JSON mode targets valid JSON but does not specifically improve whether extracted entities are supported by the contract text. It also weakens the existing schema constraint.
4. Add task-specific entity definitions and representative examples, then reevaluate extracted fields against labeled contracts. ✓

   Entity extraction needs task-specific instructions and evaluation against representative examples. The existing structured response can remain in place, assuming the model and API support it.

Use entity-specific instructions and representative labeled examples; schema validity does not establish extraction accuracy.

8. Use supported structured outputs: Which implementation best meets these requirements?

1. Use JSON mode to parse responses and inspect samples manually, without schema validation or business-rule checks.

   JSON mode targets valid JSON but does not provide the same schema guarantee, and manual inspection does not replace systematic validation.
2. Use supported structured outputs, then apply business-rule checks, representative evaluation, and refusal or incomplete-response handling. ✓

   This combines schema-constrained generation with application validation, representative evaluation, and explicit handling for refusal or incomplete results.
3. Use task-specific extraction instructions and representative evaluation, but return unrestricted text for downstream parsing.

   Task-specific instructions and evaluation are useful, but unrestricted text does not satisfy the production requirement for schema-conformant JSON.
4. Redact invoice PII before extraction and restrict access to original documents and application logs.

   Redaction and protection address sensitive-data handling, not structured output conformance, business validation, or incomplete-response handling.

Use structured outputs with a supported model/API, then validate business rules, evaluate representative data, and handle incomplete results.

9. Detect supported PII: What implementation should the developer use?

1. Encrypt source documents and restrict app access, while allowing original text for authorized reviewers.

   Encryption and access restrictions protect data, but returning original text does not satisfy the requirement to redact detected PII before display.
2. Detect supported PII, redact entities before display, and protect original documents and logs. ✓

   PII detection can identify supported sensitive entity categories and support redaction. Coverage must be validated for the application’s language and domain, while originals and logs require protection separately.
3. Classify each document for sentiment and route negative results for manual review before display.

   Sentiment analysis addresses emotional polarity, not detection or redaction of supported personally identifiable information.
4. Require a JSON schema for names and identifiers, then validate fields before displaying the response.

   Structured outputs constrain response structure, but schema conformance does not detect or remove sensitive information from text.

Use PII detection and redaction for supported categories, while separately protecting source documents and logs.

10. Version representative tickets and instructions: Which implementation best meets these requirements?

1. Detect and redact PII before storage, without validating extraction fields or protecting original documents and logs.

   PII detection and redaction are valid privacy actions, but they do not create a reproducible entity-extraction evaluation or validate the required fields. Originals and logs also still require protection.
2. Version representative tickets and instructions, use structured outputs, validate business rules, and handle incomplete responses. ✓

   Representative examples and task-specific instructions support repeatable evaluation. Structured outputs constrain the response schema, while business-rule validation and incomplete-response handling address correctness and operational safety.
3. Use a summarization workflow to produce JSON, manually review a sample, and release the extraction pipeline.

   Summarization is a different text-analysis task from entity extraction. Manual review of a small sample does not replace representative evaluation, schema-aware handling, and business-rule validation.
4. Use JSON mode with sentiment instructions and accept syntactically valid responses as extracted entities.

   JSON mode targets valid JSON but does not provide the same schema constraint, and sentiment instructions select the wrong analysis task. Syntax alone does not establish correct entity extraction.

Version representative evaluation inputs and task instructions, apply supported structured outputs, and validate results beyond schema conformance.

11. Use supported structured outputs: Which implementation best meets these requirements?

1. Use JSON mode, parse the response, and store every returned field as factual without validating it against the source.

   JSON mode targets valid JSON but does not provide the same schema constraint, and parsing cannot establish that entities are supported by the document.
2. Use supported structured outputs, validate entities against source text, and handle refusals or incomplete responses. ✓

   Structured outputs constrain the response shape, while source-text validation addresses factual support and explicit handling covers refusals or incomplete results.
3. Redact detected PII before submission, then request entities through ordinary text generation.

   PII detection and redaction address sensitive-entity handling, not general entity extraction or structured schema conformance.
4. Run sentiment analysis, map sentiment labels into entity fields, and continue downstream processing.

   Sentiment analysis is a different task from entity extraction and cannot satisfy the requirement to identify document-supported entities.

Use structured outputs for the JSON shape, then independently validate entity support against the source text.

12. Protect original transcripts and application logs: What should the developer implement next?

1. Use structured outputs requiring each detected entity to include a category, span, and confidence value.

   Structured outputs constrain response structure, but they do not protect stored originals or prove that all sensitive meaning was detected.
2. Protect original transcripts and application logs with appropriate access controls while retaining redacted display output. ✓

   Redaction protects the displayed result, but original documents and logs may still contain sensitive information. They require protection through access controls and related safeguards.
3. Add sentiment analysis so emotionally sensitive conversations receive additional privacy protection.

   Sentiment analysis is a different text-analysis task; it does not redact PII or protect original documents and logs.
4. Encrypt the redacted transcript shown to agents without changing permissions for source documents or logs.

   Encryption can be useful, but protecting only the displayed copy leaves source documents and logs exposed through unchanged access controls.

PII redaction does not secure unredacted source documents or logs; protect those assets and control access separately.

Other AI-103 domains

• Implement generative AI and agentic solutions — 429 questions →
• Plan and manage an Azure AI solution — 364 questions →
• Implement computer vision solutions — 169 questions →
• Implement information extraction solutions — 169 questions →
• All 1300 AI-103 questions →