Recency-Boosted Reranking Prompt

This prompt is designed for search ranking engineers and RAG pipeline architects who need to rerank a set of retrieved passages by balancing semantic relevance with temporal freshness. The core job-to-be-done is producing a final ordered list where a document's value is a function of both how well it answers the query and how recently it was published. This is critical in domains where information decays rapidly, such as financial data, breaking news, regulatory filings, and competitive intelligence. The ideal user is someone who has already completed an initial retrieval step and has a list of candidate passages, each with a pre-computed relevance score and a reliable publication timestamp.

You should use this prompt when your application domain penalizes stale information and you have access to structured metadata, specifically a publication_date for each passage. The prompt is configurable: you can specify the decay function (e.g., exponential, linear), the half-life parameter, and the time reference point. This makes it adaptable to different rates of information churn. For example, a financial news application might use a half-life of 24 hours, while a regulatory filing system might use a half-life of 90 days. The prompt expects a structured input, typically a JSON array of objects, each containing a passage_id, content, relevance_score, and publication_date. The output is a reranked list with a new combined_score that explicitly shows the freshness penalty applied.

Do not use this prompt when all evidence is effectively timeless, such as historical facts, mathematical proofs, or foundational scientific principles. In these cases, applying a time-decay function would introduce noise and degrade ranking quality by penalizing authoritative older sources. This prompt is also unsuitable if publication dates are unavailable, unreliable, or not in a parseable format. It assumes you have already solved the upstream problem of date extraction and normalization. Finally, this prompt is a reranking step, not a retrieval step; it will not fix a fundamentally broken retrieval pipeline that fails to surface relevant documents in the first place. If your initial retrieval set is already stale or irrelevant, reranking with a recency boost will only amplify the problem by promoting recent but off-topic documents.

This prompt template is designed to be inserted directly into your reranking pipeline, immediately after initial retrieval and before answer generation. It instructs the model to re-score a list of candidate passages by blending their original relevance score with a configurable recency penalty. The template uses square-bracket placeholders for all dynamic inputs—your retrieval results, your chosen decay function, and your domain-specific half-life parameter. Copy the block below, replace the placeholders with your data, and wire the output into your downstream evidence selector.

textCopy
You are a precision reranking engine. Your task is to reorder a list of retrieved passages by combining their initial relevance score with a time-decay weighting that penalizes older information.

INPUT PASSAGES (JSON array):
[PASSAGES]

CURRENT REFERENCE TIMESTAMP: [REFERENCE_TIMESTAMP]

DECAY FUNCTION: [DECAY_FUNCTION]
HALF-LIFE: [HALF_LIFE]

INSTRUCTIONS:
1. For each passage, extract the publication or last-updated date. If a passage has no discernible date, assign it a default age of [DEFAULT_AGE] days.
2. Calculate the age of the passage in days relative to the reference timestamp.
3. Apply the specified decay function using the given half-life to compute a freshness weight between 0 and 1.
4. Compute a combined score: combined_score = [RELEVANCE_WEIGHT] * relevance_score + [FRESHNESS_WEIGHT] * freshness_weight.
5. Return the passages sorted by combined_score in descending order.

OUTPUT SCHEMA:
Return a JSON object with a single key "reranked_passages" containing an array of objects. Each object must have:
- "passage_id": string
- "original_relevance_score": number
- "passage_date": string (ISO 8601 or null)
- "age_days": number
- "freshness_weight": number
- "combined_score": number
- "passage_text": string (the original text, truncated to [MAX_PASSAGE_LENGTH] characters if necessary)

CONSTRAINTS:
- Do not alter the original passage text beyond truncation.
- If two passages have identical combined scores, preserve their original relative order.
- If a passage date is in the future relative to the reference timestamp, set age_days to 0.
- Output only the JSON object. No surrounding text.

To adapt this template, start by defining your decay function. Common choices are exponential (weight = e^(-age * lambda)), linear (weight = max(0, 1 - age / max_age)), or logarithmic (weight = 1 / (1 + log(1 + age))). The half-life parameter controls how quickly relevance decays; for financial news, a half-life of 1 day is common, while for legal documents, 365 days may be appropriate. The RELEVANCE_WEIGHT and FRESHNESS_WEIGHT parameters let you tune the trade-off—a 0.7/0.3 split favors semantic match, while 0.3/0.7 prioritizes recency. Always log the raw scores alongside the combined scores so you can audit the reranker's behavior in production.

Before deploying, validate the output against a golden dataset of query-passage pairs with known ideal rankings. Check for edge cases: passages with missing dates, passages dated in the future, and queries where all passages are equally stale. If your use case involves regulated content, route passages flagged with age_days exceeding a safety threshold to a human review queue before they reach end users. Do not treat this prompt as a black box—monitor the distribution of combined scores over time and set alerts for sudden shifts that may indicate a broken date extraction step upstream.

The Recency-Boosted Reranking Prompt is not a standalone module; it sits between your initial retrieval step and your final answer generation or evidence selection step. In a typical RAG pipeline, you first retrieve a candidate set of passages (e.g., top-50 from a vector store or hybrid search). You then call this prompt with the original query, the candidate passages with their publication dates, and your configured decay parameters. The prompt returns a reranked list with combined relevance-freshness scores. You then take the top-N reranked passages and pass them to your answer generation prompt. This architecture keeps the reranking logic isolated and testable without coupling it to retrieval or generation code.

For production wiring, implement a thin service wrapper around the LLM call that handles input validation, retries, and output parsing. Validate that every candidate passage includes a publication_date in ISO 8601 format before calling the prompt; if dates are missing, either exclude the passage or apply a configurable default penalty. Parse the model's output against a strict JSON schema that expects an ordered array of objects with passage_id, relevance_score, freshness_score, combined_score, and rerank_justification fields. If parsing fails, retry once with a repair prompt that includes the raw output and the expected schema. Log every reranking call with the query, decay function parameters, input passage count, output passage count, and latency for later analysis. For high-stakes domains like financial intelligence, add a human review step when the gap between the top-ranked passage's publication date and the query's required freshness window exceeds a threshold.

A/B testing decay functions against user satisfaction metrics is the primary way to tune this prompt for your domain. Instrument your application to track which decay function and half-life parameters were used for each user session. Define a user satisfaction metric—such as answer thumbs-up rate, task completion rate, or explicit freshness feedback—and compare performance across decay function variants. Start with an exponential decay function and a half-life of 7 days for news domains or 90 days for financial reporting. Run A/B tests with at least 1,000 queries per variant before drawing conclusions. Avoid over-optimizing on offline ranking metrics alone; what looks good in a spreadsheet may not match user perception of freshness. If you observe that users consistently prefer results with higher freshness scores even when relevance drops slightly, consider increasing the freshness weight parameter in your combined scoring formula.

Model choice matters for this prompt. Use a model with strong instruction-following and structured output capabilities, such as GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro. Avoid smaller or older models that may struggle with the numerical scoring and justification requirements. If latency is critical, consider using a faster model for the initial retrieval step and reserving the more capable model for reranking only the top-20 candidates. Cache reranking results when the same query and candidate set appear within a short time window, but invalidate the cache when any candidate's publication date changes or when the decay function parameters are updated. For cost control, set a maximum token budget per reranking call and truncate long passages to the first 500 tokens before sending them to the prompt.