Domain Ontology Alignment Prompt

This prompt is designed for enterprise knowledge teams whose retrieval-augmented generation (RAG) systems depend on a formal ontology—a structured model of classes, properties, and instances. The core job-to-be-done is translating a user's natural language query into the precise, canonical terms that your retrieval index understands. Without this translation, a query for 'customer churn rate in Q3' will fail to retrieve a document titled 'Q3 Fiscal Year Subscriber Attrition Report' because the system doesn't know that 'churn' maps to the ontology class SubscriberAttrition and 'Q3' maps to the property fiscalQuarter. Use this prompt when your retrieval performance is gated by terminology mismatch and you need an auditable, scored mapping rather than an opaque query rewrite.

The ideal user is an AI engineer or search relevance lead who has access to a machine-readable ontology snippet (in OWL, RDFS, JSON-LD, or a simple YAML structure) and needs to inject it as grounding context. The prompt requires two critical inputs: the raw user query and a text representation of the relevant ontology fragment. It is not a general-purpose query rewriter. Do not use this prompt if you lack a formal ontology or controlled vocabulary—simpler synonym expansion or keyword extraction prompts will be more appropriate. It is also a poor fit for real-time consumer chat where latency and token cost preclude passing a large ontology context. The output is a structured mapping with hierarchical context (parent classes, broader terms) and confidence scores, enabling your application to programmatically decide whether to trust the mapping, narrow the retrieval scope, or fall back to a keyword search.

Before implementing, verify that your ontology is stable and versioned. If the ontology changes frequently, you must update the prompt's grounding context or risk mappings to deprecated terms. Also, plan for partial matches: the prompt includes confidence scoring precisely because real-world queries often contain terms with no exact ontological equivalent. Your application harness should define a confidence threshold below which the system falls back to a broader retrieval strategy. Start by running this prompt against a golden dataset of 50-100 known query-to-ontology mappings to calibrate your threshold and identify gaps in your ontology coverage.

This prompt template translates user-facing terminology into precise ontology concepts before retrieval. It takes a natural language query and a provided ontology snippet, then outputs aligned classes, properties, and instances with confidence scores. The prompt is designed for enterprise RAG systems where internal knowledge bases use formal ontologies that user queries rarely match without translation. Use this template when your retrieval index is organized around an ontology and you need to bridge the gap between how users ask and how documents are classified.

textCopy
You are an ontology alignment specialist. Your task is to map terms from a user query to formal concepts in a provided domain ontology.

## INPUT
User Query: [USER_QUERY]

Ontology Snippet (JSON or OWL/RDF):
[ONTOLOGY_SNIPPET]

## INSTRUCTIONS
1. Extract all domain-relevant terms and phrases from the user query.
2. For each term, find the best-matching ontology class, property, or instance from the provided ontology snippet.
3. Include hierarchical context: for each match, list parent classes up to the root.
4. Assign a confidence score (0.0 to 1.0) to each mapping.
5. Flag terms that have no clear match as UNMAPPED with a suggested gap in the ontology.
6. If a term could map to multiple concepts, list all candidates ranked by likelihood.

## OUTPUT SCHEMA
Return a JSON object with this structure:
{
  "query_terms": [
    {
      "term": "string",
      "ontology_concept": {
        "id": "string (URI or identifier)",
        "label": "string",
        "type": "class | property | instance",
        "hierarchy": ["string (root to matched concept)"],
        "confidence": 0.0
      },
      "candidates": [
        {
          "id": "string",
          "label": "string",
          "confidence": 0.0
        }
      ],
      "status": "MATCHED | PARTIAL | UNMAPPED",
      "notes": "string (explain partial matches, gaps, or disambiguation reasoning)"
    }
  ],
  "unmapped_terms": ["string"],
  "ontology_gaps": ["string (suggested missing concepts)"]
}

## CONSTRAINTS
- Only use concepts present in the provided ontology snippet. Do not invent ontology terms.
- For PARTIAL matches, explain what aspect of the term could not be mapped.
- If the ontology snippet is empty or invalid, return an error object with reason.
- Preserve the exact IDs and labels from the ontology snippet.
- Confidence below 0.5 should trigger PARTIAL or UNMAPPED status.

## EXAMPLES
[EXAMPLES]

To adapt this prompt, replace [USER_QUERY] with the raw user input and [ONTOLOGY_SNIPPET] with a JSON or RDF representation of your domain ontology. The [EXAMPLES] placeholder should contain 2-3 worked examples showing correct mappings for your domain, including at least one partial match and one unmapped term. For high-stakes domains like healthcare or finance, add a [RISK_LEVEL] constraint that requires human review when confidence scores fall below a threshold or when unmapped terms appear in safety-critical queries. Validate the output against your ontology schema before passing mapped terms to retrieval—an invalid concept ID will cause silent retrieval failures. Consider running a hallucination check that verifies every returned concept ID exists in the provided ontology snippet.

The Domain Ontology Alignment Prompt is designed to sit between the user's raw query and your retrieval system. It accepts a natural language query and a structured ontology snippet (classes, properties, instances, and hierarchical relationships) and returns a mapping of user terms to canonical ontology concepts with confidence scores. In a production RAG pipeline, this prompt is called synchronously before vector or keyword search. The output enriches the retrieval request by adding ontology-aligned query terms, metadata filters derived from ontology classes, and hierarchical context that can be used to expand or constrain the search scope.

To integrate this prompt into an application, wrap it in a service function that: (1) loads the relevant ontology snippet based on the query domain or user context; (2) constructs the prompt with the user query in [USER_QUERY] and the ontology in [ONTOLOGY_SNIPPET]; (3) calls the model with a low temperature (0.0–0.2) to maximize deterministic mapping behavior; (4) parses the JSON output and validates that every mapped concept exists in the provided ontology snippet—reject mappings where the source_concept_id or target_iri is hallucinated; (5) applies a confidence threshold (e.g., discard mappings below 0.7) before forwarding aligned terms to retrieval. For high-stakes domains such as clinical or legal ontologies, add a human review step when the prompt reports partial_match: true or when confidence scores fall in a middle band (0.5–0.8). Log every mapping request with the original query, ontology version, model response, and validation results for audit and debugging.

Common failure modes to guard against in the harness: the model may fabricate ontology terms that sound plausible but do not exist in the provided snippet—always validate against the source ontology before retrieval. The model may also over-map, assigning ontology concepts to query terms that are only tangentially related, which introduces noise into retrieval. Mitigate this by setting a strict confidence floor and by post-processing the output to remove mappings where the relationship_type is too generic (e.g., related_to without hierarchical justification). If the prompt returns an empty or malformed JSON block, implement a single retry with the same parameters and a stronger instruction to output valid JSON only. If the retry also fails, fall back to the original user query without ontology alignment and log the failure for ontology gap analysis. Model choice matters: use a model with strong instruction-following and JSON output discipline, such as GPT-4o, Claude 3.5 Sonnet, or a fine-tuned variant if your ontology is large and domain-specific.