Recency-Aware Passage Ranking Prompt

This prompt is for RAG system builders and search ranking engineers who need to rerank retrieved passages by combining semantic relevance with temporal freshness. Use it when your retrieval pipeline returns passages with publication dates and you need an ordered evidence list that prioritizes recent, authoritative sources without discarding highly relevant older content. The ideal user is operating a production RAG system in a domain where information decays predictably—financial reports, news, regulatory filings, technical documentation, or market intelligence—and needs an auditable ranking step before answer generation or citation selection.

This prompt belongs in the reranking stage of a RAG pipeline, after initial retrieval and before answer generation or citation selection. It assumes you already have a set of candidate passages, each with a relevance score, publication date, and source identifier. The prompt produces a ranked list with per-passage recency justifications, making evidence selection auditable and debuggable. You should wire it as a post-retrieval processing step: your retriever returns N candidates, this prompt reranks them into a final ordered list, and your answer generation prompt receives the top K passages. The recency justifications double as debugging artifacts when stakeholders question why certain sources were prioritized.

Do not use this prompt when your domain has no meaningful temporal decay (classic literature, stable scientific facts, mathematical proofs), when your retrieval set lacks reliable publication dates, or when you need strict date-range filtering rather than weighted reranking. If your use case requires excluding all passages outside a fixed window, use a time-bounded evidence selection prompt instead. If you need to detect whether individual passages contain stale claims regardless of publication date, pair this with a stale evidence detection prompt. This prompt is also not a substitute for retrieval—it reranks what it receives and cannot recover passages that retrieval missed due to poor temporal filtering upstream.

Before deploying, calibrate the decay function against your domain's actual information half-life. A financial earnings use case might use a 90-day half-life, while a legal precedent use case might use years. Test with human-annotated preference pairs where annotators rank passage sets for time-sensitive queries, and measure whether the prompt's ranking correlates with human preferences. Common failure modes include over-penalizing evergreen content that happens to be old, under-penalizing recent but low-authority sources, and producing justifications that parrot the publication date without explaining why recency matters for the specific query. Start with a small eval set of 50-100 query-passage groups before scaling to production traffic.

This prompt template is designed to be dropped directly into your RAG pipeline's reranking stage. It instructs the model to evaluate each passage against both semantic relevance to the query and temporal freshness relative to the query's time sensitivity. The template uses square-bracket placeholders that you must replace with your actual data before sending to the model. Each placeholder is documented so you know exactly what shape of data to provide.

textCopy
You are a recency-aware passage ranking system. Your job is to rerank a set of retrieved passages by combining relevance to the query with temporal freshness. You will receive a query, a set of passages with metadata, and domain-specific freshness rules. You must produce an ordered list of passages with per-passage justifications.

## INPUT

### Query
[QUERY]

### Query Temporal Sensitivity
Classification: [TEMPORAL_SENSITIVITY_CLASSIFICATION]
Recommended freshness window: [FRESHNESS_WINDOW]

### Domain Freshness Rules
[DOMAIN_FRESHNESS_RULES]

### Retrieved Passages
[RETRIEVED_PASSAGES]

Each passage includes:
- passage_id: unique identifier
- text: the passage content
- publication_date: ISO 8601 date or null if unknown
- source_authority_score: 0.0 to 1.0 indicating source trustworthiness
- initial_relevance_score: 0.0 to 1.0 from the retriever

## OUTPUT SCHEMA

Return a JSON object with this exact structure:
{
  "ranked_passages": [
    {
      "passage_id": "string",
      "combined_score": 0.0,
      "relevance_score": 0.0,
      "freshness_score": 0.0,
      "recency_justification": "string explaining why this passage is temporally appropriate or not",
      "rank": 1
    }
  ],
  "ranking_methodology": "brief explanation of how scores were combined",
  "excluded_passages": [
    {
      "passage_id": "string",
      "exclusion_reason": "string"
    }
  ]
}

## CONSTRAINTS

1. For queries classified as 'real-time' or 'recent', heavily penalize passages older than the freshness window.
2. For 'historical' queries, do not penalize older passages; prioritize relevance and authority.
3. For 'time-agnostic' queries, freshness should have minimal weight.
4. If a passage has a null publication_date, assign a freshness_score of 0.5 and note the uncertainty in the justification.
5. Exclude passages that are clearly stale according to the domain freshness rules and explain why.
6. The combined_score must reflect a weighted combination of relevance_score, freshness_score, and source_authority_score.
7. All scores must be between 0.0 and 1.0.
8. Rank 1 is the best passage.

## EXAMPLES

### Example 1: Real-Time Query
Query: "What is the current stock price of AAPL?"
Temporal Sensitivity: real-time
Freshness Window: last 24 hours

Passage A: publication_date=2024-01-15, relevance=0.9, text="AAPL closed at $185.50 on January 15"
Passage B: publication_date=2024-01-16, relevance=0.7, text="AAPL trading at $187.20 in pre-market"

Expected: Passage B ranks higher despite lower relevance because Passage A is outside the 24-hour window.

### Example 2: Historical Query
Query: "What caused the 2008 financial crisis?"
Temporal Sensitivity: historical
Freshness Window: any

Passage A: publication_date=2009-03-15, relevance=0.95
Passage B: publication_date=2023-06-01, relevance=0.85

Expected: Passage A may rank higher if it has stronger relevance and authority, despite being older.

## INSTRUCTIONS

1. Read the query and its temporal sensitivity classification.
2. For each passage, compute a freshness_score based on how well its publication_date aligns with the freshness window and domain rules.
3. Compute a combined_score using relevance_score, freshness_score, and source_authority_score.
4. Sort passages by combined_score descending.
5. Write a recency_justification for each passage.
6. Identify and list any excluded passages with reasons.
7. Return the output in the exact JSON schema specified.

To adapt this template for your system, replace each bracketed placeholder with real data. [QUERY] should contain the user's original question. [TEMPORAL_SENSITIVITY_CLASSIFICATION] should be one of 'real-time', 'recent', 'historical', or 'time-agnostic', ideally produced by an upstream classification prompt. [FRESHNESS_WINDOW] should be a human-readable time range like 'last 24 hours' or 'Q4 2024'. [DOMAIN_FRESHNESS_RULES] should encode your business logic about when information becomes stale—for example, 'financial price data expires after 24 hours; earnings reports expire after one quarter.' [RETRIEVED_PASSAGES] should be a JSON array of passage objects matching the schema described in the prompt. Before deploying, validate that your upstream retriever consistently provides publication_date and source_authority_score fields, or adjust the template to match your available metadata. Test the prompt against a golden dataset of query-passage pairs with known correct rankings to calibrate the scoring weights before production use.

This prompt is designed to sit between your retrieval system and your answer generation step. It accepts a list of passages—each with a passage_id, text, publication_date, and source_authority score—along with the user's query and a domain-specific freshness window. The output is a reranked list of passages with combined relevance-freshness scores and per-passage recency justifications. The implementation harness must enforce the input schema, validate the output structure, and handle failures before the ranked list reaches downstream components.

Input Validation and Schema Enforcement. Before calling the model, validate that every passage object contains the required fields: passage_id (string), text (string), publication_date (ISO 8601 string or null), and source_authority (float 0-1). Reject or sanitize inputs where publication_date is missing or unparseable—assign a default date far in the past with a low-confidence flag rather than silently passing null. The freshness_window_days parameter must be a positive integer; clamp unreasonable values (e.g., >10 years for news queries) and log a warning. The query_timestamp should default to the current UTC time if not provided, but make this explicit in logs to avoid silent timezone drift.

Model Choice and Tool Integration. This prompt works best with models that have strong instruction-following and structured output capabilities (e.g., GPT-4o, Claude 3.5 Sonnet). For high-throughput pipelines, consider using a smaller, fine-tuned model with the same output schema. If your retrieval system already provides relevance scores, pass them as an optional retrieval_score field per passage and instruct the model to incorporate them. Do not use this prompt as a standalone tool call—it should be a synchronous step in your RAG pipeline with a timeout (suggest 10-30 seconds depending on passage count) and a circuit breaker that falls back to retrieval-order ranking if the model call fails twice.

Output Validation and Retry Logic. Parse the model's JSON output immediately. Validate that: (1) the ranked_passages array contains the same number of items as the input, (2) every passage_id in the output matches an input passage_id, (3) the combined_score values are floats between 0 and 1, and (4) the recency_justification field is a non-empty string for each passage. If validation fails, retry once with a repair prompt that includes the validation error message. If the second attempt also fails, log the failure, fall back to a deterministic time-decay reranking function (e.g., exponential decay based on publication_date and freshness_window_days), and emit an alert. Never pass unvalidated rankings to the answer generation step.

Observability and Logging. Log the full prompt input, model response, validation results, and final ranked list for every call. Include metadata: model_id, latency_ms, token_count, validation_passed (boolean), and fallback_used (boolean). This data is essential for debugging ranking quality issues and for the eval harness described in the companion evaluation rubric. If your system serves user-facing answers, store the recency_justification strings alongside citations so users can inspect why a source was prioritized. For high-stakes domains like financial intelligence or medical literature, route a sample of ranked outputs to human review and compare against the eval rubric's preference pairs to detect drift.

What to Avoid. Do not use this prompt for real-time streaming scenarios where passage sets change faster than the model's inference latency—use a deterministic time-decay function instead. Do not pass more than 50 passages in a single call; if your retrieval set is larger, pre-filter by retrieval score or source authority before invoking the prompt. Do not skip output validation even if the model has been reliable in testing—schema drift and malformed JSON are the most common production failure modes for structured-output prompts.