Cross-Lingual Compound Noun Decomposition Prompt

This prompt is designed for search engineers and RAG developers who need to improve retrieval recall when users query in one language but relevant documents exist in another, and the source language uses compound nouns extensively. Germanic languages (German, Dutch, Swedish, Danish, Norwegian), agglutinative languages (Finnish, Turkish, Hungarian), and technical domains in any language frequently concatenate multiple concepts into single tokens. A German user searching for 'Kinderbetreuungseinrichtung' (childcare facility) will miss English documents that mention 'childcare facility' or 'daycare center' unless the compound is decomposed into its constituent parts and translated into multi-word phrases in the target retrieval language. Direct translation alone often fails because the compound noun does not exist as a single token in the target language's index, and naive translation may produce a single unnatural word that retrieves nothing.

Use this prompt when your retrieval pipeline includes a Germanic or agglutinative source language and a target index language that prefers multi-word phrases. The prompt expects a source compound noun, the source language, and the target retrieval language as inputs. It returns a structured decomposition showing the individual morphemes, their meanings, and one or more equivalent multi-word phrases in the target language suitable for keyword, BM25, or dense retrieval queries. Do not use this prompt for languages that do not form compound nouns (e.g., Romance languages like Spanish or French), for single-word non-compound queries, or when the compound noun already has a direct dictionary translation in the target language's index. The prompt is a pre-retrieval expansion step, not a replacement for query translation or synonym expansion.

Before deploying this prompt in production, validate that your retrieval index actually contains the multi-word phrases the decomposition produces. A common failure mode is generating correct decompositions that still return zero results because the target corpus uses different terminology. Pair this prompt with a query relaxation fallback that broadens terms if the initial decomposition yields no matches. For high-stakes applications such as legal or medical retrieval, always log the decomposition output alongside the original query for auditability, and consider human review of the decomposition mapping for domain-specific compound terms that may have non-compositional meanings. The next section provides the copy-ready prompt template you can adapt for your language pair and retrieval backend.

This template is designed to be copied directly into your prompt management system or codebase. It accepts a compound noun in a source language (such as German, Dutch, or Finnish) and decomposes it into its constituent semantic parts. It then generates equivalent multi-word phrases in the target retrieval language that capture the same meaning, improving match rates against keyword and vector indexes that would otherwise miss the compound form. The prompt includes placeholders for the input term, source and target language codes, domain context, and output format constraints.

textCopy
You are a linguistic retrieval specialist. Your task is to decompose a compound noun from a source language into its semantic components and generate equivalent multi-word retrieval phrases in a target language.

INPUT:
- Source compound noun: [COMPOUND_NOUN]
- Source language (ISO 639-1): [SOURCE_LANG]
- Target retrieval language (ISO 639-1): [TARGET_LANG]
- Domain context (optional): [DOMAIN_CONTEXT]

INSTRUCTIONS:
1. Decompose the source compound noun into its constituent semantic parts. Identify the head noun and any modifiers.
2. For each part, provide a brief gloss in English to confirm your decomposition.
3. Generate 3-5 equivalent multi-word phrases in the target language that capture the full meaning of the original compound. Prioritize phrases that are natural in the target language and likely to appear in indexed documents.
4. If the compound has multiple plausible interpretations, generate phrases for each interpretation and flag them.
5. If [DOMAIN_CONTEXT] is provided, bias your target phrases toward terminology used in that domain.

OUTPUT_SCHEMA:
{
  "source_compound": "string",
  "source_language": "string",
  "target_language": "string",
  "decomposition": [
    {
      "part": "string",
      "gloss_en": "string",
      "role": "head|modifier"
    }
  ],
  "interpretations": [
    {
      "interpretation_label": "string",
      "target_phrases": ["string"],
      "is_primary": true|false
    }
  ],
  "confidence": "high|medium|low",
  "notes": "string or null"
}

CONSTRAINTS:
- Do not produce a literal word-for-word translation. Generate phrases that a native speaker would use in a search query or document.
- If the compound is already a common term with a standard translation, include that standard form as the primary phrase.
- Set confidence to "low" if the decomposition is ambiguous or the domain is unknown. Flag the ambiguity in notes.
- Return ONLY valid JSON. No markdown, no commentary outside the JSON object.

To adapt this template, replace the square-bracket placeholders with your application's runtime values. The [DOMAIN_CONTEXT] field is optional but strongly recommended for specialized corpora—a medical compound like Herzkranzgefäßverengung requires different target phrases in a cardiology index than in a general-health index. For production use, validate the output JSON against the schema before sending phrases to your retrieval backend. If the confidence field returns low, route the output for human review or fall back to a direct translation query. When integrating with a RAG pipeline, pass each generated phrase as a separate query variant to your hybrid or multi-query retrieval step to maximize recall.

This prompt operates as a pre-retrieval transformation step in a multilingual RAG pipeline. It receives a user query in a source language (typically German, Dutch, Finnish, or another compound-heavy language) and produces a structured decomposition that includes the original compound, its constituent parts, and a target-language multi-word phrase for retrieval. The prompt should be called before any vector or keyword search against the target-language index. Its output is not shown to the user; it is consumed by the retrieval layer to generate expanded query variants.

Wire the prompt into your query processing chain immediately after language detection and before retrieval dispatch. The input [COMPOUND_NOUN] should be extracted from the user's query using a lightweight parser or a prior LLM call that identifies compound candidates. The [TARGET_LANGUAGE] parameter must match the language of your retrieval index. On the output side, validate the JSON structure strictly: confirm that decomposed_parts is a non-empty array of strings, that target_phrase is a non-empty string, and that confidence is a float between 0.0 and 1.0. If validation fails, retry once with the same input and a stronger constraint instruction appended to the prompt. If the retry also fails, log the failure, skip decomposition for that compound, and fall back to a direct translation of the original compound using a simpler translation prompt. Log every decomposition attempt with the input compound, output structure, validation result, and retrieval backend used, so you can trace recall gaps back to decomposition failures.

For model choice, a mid-tier model like GPT-4o-mini or Claude Haiku is sufficient for this task; the linguistic knowledge required is well-covered by these models and latency matters in a retrieval pipeline. Set temperature to 0.0 or near-zero to maximize deterministic output. If your system handles multiple compound nouns per query, batch them into a single prompt call with an array input to reduce round trips, but keep the batch size under 10 to avoid output truncation. Do not use this prompt for languages that do not form closed compounds (like English or Romance languages); the model may hallucinate decompositions where none exist. Add a pre-check that the source language is in a configured allowlist of compound-forming languages before invoking this prompt.