Contextual Synonym Generation Prompt for Search

This prompt is designed for conversational search engineers who need to expand a user's current query with synonyms that respect the full session context. The core job-to-be-done is preventing context drift in multi-turn retrieval. When a user asks a follow-up question like 'What about its safety profile?', a generic synonym expander might broaden 'safety' to 'security' or 'protection', ignoring that the prior turn was about a specific medication. This prompt ingests the prior query turns, the current query, and a declared user intent to generate expansion terms that are contextually anchored. The ideal user is a developer or search relevance engineer operating a RAG system or hybrid search pipeline that supports conversational sessions and has observed that follow-up queries retrieve irrelevant documents because the expansion logic treats each query in isolation.

You should use this prompt when your system maintains a session history and you can pass at least one prior user turn as context. It is particularly valuable in domains with dense terminology overlap, such as legal, medical, or technical documentation, where the same word means different things in different contexts. The prompt also includes a relevance decay scoring mechanism, which forces the model to weight expansion terms based on their contextual fit. This scoring can be passed directly to downstream retrieval systems, allowing them to boost or penalize expanded terms relative to the original query tokens. Do not use this prompt for single-shot queries with no conversational history; a simpler synonym expansion prompt without session context will be faster, cheaper, and equally effective. It is also not a replacement for a dedicated query decomposition step when the user's single turn contains multiple independent sub-questions.

Before wiring this into production, ensure you have a reliable method for extracting and formatting the session's prior turns. The prompt expects a structured input block, not a raw transcript dump. If your session history is noisy, contains assistant responses, or includes unresolved clarifications, pre-process it to isolate the user's informational intent. The next section provides the exact prompt template you can adapt, including the required input schema and output contract. Start by copying that template and running it against a set of recorded multi-turn sessions where you observed retrieval failures to see if the context-aware expansions would have corrected the drift.

This prompt template produces a ranked list of synonyms and related terms for a user's search query, weighted by relevance to the current conversational context. Unlike generic thesaurus expansion, it considers the prior query turns, the active domain, and the user's stated intent to avoid irrelevant or contradictory expansions. Replace each square-bracket placeholder with data from your application before sending the prompt to the model. The output is structured for direct consumption by a downstream retrieval system, with per-term confidence scores and a rejection threshold for low-quality suggestions.

textCopy
SYSTEM:
You are a search query expansion engine. Your job is to generate contextually relevant synonyms, related terms, and conceptual alternatives for a user's search query. You must respect the session context, the active domain, and the user's stated intent. Do not generate generic thesaurus entries. Do not introduce terms that contradict the user's intent or prior constraints.

INPUT:
- Current query: [USER_QUERY]
- Session context (prior turns, last 5): [SESSION_HISTORY]
- Active domain: [DOMAIN]
- User intent classification: [INTENT_CLASS]
- Constraints: [CONSTRAINTS]
- Max terms to return: [MAX_TERMS]
- Minimum confidence threshold: [MIN_CONFIDENCE]

OUTPUT_SCHEMA:
{
  "original_query": "string",
  "intent_class": "string",
  "expanded_terms": [
    {
      "term": "string",
      "weight": 0.0-1.0,
      "confidence": 0.0-1.0,
      "rationale": "string (why this term is relevant given context)",
      "source": "session_context | domain_knowledge | conceptual_inference"
    }
  ],
  "rejected_terms": [
    {
      "term": "string",
      "reason": "string (why rejected: context_mismatch | intent_conflict | low_confidence | domain_irrelevant)"
    }
  ],
  "context_drift_flag": true | false,
  "context_drift_note": "string (if flagged, explain why the query appears to shift topic from session context)"
}

INSTRUCTIONS:
1. Analyze the current query against the session context to detect topic drift.
2. Generate synonyms and related terms that are relevant to the active domain and user intent.
3. Weight terms by their estimated retrieval value (higher = more likely to surface relevant documents).
4. Assign confidence scores based on how certain you are the term is appropriate.
5. Reject terms below the minimum confidence threshold and explain why.
6. Flag context drift if the current query appears to shift topic from prior turns.
7. Return ONLY valid JSON matching the output schema. No commentary outside the JSON.

Adapt this template by adjusting the session history window size based on your application's conversation length. For short sessions, include all prior turns. For long sessions, summarize earlier turns or use a sliding window of the last 5-10 exchanges. The domain field should be populated from your application's routing or configuration layer—do not rely on the model to infer it. If your retrieval system uses different weighting schemes, modify the weight field description to match your scoring conventions. For production deployments, always validate the output JSON against the schema before passing terms to your retrieval backend, and log any instances where the context_drift_flag is true for human review.

Integrating the contextual synonym generation prompt into a search pipeline requires treating it as a pre-retrieval expansion step that consumes session state and produces structured, auditable term lists. The prompt expects a current query, a session history window, and an optional domain context block. The output should be a JSON object containing an array of expanded terms, each with a relevance score, a source rationale (e.g., 'prior turn reference', 'domain synonym', 'conceptual alternative'), and a drift flag indicating whether the term may shift the original intent. Wire this prompt as a synchronous call before the main retrieval step, with a strict timeout (e.g., 500ms) to avoid adding unacceptable latency. If the call fails or times out, the system must fall back to the original query without expansion—never block the user on a synonym generation failure.

Validation is critical because a bad expansion silently degrades search quality. Implement a post-generation validator that checks: (1) the output parses as valid JSON matching the expected schema, (2) no term is an exact duplicate of the original query, (3) relevance scores are within [0.0, 1.0], (4) drift flags are boolean, and (5) the total number of terms does not exceed a configured maximum (e.g., 10). Reject and retry once if validation fails, logging the failure reason and the raw model output for debugging. For session context, maintain a sliding window of the last N turns (start with 3) and pass them as a structured array of {role, query, timestamp} objects. Include a context staleness check: if the most recent prior turn is older than a configurable threshold (e.g., 5 minutes), clear the session context to prevent stale references from polluting the expansion. Log every expansion call with the original query, session window size, generated terms, and whether the fallback path was triggered.

Model choice matters here. Use a fast, cost-efficient model for this pre-retrieval step—GPT-4o-mini, Claude Haiku, or an equivalent small model—since the task is classification-like and latency-sensitive. Do not use a large reasoning model for synonym expansion. If your domain requires high precision (e.g., legal or medical search), add a human-review queue for expansions flagged with high drift scores above a threshold (e.g., 0.7). For evaluation, maintain a golden set of 50–100 query-and-context pairs with expected synonym sets, and run regression tests on every prompt or model change. Measure precision (how many generated terms are relevant), recall (how many expected terms were generated), and drift false-positive rate. Set a release gate: precision must stay above 0.85 and drift false-positive rate below 0.05. If the prompt underperforms, check whether the session window is too large (causing context pollution) or the domain context block is too broad (causing generic rather than targeted synonyms).