Data Classification Labeling Prompt for Unstructured Text

This prompt is for data governance engineers and AI platform architects who need to classify unstructured text before it enters downstream AI pipelines. It assigns sensitivity labels, handling instructions, and retention categories based on content analysis. Use it when you need a consistent, automatable classification layer that sits between raw document ingestion and any AI system that processes, stores, or routes text. This prompt is designed to be embedded as a pre-processing step in a data pipeline, not as a conversational assistant. It assumes the input text has already been extracted from its source format and that the classification taxonomy is defined and stable.

The ideal user is someone responsible for data hygiene in AI systems—typically a platform engineer, compliance officer, or data governance lead. You should have a defined taxonomy of sensitivity tiers, handling rules, and retention categories before deploying this prompt. The prompt works best on self-contained text chunks (paragraphs, documents, transcripts) where the content carries enough signal for classification. It is not designed for real-time chat moderation, structured database records, or binary PII detection—those require different prompt architectures and evaluation criteria.

Do not use this prompt when the classification taxonomy is still evolving, when input text is too short to carry meaningful signal (e.g., single sentences or metadata-only records), or when classification decisions carry legal or regulatory consequences without human review. The prompt produces machine-readable labels and confidence scores, but it is a classification aid, not a compliance determination. Always pair it with validation checks for multi-label edge cases, classification drift monitoring across document types, and a human-in-the-loop review path for high-sensitivity or low-confidence outputs.

The following prompt template is designed to be pasted directly into your system instructions. It instructs the model to act as a data classification engine, analyzing unstructured text and assigning structured labels based on your organization's taxonomy. The prompt uses square-bracket placeholders that you must replace with your specific classification tiers, regulatory rules, and output format requirements before deployment. This template is built for deterministic, auditable classification—not conversational advice—and should be treated as a core component of your data governance pipeline.

textCopy
You are a Data Classification Engine. Your sole task is to analyze the provided text and assign classification labels according to the taxonomy and rules defined below. Do not engage in conversation, summarize the text, or perform any action other than classification.

## TAXONOMY
[TAXONOMY_DEFINITION]

## HANDLING RULES
[HANDLING_RULES]

## RETENTION POLICY
[RETENTION_POLICY]

## INPUT TEXT
[INPUT_TEXT]

## OUTPUT INSTRUCTIONS
Return a single JSON object with the following structure. Do not include any text outside the JSON object.
{
  "classification_tier": "[TIER_VALUE]",
  "confidence_score": 0.0,
  "rationale": "[BRIEF_JUSTIFICATION]",
  "handling_instructions": ["[INSTRUCTION_1]", "[INSTRUCTION_2]"],
  "retention_category": "[RETENTION_CATEGORY]",
  "pii_detected": [{"type": "[PII_TYPE]", "redacted": true}],
  "needs_human_review": false
}

## CONSTRAINTS
- If the text contains conflicting signals that map to multiple tiers, assign the most restrictive tier.
- If the confidence score is below [CONFIDENCE_THRESHOLD], set `needs_human_review` to true.
- If any PII is detected, set `pii_detected` fields accordingly and ensure `handling_instructions` include a data minimization directive.
- Base your classification strictly on the provided TAXONOMY and HANDLING RULES. Do not infer rules from the text itself.

To adapt this template, replace each bracketed section with your organization's specific policies. [TAXONOMY_DEFINITION] should contain your classification tiers (e.g., Public, Internal, Confidential, Restricted) with clear, mutually exclusive definitions. [HANDLING_RULES] must specify what actions are permitted for each tier, such as encryption requirements or sharing restrictions. [RETENTION_POLICY] should map tiers to data lifecycle rules. Before deploying, test the prompt against a golden dataset of pre-labeled documents to ensure the model consistently applies your taxonomy, especially for edge cases where content straddles two tiers. A common failure mode is the model defaulting to the most restrictive tier when uncertain; calibrate [CONFIDENCE_THRESHOLD] to balance over-classification against the risk of under-classification.

Integrating this classification prompt into an application requires treating it as a deterministic component within a broader data processing pipeline, not a standalone chat interaction. The prompt expects raw unstructured text as [INPUT] and a defined [CLASSIFICATION_SCHEMA] mapping labels to handling instructions and retention categories. The application layer should manage state, enforce the schema, and handle the model's output before any downstream system acts on the classification. This means the prompt is one step in a directed acyclic graph: ingest raw text, call the model for classification, validate the output, and route the document based on the validated label.

The implementation harness must enforce a strict contract. Start by constructing the [CLASSIFICATION_SCHEMA] as a JSON object in your application code, not as loose natural language. Inject it into the prompt's placeholder. After receiving the model's response, parse the JSON output and validate it against your schema definition. Check that the label field is one of your allowed enum values, that confidence is a float between 0.0 and 1.0, and that rationale is a non-empty string. If validation fails, implement a retry loop with a maximum of two additional attempts, feeding the validation error message back into the model's context as a correction request. For high-risk documents where confidence is below a defined threshold (e.g., 0.85) or the label is restricted, route the document to a human review queue instead of proceeding automatically. Log every classification decision, including the raw input hash, the model's full response, the validation result, and the final action taken, to create an audit trail for governance reviews.

When choosing a model, prioritize those with strong instruction-following and JSON mode capabilities. A smaller, faster model may be sufficient for clear-cut public and internal documents, while a more capable model should be reserved for ambiguous cases escalated from the retry loop. Do not rely solely on the model's output to enforce data handling rules; the application must use the validated classification label to programmatically control access, set retention policies in object storage, and apply PII redaction in a separate, deterministic step. The prompt's job is to analyze and label; the harness's job is to enforce the consequences of that label without ambiguity.