Irrelevant Passage Detection Prompt for RAG

This prompt is designed for production RAG pipeline engineers who need to programmatically filter irrelevant or noisy passages from a retrieval set before those passages reach the answer generation step. The core job-to-be-done is reducing hallucination and improving answer quality by ensuring that only contextually relevant information is packed into the model's context window. The ideal user is an engineer or AI architect who already has a working retrieval system (vector, hybrid, or keyword) and observes that retrieved results frequently contain off-topic, outdated, or tangentially related content that degrades downstream answers. You should use this prompt when you need a structured, auditable filtering step that produces not just a binary relevant/irrelevant label, but also a clear reason for exclusion, which is essential for debugging retrieval quality and calibrating your pipeline's precision-recall trade-off.

This prompt is not a replacement for retrieval itself. It operates on an already-retrieved candidate set. If your retrieval system is returning completely wrong results due to poor indexing, embedding model mismatch, or broken metadata filters, fix the retrieval layer first—this prompt cannot rescue fundamentally broken search. It is also not a substitute for a dedicated cross-encoder reranker when you need fine-grained relevance ordering; this prompt focuses on hard exclusion decisions with explainability. Use it when you need a gatekeeping step that removes noise before context assembly, especially in high-stakes domains where irrelevant context can cause confident but incorrect answers. The prompt requires you to provide the original user query and the candidate passages as input. It works best when passages are self-contained chunks (not fragments requiring surrounding context to interpret).

Avoid this prompt when latency is your primary constraint and you can tolerate some noise in the context window—adding an LLM call for filtering introduces overhead that may not be justified for low-risk, high-tolerance applications. Also avoid it when your passages are extremely short (e.g., single-sentence chunks) where relevance is ambiguous without broader document context; in those cases, consider expanding chunk size or using a document-level relevance signal instead. For regulated or safety-critical domains, always pair this prompt's output with a human review step for excluded passages to ensure no critical evidence is silently dropped. The next section provides the copy-ready prompt template you can adapt and wire into your filtering pipeline.

This prompt template is designed to be dropped into a RAG pipeline after retrieval and before answer generation. It takes a user query and a set of retrieved passages, then flags each passage as relevant or irrelevant with a specific reason for exclusion. The template uses square-bracket placeholders that you replace with your actual query, passages, and output schema. It is structured to enforce strict JSON output, require evidence-based reasoning, and handle edge cases like borderline relevance or insufficient context. The prompt works best when passages are already chunked and deduplicated, and when you have a clear definition of what 'relevant' means for your domain.

textCopy
You are a passage relevance classifier for a RAG system. Your job is to evaluate each retrieved passage against the user query and flag irrelevant passages that should be excluded before answer generation.

## INPUT
**User Query:** [QUERY]
**Retrieved Passages:** [PASSAGES]

## RELEVANCE CRITERIA
A passage is RELEVANT if it:
- Directly addresses or partially answers the user query
- Provides factual context needed to answer the query
- Contains entities, dates, definitions, or constraints mentioned in the query
- Offers supporting evidence, examples, or counterpoints related to the query

A passage is IRRELEVANT if it:
- Discusses a different topic, entity, or domain entirely
- Contains only generic boilerplate, navigation text, or metadata
- Is too vague or tangential to contribute to an answer
- Duplicates information already present in other relevant passages without adding new detail

## CONSTRAINTS
[CONSTRAINTS]

## OUTPUT SCHEMA
Return a JSON object with this exact structure:
```json
{
  "passages": [
    {
      "passage_id": "string",
      "relevance": "relevant|irrelevant|borderline",
      "reason": "string explaining the decision with specific evidence from the passage and query",
      "confidence": "high|medium|low"
    }
  ],
  "summary": {
    "total_passages": number,
    "relevant_count": number,
    "irrelevant_count": number,
    "borderline_count": number,
    "filtering_notes": "string summarizing any patterns or concerns"
  }
}

EXAMPLES

[EXAMPLES]

RISK LEVEL

[RISK_LEVEL]

INSTRUCTIONS

1. Evaluate each passage independently against the query
2. For irrelevant passages, cite specific content that fails the relevance criteria
3. For borderline passages, explain what information is missing or ambiguous
4. If confidence is low for any decision, note what additional context would help
5. Do not generate an answer to the query. Only classify passages.

To adapt this template for your pipeline, replace the placeholders with concrete values. For [QUERY], insert the user's original question. For [PASSAGES], provide a JSON array of objects with passage_id and text fields. The [CONSTRAINTS] placeholder should contain domain-specific rules, such as 'Exclude passages older than 2023' or 'Only consider passages from official documentation.' The [EXAMPLES] placeholder is critical for few-shot performance: include 2-3 labeled examples showing clear relevant/irrelevant/borderline decisions with reasoning. Set [RISK_LEVEL] to high if filtering errors could cause downstream harm, which triggers stricter confidence thresholds and human review requirements. If your domain has a taxonomy of irrelevance types (e.g., wrong_entity, stale_content, too_vague), add those as an enum in the output schema. Always validate the JSON output before passing filtered passages to the answer generation step. If the model returns malformed JSON or missing fields, use a repair prompt or fallback to including all passages with a warning log.