RETRIEVAL-AUGMENTED GENERATION WITH ESTIMATION OF SOURCE RELIABILITY

## Abstract

Abstract Retrieval-augmented generation (RAG) addresses key limitations of large language models (LLMs), such as hallucinations and outdated knowledge, by incorporating external databases. These databases typically consult multiple sources to encompass up-to-date and various information. However, standard RAG methods often overlook the heterogeneous source reliability in the multi-source database and retrieve documents solely based on relevance, making them prone to propagating misinformation. To address this, we propose Reliability-Aware RAG (RA-RAG) which estimates the reliability of multiple sources and incorporates this information into both retrieval and aggregation processes. Specifically, it iteratively estimates source reliability and true answers for a set of queries with no labelling. Then, it selectively retrieves relevant documents from a few of reliable sources and aggregates them using weighted majority voting, where the selective retrieval ensures scalability while not compromising the performance. We also introduce a benchmark designed to reflect real-world scenarios with heterogeneous source reliability and demonstrate the effectiveness of RA-RAG compared to a set of baselines.

## 1 Introduction

Large language models (LLMs) have demonstrated remarkable capabilities across various tasks but are often limited by hallucinations and a lack of access to real-time information. Retrieval-augmented generation (RAG) offers a promising solution by integrating external databases, allowing LLMs to access more accurate and up-to-date information (Guu et al., ; Lewis et al., ). However, these databases often consist of content from multiple sources with varying levels of reliability, which can make RAG systems vulnerable to misinformation from unreliable sources. Standard RAG methods retrieve documents based on only relevance to the query, without considering the accuracy or trustworthiness of the information retrieved. As a result, RAG systems are prone to propagating misinformation. This issue is exacerbated by the advances of LLMs, which enable a massive production of plausible yet false documents and disables identifying the credibility of documents by linguistic features (Menczer et al., ; Augenstein et al., ; Hong et al., ; Zou et al., ; Shafran et al., ; Chaudhari et al., ; Chen & Shu, ).

Several recent efforts have sought to improve the robustness of RAG systems against misinformation (Pan et al., ; Weller et al., ; Xiang et al., ; Deng et al., ; Pan et al., ). However, these approaches have notable limitations. Deng et al. () use LLMs to evaluate document reliability based on their internal knowledge, which is ineffective when LLMs indeed need to consult with external knowledge. Pan et al. (); Weller et al. (); Xiang et al. () use counting-based methods such as majority voting (MV) or selecting responses that exceed a certain threshold.
However, these methods are effective only when the portion of misinformation in the retrieved documents is minor, overlooking the heterogeneity in source reliability. Pan et al. () propose a heuristic estimation, which categorizes the source reliability into three groups (low, medium, high) based on a common reputation of the source. To learn how to aggregate responses according to source reliability, they generate labeled dataset to fine-tune LLMs. However, the reputation of sources, particularly social media and blogs, is often unclear and susceptible to manipulation. Additionally, a simple three-level credibility score cannot capture subtle differences in reliability and requires additional training to utilize this information.

To overcome these limitations, we formalize a multi-source RAG framework based on weighted majority voting (WMV) that distinguishes between different sources in the database and integrates information from multiple sources given their reliability. However, as it is hard to know the source reliability in advance, we introduce Reliability-Aware RAG (RA-RAG), an effective method that estimates the reliability of each source and uses this information to guide the retrieval and aggregation process. RA-RAG operates in two stages illustrated in Figure 1. The first stage focuses on estimating source reliabilities for a set of queries with no labelings. Specifically, we devise an iterative reliability estimation that alternates estimating the true answers and the reliability of each source. In the second stage, RA-RAG aims at reliable and efficient inference, which aggregates documents from sources given the estimated source reliability while ensuring computational scalability even with numerous sources without compromising performance. To do so, we propose WMV with $\kappa$-reliable and relevant source selection ($\kappa$-RRSS), in which RA-RAG consults with only a small number of selective sources that are reliable with relevant documents.

RA-RAG also addresses two specific issues inherent in RAG systems: misalignment of responses, where the model generates answers based on internal knowledge rather than retrieved documents, and response variation, where semantically identical answers are phrased differently. These issues can hinder both the aggregation of responses and the estimation of source reliability. To overcome these challenges, RA-RAG incorporates a misalignment filtering mechanism to detect and exclude hallucinated responses, and a keyword-based system prompt to regularize response variation.

To evaluate the effectiveness of RA-RAG, we develop a realistic benchmark of multi-source RAG with heterogeneous source reliability, reflecting the complexity of real-world scenarios. Our benchmark contrasts with previous works (Weller et al., ; Xiang et al., ; Deng et al., ; Pan et al., ) that relied on setups with artificially injected misinformation into retrieved documents, as we construct an environment where the database consists of multiple sources with heterogeneous reliability. Our experimental results show that RA-RAG consistently outperforms various baselines, highlighting its robustness and effectiveness in accurately aggregating information from multiple sources.

Figure: Figure 1: Overview of the RA-RAG framework. In the first stage, RA-RAG iteratively estimates the reliability of each source $v_{i}$ for $i\in[N]$ based on estimated true answers $\hat{y}^{j}$ for each question $j$, as outlined in equation (3) and (4). Based on the estimated reliability, in the second stage, the retriever selects $\kappa$ sources through the Reliable and Relevant Source Selection ($\kappa$-RRSS) process, detailed in Section 3.4. The final answer is determined using a weighted majority voting process, with the weights derived from the estimated reliability.
Refer to caption: x1.png

We defer an extensive discussion of related works to Appendix A,
while we summarise our main contributions as follows:

- •
We formalize the multi-source RAG (Section 2) and propose an effective approach, called RA-RAG (Section 3). It estimates the source reliability without additional labelings via the iterative reliability estimation (Section 3.3). Then, based on the estimated reliability, it efficiently retrieves reliable and relevant documents by $\kappa$-RRSS and robustly aggregates them with WMV (Section 3.4).
- •
We also address the inherent issues of RAG systems: variation and misalignment in the generated responses. To mitigate the issues, we devise the keyword-based system prompt (Section 3.1) and the misalignment filtration (Section 3.2).
- •
We construct the realistic benchmark of the multi-source RAG frameworks with diverse source reliability, which allows us to evaluate and analyze multi-source RAG systems (Section 4). Our code and datasets will be released.
- •
Our experimental results demonstrate that RA-RAG consistently outperforms a number of baselines, showcasing its robustness and effectiveness in accurately aggregating information from multiple sources, even in conflicting and unreliable information (Section 5).

## 2 Problem Formulation

In this section, we formally describe the problem of retrieval-augmented generation (RAG) with a multi-source database. We introduce the standard RAG system in Section 2.1 and outline the multi-source RAG framework in Section 2.2, followed by a discussion of key challenges in Section 2.3.

### 2.1 Retrieval-Augmented Generation (RAG)

A typical RAG system generates a response $\hat{y}$ by retrieving relevant information from a database $\mathcal{D}$ using a retrieval mechanism $\mathcal{R}$, followed by a language model $\mathcal{G}$ to generate the final response. To be specific, consider a closed-ended query $q$ associated with a true answer $y$. Retriever $\mathcal{R}$ selects the top-$K$ most relevant documents from database $\mathcal{D}$ based on a similarity measure between query $q$ and each document $t\in\mathcal{D}$. The set of retrieved documents is denoted by $\mathcal{R}(q,\mathcal{D})$. Using the retrieval result $\mathcal{R}(q,\mathcal{D})$ and a system prompt $\mathcal{P}$, language model $\mathcal{G}$ generates a response $\hat{y}$, which can be represented as follows:
$\hat{y}=\mathcal{G}(q,\mathcal{R}(q,\mathcal{D}),\mathcal{P})\;.$
In this framework, system prompt $\mathcal{P}$ guides language model $\mathcal{G}$ to generate response $\hat{y}$ based on the retrieval result $\mathcal{R}(q,\mathcal{D})$. A critical limitation arises when the retrieved documents come from unreliable sources, as the similarity measure used in retrieval does not account for the truthfulness or reliability of the information. This becomes particularly problematic when database $\mathcal{D}$ includes documents from multiple sources with different levels of reliability, such as news articles, Wikipedia, or social media. Such a multi-source database is often necessary to cover up-to-date and diverse content. Although prompts can attempt to filter out unreliable information based on linguistic features, this is not always reliable. With the growing sophistication of language models, generating plausible yet false information—such as fake news—has become easier (Menczer et al., ; Augenstein et al., ). This underscores the need for additional mechanisms to assess the reliability of retrieved documents, beyond their mere relevance to the query.

### 2.2 Multi-Source RAG

To address the vulnerability to misinformation in retrieval, we propose a multi-source RAG framework that explicitly distinguishes between the sources of documents. Let $N$ be the number of distinct sources contributing to database $\mathcal{D}$. We partition the database as $\mathcal{D}=\bigcup_{i=1}^{N}\mathcal{S}_{i}$, where $\mathcal{S}_{i}$ is the set of documents originating from source $i\in[N]$. Such a partition of dataset $\mathcal{D}$ enables the system to account for the reliability of each document’s source, based on weighted majority voting (WMV).
For a given query $q$, let $\tilde{y}_{i}=\mathcal{G}(q,\mathcal{R}(q,\mathcal{S}_{i}),\mathcal{P})$ represent the response generated using documents exclusively from source $i$. Once the probability that a retrieved document from source $i$ is correct is estimated as $v_{i}$, and a set of candidate responses $\mathcal{M}$ is obtained from $\tilde{y}_{i}$’s, we can apply WMV to aggregate the responses:

$$ $\displaystyle\hat{y}=\operatorname*{arg\,max}_{u\in\mathcal{M}}\sum_{i\in[N]}v _{i}\mathbbm{1}(\tilde{y}_{i}=u)\;.$ (1) $$

If all sources are assumed to have equal reliability, this reduces to majority voting (MV) that selects the most consensus among $\tilde{y}_{i}$’s. However, WMV is superior to MV when the reliability of each source $v_{i}$ can be properly estimated. Hence, the key components in a multi-source RAG framework are (i) the reliability estimation for $v_{i}$’s and (ii) the response aggregation of $\tilde{y}_{i}$’s based on WMV.

### 2.3 Challenges in Multi-source RAG

To develop an effective mechanism for reliability estimation and response aggregation in the multi-source RAG framework, we need to address four key challenges: (i) response variations, (ii) misaligned response, (iii) limited access to ground truth, and (iv) scalability in the number of sources.

Response variations.
Even when focusing on closed-ended queries, language models often generate semantically identical answers with paraphrasing, complicating the application of weighted majority voting (WMV). For example, in response to the question, “What is the largest planet in our solar system?”, the model might generate “The largest planet in our solar system is Jupiter” or “Jupiter is the largest planet in our solar system.” These responses convey the same meaning, but if treated as different outputs, they can reduce the effectiveness of WMV. Therefore, techniques for normalizing or aligning semantically equivalent responses are essential to ensure that the aggregation process accurately reflects consensus.

Misaligned responses.
Since the reliability of sources is inferred based on the outputs generated by the language model, the model must generate responses strictly from the documents retrieved from each source. However, language models often produce hallucinations or responses influenced by their internal knowledge, particularly when dealing with complex queries or ambiguous contextual information (Kaddour et al., ; Ji et al., ; Xie et al., ; Kortukov et al., ; Xu et al., ). These misaligned responses complicate the reliability estimation process by distorting the relationship between the response and the quality of the retrieved documents. Thus, it is necessary to develop a filtering mechanism to exclude responses that do not rely on the retrieved documents, ensuring that the answers are grounded in the provided information.

Limited access to ground truth.
A straightforward reliability estimation can be conducted with the true labels for a number of queries. However, acquiring the labels is costly and time-intensive, particularly when dealing with unverified, up-to-date information. Hence, we consider a set of queries with no labels and devise an iterative algorithm that alternates between estimating both the reliability of sources and the true answers (Section 3.3).

Scalability in the number of sources.
In a multi-source RAG framework, retrieving documents from a large number of sources can lead to significant computational overhead. Generating responses $\tilde{y}_{i}$ for every source may become impractical as the number of sources increases. To ensure scalability in real-world applications, it is critical to use strategies that reduce computational costs, such as optimizing retrieval processes or limiting the number of sources considered during inference. Effective solutions will enable multi-source RAG systems to scale efficiently without compromising performance (Section 3.4).

## 3 Reliability-Aware Retrieval-Augmented Generation (RA-RAG)

To mitigate the impact of misinformation on RAG systems, we propose the Reliability-Aware Retrieval-Augmented Generation (RA-RAG), which addresses the challenges of the multi-source RAG framework outlined in Section 2.3.
RA-RAG operates in two stages: (i) iterative reliability estimation (Section 3.3) and (ii) reliable and efficient inference (Section 3.4). In the first stage, the iterative algorithm given a set of queries with no labels estimates the reliability of sources before deploying the RAG system. In the second stage, a WMV mechanism combined with $\kappa$-reliable and relevant source selection ($\kappa$-RRSS) uses the estimated reliability to retrieve documents and effectively aggregate the information. In advance of describing the two stages of RA-RAG, we first present two common components used for both stages: keyword-based system prompt (Section 3.1) and misalignment filtration (Section 3.2). They are mainly to address the problems of variation and misalignment in the language model’s responses. The detailed algorithm of RA-RAG can be found in Appendix B, and the code will be distributed.

### 3.1 Keyword-based System Prompt

Even for closed-ended queries that elicit simple answers, such as “What is the largest planet in our solar system?”, the language model often generates responses of the same semantic meaning but in various forms. This decreases the effectiveness of response aggregation with WMV and thus disturbs the reliability estimation as well. To address this, we employ a system prompt to ensure that the language model generates keyword-based answers without unnecessary details. For example, the keyword-based response to the aforementioned query would be “Jupiter”, rather than a more detailed response, “Jupiter is the largest planet in our solar system.”. In addition, the prompt also guides the language model to say IDK (which stands for “I don’t know” and indicates the abstention) when irrelevant documents are retrieved. The detailed prompt is provided in Appendix G. This keyword-based answer allows us to effectively aggregate the LLMs response for WMV while reducing hallucinations to generate responses irrelevant to retrieval results. We note that Xiang et al. () use a post-processing method with the spaCy library (Honnibal et al., ) to extract keywords like adjectives, adverbs, and other elements from LLM outputs. However, we observe that prompt engineering alone can effectively generate the desired keyword-based outputs without the need for additional processing. The detailed experimental results are provided in Appendix E.

### 3.2 Misalignment Filtration

Although the system prompt directs the language model to generate $\tilde{y}_{i}$ based on the retrieval result $\mathcal{R}(q,\mathcal{S}_{i})$, responses irrelevant to the retrieval result
are often generated. This can distract the reliability estimation and WMV, as discussed in Section 2.3. To mitigate this issue, we further employ a filtration function $f_{\text{align}}$ to detect misaligned responses and replace them with IDK, indicating the abstention. In this paper, we use the ROUGE-1 precision score (Lin, ) which computes the ratio of the number of unigrams in response $\tilde{y}_{i}$ that appear also in retrieval result $\mathcal{R}(q,\mathcal{S}_{i})$.
A low score implies that the response is irrelevant to the retrieved documents. Specifically, $f_{\text{align}}$ replaces $\tilde{y}_{i}$ with IDK if the score for a response is below 0.9
and keep $\tilde{y}_{i}$ otherwise. Given that the responses are in a keyword-based form, the ROUGE-1 precision score effectively captures how well the words in the response match the provided context. As a result, we can obtain a refined set of answer candidates:

$$ $\displaystyle\mathcal{M}_{\text{filtered}}=\{f_{\text{align}}(\tilde{y}_{i}, \mathcal{R}(q,\mathcal{S}_{i}))\mid{i\in[N]}\}\;.$ (2) $$

We demonstrate the effectiveness of $f_{\text{align}}$ based on ROUGE-1 precision in Section 5.3. However, our choice of $f_{\text{align}}$ based on the ROUGE-1 score can be replaced with asking the relevance of the response to the retrieved result to the language model, while it requires substantial cost as well as the risk of hallucination.

### 3.3 Stage 1: Iterative Reliability Estimation

To estimate the reliability of sources and effectively aggregate the outputs, we utilize the WMV method proposed by Li & Yu (), which is a simple and effective approach for aggregating crowdsourced labels in classification tasks, applied to the filtered outputs.
Given the set $\{q^{j}\mid j\in[M]\}$ of $M$ queries,
the iterative reliability estimation is described as follows:

- •
Step 0. We initialize the source weights $v_{i}=1$ for all sources $i\in[N]$ and
repeat Step 1 to Step 2 until $v_{i}$’s converge.
- •
Step 1. We estimate each answer $\hat{y}^{j}$ for each $j\in[M]$ using WMV:
$\displaystyle\hat{y}^{j}=\operatorname*{arg\,max}_{\scriptscriptstyle{u\in
\mathcal{M}^{j}_{\text{filtered}}}}\sum_{i\in[N]}v_{i}\mathbbm{1}(\tilde{y}_{i
}^{j}=u)\;,$
(3)
where $\tilde{y}_{i}^{j}=\mathcal{G}(q^{j},\mathcal{R}(q^{j},\mathcal{S}_{i}),
\mathcal{P}_{\text{keyword}})$ is a response to $q^{j}$ based on documents from source $i$ and
$\mathcal{M}^{j}_{\text{filtered}}=\{f_{\text{align}}(\tilde{y}_{i}^{j},
\mathcal{R}(q,\mathcal{S}_{i}))\mid{i\in[N]}\}$ is the filtered candidates of responses to $q^{j}$.
- •
Step 2.
Given the estimated $\hat{y}^{j}$’s, we estimate source reliability $\hat{w}_{i}$ for each $i\in[N]$ as follows:
$\displaystyle\hat{w}_{i}=\frac{\sum_{j=1}^{M}\mathbbm{1}\big{(}f_{\text{align}
}(\tilde{y}_{i}^{j},\mathcal{R}(q^{j},\mathcal{S}_{i}))=\hat{y}^{j}\big{)}}{
\sum_{j=1}^{M}\mathbbm{1}\big{(}f_{\text{align}}(\tilde{y}_{i}^{j},\mathcal{R}
(q^{j},\mathcal{S}_{i}))\neq\text{IDK}\big{)}}\;.$
(4)
Then, we normalize $\hat{w}_{i}$ as $v_{i}=N\hat{w}_{i}-1$
giving larger weights to reliable sources and smaller weights to unreliable sources. This leads to more accurate estimates of $w_{i}$. Following the approach of Li & Yu (), which uses the number of labels $L$ as a scaling factor, we use $N$, the number of sources, because the maximum possible number of responses occurs when each source provides a distinct answer. However, in real-world applications, it is unlikely that all sources will offer completely distinct responses, especially when $N$ is large. Thus, $N$ can be reasonably limited to a manageable size.
- •
Step 3.
With the converged weights $v_{i}$, we compute the refined estimated answers using the WMV, i.e., $\hat{y}^{j}=\operatorname*{arg\,max}_{u\in\mathcal{M}^{j}_{\text{filtered}}}
\sum_{i\in[N]}v_{i}\mathbbm{1}(\tilde{y}_{i}=u)$ for all $j\in[M]$.

### 3.4 Stage 2: Reliable and Efficient Inference

In real-world applications, integrating information from all sources can cause a significant computational burden, especially when the number of sources is large. The WMV process, $\hat{y}^{j}=\arg\max_{u\in\mathcal{M}^{j}_{\text{filtered}}}\sum_{i\in[N]}v_{i
}\mathbbm{1}(\tilde{y}_{i}^{j}=u)$, becomes increasingly expensive as $N$ grows. For better scalability, we select a subset of sources, denoted as $\mathcal{W}$, where $|\mathcal{W}|<N$. Then, the WMV process is applied using $\mathcal{W}$: $\hat{y}^{j}=\arg\max_{u\in\mathcal{M}^{j}_{\text{filtered-}\mathcal{W}}}\sum_{
i^{\prime}\in\mathcal{W}}v_{i^{\prime}}\mathbbm{1}(\tilde{y}_{i^{\prime}}=u)$, where
$\mathcal{M}^{j}_{\text{filtered-}\mathcal{W}}=\{f_{\text{align}}(\tilde{y}_{i^
{\prime}}^{j},\mathcal{R}(q,\mathcal{S}_{i^{\prime}}))\mid{i^{\prime}\in
\mathcal{W}}\}$. A simple way to select $\mathcal{W}$ is to choose the $\kappa$ most reliable sources. However, high reliability alone doesn’t always mean these sources will contain relevant documents for the given query, which can lead to performance degradation. Therefore, it’s important to consider both reliability and relevance.

To achieve this, we identify the $\kappa$ most reliable and relevant sources. We start by ordering the sources by reliability and then check if they contain documents relevant to the query. This process continues until we find $\kappa$ sources, which we call the $\kappa$-Reliable and Relevant Source Selection ($\kappa$-RRSS). Although similarity scores from the retrieval process can suggest relevance, they are often noisy, as high scores may just reflect shared words without capturing the actual context. Instead, we use the LLM’s responses and apply a filtering method, $f_{\text{align}}$, to assess relevance. If the filtered LLM response is “I don’t know”, we consider the source as lacking relevant information. Once the $\kappa$ sources are selected, we use their outputs in the WMV process to generate the final answers.

## 4 Benchmark of Multi-Source RAG

We construct a benchmark designed to assess performance in environments where the database contains sources with heterogeneous reliability, which reflect the complexities of real-world scenarios.
Each source $S_{i}$ is characterized by two parameters: (1) the probability $r_{i}$ of containing the relevant documents to a given question (related to the corpus size), and (2) its reliability $p_{i}$, representing the probability that $S_{i}$ contains factual documents. We use two types of priors to model the reliability $p_{i}$: the *beta* prior and the *spammer-hammer* prior. For the *beta* priors, $p_{i}$ is sampled from $\text{Beta}\left(\nicefrac{{2\bar{w}}}{{1-\bar{w}}},\ 2\right)$, which has an expected mean of $\bar{w}$. This enables the simulation of scenarios with sources that have heterogeneous reliability. For the *spammer-hammer* prior, $p_{i}$ is set to either $0.1$ or $0.9$, where $p_{i}=0.1$ represents a *spammer*, an unreliable source that provides mostly incorrect information for the given query and $p_{i}=0.9$ represents a *hammer*, a reliable source that provides mostly accurate information.

To construct the corpus for each source $S_{i}$ based on this framework, we use three datasets: Natural Questions (NQ) (Kwiatkowski et al., ), HotpotQA (Yang et al., ), and TriviaQA (TQA) (Joshi et al., ). For the HotpotQA dataset, we use only single-hop queries. We focus on closed-ended queries because open-ended queries (e.g., “Describe the various uses of forests to human beings” from the NQ dataset) often lack definitive answers, making aggregation from multiple sources difficult. To identify closed-ended queries, we first use GPT-4o-mini (OpenAI, ) to filter out open-ended queries and then manually review any remaining ones. The filtering prompt is provided in Appendix F.1. Due to computational constraints, we select 1,600 queries per dataset: 200 for reliability estimation and 1,400 as test data.
The corpus for each source $S_{i}$ is generated through the following steps:

- 1.
Collecting factual documents: We first collect documents containing the correct answers from the Wikipedia corpus using Contriever (Izacard et al., ) for the NQ and TQA datasets. For the HotpotQA dataset, we use the contexts provided within the dataset itself.
- 2.
Generating diverse factual information: To generate diverse factual information that conveys the same meaning but in different expressions, we use GPT-4o-mini to paraphrase the collected documents, creating 9 documents for each query. This diversity makes it more challenging to aggregate the LLM’s outputs.
- 3.
Generating diverse misinformation:
Unlike classification tasks with predefined label sets, incorrect answers can vary infinitely in query-answering tasks. To simplify our experiment, we use GPT-4o-mini to generate 9 distinct incorrect answers for each query and then create three corresponding documents for each incorrect answer using GPT-4o-mini.
- 4.
Constructing the corpus for $S_{i}$:
The corpus for each source $S_{i}$ is generated independently, based on its $r_{i}$ and $p_{i}$. If $S_{i}$ contains relevant documents for a given query (as determined by $r_{i}$), the truthfulness of these documents is decided by $p_{i}$. If $S_{i}$ is assigned to provide factual information, it randomly selects three documents from pool of the previously generated factual documents.
Conversely, if $S_{i}$ is designated to provide misinformation, it randomly choose one of the nine incorrect answers and includes the corresponding three misinformation documents generated earlier.
Since the corpus for each source is constructed independently, each source contains a different set of knowledge. For instance, for a given query, $S_{i}$ may have relevant documents, while $S_{j}$ may not, where $i\neq j$ and $i,j\in[N]$.

The specific prompts used to generate the data are detailed in Appendix F.

## 5 Experiments

In this section, we conduct comprehensive experiments on the benchmarks to evaluate the effectiveness of RA-RAG. Detailed descriptions of the experimental setup can be found in Section 5.1, and the results are presented in Section 5.2. Additionally, we perform ablation studies on the individual modules within RA-RAG to evaluate its overall effectiveness, as discussed in Section 5.3.

### 5.1 Experimental Settings

Models. For the LLMs, we use Llama3-8B Instruct (Dubey et al., ), Phi3-mini Instruct (Abdin et al., ), and GPT-4o mini (OpenAI, ).
As the retriever, we utilize Contriever (Izacard et al., ), which calculates similarity scores by taking the dot product between the embedding vectors of a query and documents in the database.

Baselines. We evaluate our framework against the following baselines:

- •
Oracle WMV: Oracle Weighted Majority Voting aggregates outputs using the true reliability values of each source, representing an ideal scenario where the source reliability is available.
- •
WMV: Weighted Majority Voting aggregates outputs from all sources using the estimated reliability values, i.e., Weighted Majority Voting excludes the RRSS process from RA-RAG.
- •
MV: Majority Voting aggregates outputs by assigning equal weight to each response.
- •
Naive RAG: Naive RAG follows the traditional RAG approach, retrieving documents and generating outputs without considering the reliability of the sources in the database.
- •
Naive LLM: Naive LLMs generate outputs for the given query without using a retriever.

Settings for multi-source RAG.
In our multi-source RAG setup, we retrieve the top 3 documents from each source and select 4 sources for the $\kappa$-RRSS process. For Naive RAG, we retrieve the top-10 documents, as multi-source RAG typically handles a larger volume of information. When constructing sources for the multi-source RAG benchmark, we set the beta prior with $\bar{w}=0.6$. To simplify the setup, we assign $r_{i}=0.6$ for all sources. Due to computational constraints, the number of sources is limited to between 3 and 9. We use Exact Match (EM) (Rajpurkar et al., ) as the evaluation metric, with all experimental results averaged over 10 random trials.

### 5.2 Main Results

Beta prior. We conduct experiments using a *beta* prior across different numbers of sources to demonstrate the effectiveness of our method with heterogeneous reliability.
Figure 2 shows that our RA-RAG framework demonstrates significant performance improvements, outperforming both MV and Naive RAG.
Notably, our RA-RAG, which uses $\kappa=4$ for $\kappa$-RRSS (the subset of sources), achieves performance comparable to WMV, which aggregates information from all available sources.
The performance of WMV closely matches the oracle WMV, demonstrating that our approach effectively estimates source reliability.
In contrast, the Naive RAG exhibits poor performance when source reliability varies, leading to a high likelihood of retrieving a mixture of factual information and misinformation, for both the NQ and TQA datasets.
This inconsistency results in conflicting knowledge, complicating LLMs’ ability to generate accurate outputs.

We provide a qualitative example in Figure 3 to illustrate how RA-RAG effectively estimates source reliabilities and improves answer accuracy.
While MV selects “southern ocean” based on response frequency,
RA-RAG correctly identifies “atlantic ocean” by leveraging well-estimated reliabilities that align closely with true values.
This example highlights RA-RAG’s robustness in overcoming conflicting or inaccurate information by focusing on more reliable sources, ensuring more accurate predictions.

Spammer-hammer prior.
To evaluate the robustness of our method in the presence of spammers in the database, we conduct experiments using the *spammer-hammer prior* with a total of 9 sources, using Llama3-8B on the NQ dataset. The experimental results for TQA and HotpotQA datasets are provided in Appendix C.2.
As shown in Figure 7, our RA-RAG framework demonstrates robustness against spammers, while the performance of Naive RAG degrades significantly as the number of spammers increases.
When the number of spammers exceeds five, MV performs worse than Naive RAG. This decline results from the dominance of misinformation from spammers, which leads MV to select incorrect answers.

Figure: Figure 2: Exact Match against the number of sources, comparing the heterogeneous reliability via *beta* priors on the NQ and TQA datasets across the Llama3-8B, Phi3-mini, and GPT-4o-mini language models. See Figure 8 in Appendix C.1 for the HotpotQA dataset.
Refer to caption: x2.png

Figure: Figure 3: A qualitative comparison between MV and RA-RAG on the NQ dataset. Additional examples are available in Appendix D.
Refer to caption: x3.png

Figure: Figure 4: EM against the number of spammers, comparing robustness using *spammer-hammer* priors on the NQ dataset.
Refer to caption: x4.png

### 5.3 Ablation studies and Analysis

Effectiveness of filtering with $f_{\textbf{align}}$.
We conduct an ablation study to evaluate the necessity of $f_{\text{align}}$ for accurate reliability estimation, across different types of retrieved documents: factual, misinformation, and irrelevant. Table 2 shows the proportions of answers both without (w/o) and with (w/) filtering, categorized by answer types: correct, incorrect, IDK (I don’t know), and hallucination, based on 1,600 queries in the TQA dataset, using a single source with $p_{i}=0.5$ and $r_{i}=0.5$. Further results for other datasets and models are in Appendix C.5.
Table 2 shows that LLM misalignment occurs when the documents contain misinformation or are irrelevant, resulting in correct or hallucinated answers that are not based on the retrieved documents. In particular, in cases of irrelevant documents, LLMs often generate either correct answers or hallucinations. However, after applying the $f_{\text{align}}$, these misaligned responses (marked in blue) are significantly reduced. Additionally, the increase in IDK responses (marked in red) indicates that filtering effectively mitigates the influence of irrelevant documents and misinformation.

Risk of distortion of reliability estimation without filtering.
As highlighted in our analysis, LLMs frequently generate either correct answers or hallucinations when processing irrelevant documents. This issue becomes particularly problematic when dealing with low-reliability sources that have a small corpus. As the corpus size shrinks, i.e., contains fewer relevant documents, more queries are needed to accurately estimate the reliability of these sources. However, this can lead to LLMs producing a large number of correct answers or hallucinations, potentially resulting in an overestimation of the sources’ reliability. To illustrate this risk, we conduct experiments using the *spammer-hammer prior*. Specifically, we experiment with five sources from the TQA dataset using Llama3-8B: four spammers with $r_{i}=0.1$ and one hammer with $r_{i}=0.6$, using 800 queries for reliability estimation. As illustrated in Table 2, without filtering, the estimated weights are distorted, giving more weight to the spammers and leading to poor performance. However, applying filtering effectively mitigates this distortion in reliability estimation, yielding performance close to the Oracle WMV.

Table: Table 1: Percentage of type of answers by retrieved document type in the filtering with $f_{\text{align}}$ ablation study on Llama3-8B and TQA dataset.

Effectiveness of $\kappa$-RRSS.
To determine the optimal value of $\kappa$ for $\kappa$-RRSS, we conduct ablation studies using different values of $\kappa$ with 9 sources on the NQ dataset, employing Llama3-8B. As shown in Figure 7, when $\kappa=4$, RA-RAG outperforms MV and shows a slight performance drop compared to WMV, which uses all available sources. This result, with $\kappa$ being less than half the total number of sources, shows that selecting a small subset of sources can achieve performance close to using all sources.
The results for additional datasets are provided in Appendix C.3.
In addition, to quantitatively evaluate the efficiency of $\kappa$-RRSS, we assess the inference cost using GPT-4o mini by the number of sources. As shown in Figure 7, RA-RAG incurs lower inference costs than WMV, which aggregates all sources, and the efficiency of our RA-RAG framework becomes increasingly evident as the number of sources grows.

To analyze the importance of considering relevance in $\kappa$-RRSS, we evaluate a variant: $\kappa$-RSS (Reliable Source Selection), which selects $\kappa$ sources based solely on reliability scores in descending order, without checking whether the sources contain relevant documents on NQ dataset. As shown in Figure 7, using $\kappa$-RSS leads to significant performance degradation, since high reliability alone does not guarantee that the selected sources will contain documents relevant to the given query.

## 6 Conclusion

In this paper, we introduce RA-RAG, an effective multi-source RAG mechanism that estimates source reliability without using true labels and efficiently aggregates information through WMV, addressing the inherent problems of RAG systems. We also present a comprehensive benchmark that reflects real-world scenarios with diverse source reliability. Our experimental results show that RA-RAG consistently outperforms a set of baselines, demonstrating its robustness and effectiveness even when handling conflicting and unreliable information.

Future directions.
Despite RA-RAG’s robustness, several challenges remain: (1) While aggregating keyword-based LLM responses using a system prompt is effective and does not require additional post-processing or modules, this approach has limitations, such as difficulty in handling homonyms and varied expressions, which make consistent aggregation challenging. Therefore, more advanced approaches, such as using LLMs capable of capturing semantic meaning, are needed for more general and reliable aggregation. (2) While $f_{\text{align}}$ effectively filters misaligned responses, it struggles to detect incorrect answers based on retrieved documents. More reliable evaluation methods, such as applying modules from advanced RAG, are necessary. Since our approach does not require training, it can be applied in a plug-and-play manner alongside advanced RAG systems. (3) While we assume the availability of queries to estimate source reliability, real-world applications often require generating these queries, which adds complexity to accurately estimating source reliability.

## 7 Reproducibility Statement

As mentioned, we will release the source code and datasets for the multi-source RAG benchmark and the set of method including RA-RAG and the other baselines. Our experiments have been produced using LLama3-8B Instruct, Phi3-mini Instruct and ChatGPT-4o-mini from July to September 2024. We will also distribute the intermediate outputs of the LLMs so that every evaluation in this work can be reproducible.

## Appendix A Related works

Vulnerabilities of RAG to misinformation.
Retrieval-Augmented Generation (RAG) systems address inherent limitations of LLMs, such as hallucinations and a lack of access to up-to-date knowledge (Lewis et al., ; Guu et al., ), by integrating external databases through retrievers with LLMs. However, standard RAG systems often fall short in handling more complex real-world scenarios. To address these challenges, several advanced RAG systems (Jiang et al., ; Asai et al., ) have been developed, incorporating multiple modules to enhance their performance. Despite these advancements, concerns about misinformation threats within RAG frameworks are growing, as misinformation in retrieved results can lead LLMs to generate unreliable outputs (Pan et al., ; Chen et al., ; Greshake et al., ; Hong et al., ). Furthermore, recent studies (Zhong et al., ; Zou et al., ; Shafran et al., ; Chaudhari et al., ) have highlighted the vulnerability of RAG systems to data poisoning attacks, where adversaries craft a small number of malicious documents to disrupt the system’s reliability. These attacks exploit a key weakness in RAG systems that rely on relevance scores for retrieval; by creating malicious documents with high similarity scores to target questions, adversaries can deceive the RAG system into retrieving misleading information. Notably, Zou et al. () demonstrated that even advanced RAG systems are highly susceptible to such data poisoning attacks.

Robust RAG against misinformation threat.
In response to misinformation threats in RAG systems, several robust methods have been proposed. Pan et al. () uses majority voting to enhance output reliability, while Weller et al. () employs query augmentation to retrieve diverse documents and evaluates the frequency of generated outputs against the retrieved content. Xiang et al. () adopts an isolate-then-aggregate strategy, generating LLM responses for each passage separately and then aggregating them securely to produce robust outputs. Deng et al. () assigns heuristic reliability scores to the document based on source reputation and applies prompt engineering to prioritize documents from reputable sources, whereas Pan et al. () uses GPT’s internal knowledge to generate reliability scores of the document and adjust attention weights accordingly. However, these methods heavily depend on heuristics, with Weller et al. (); Pan et al. (); Xiang et al. () being effective only when the true documents are the majority of the retrieved results. Moreover, heuristic approaches for determining the reliability scores of documents are often impractical in real-world scenarios, as
the reliability of sources such as social media or blogs are often unknown or uncertain, and LLMs cannot rely on internal knowledge to assess up-to-date information. In contrast, our approach systematically estimates source reliability within the database and efficiently aggregates information from multiple sources, resulting in more robust and reliable outcomes.

Robust answer aggregation. In many AI systems, gathering information from diverse sources is essential for tasks such as data labeling, knowledge retrieval, and enhancing large language model (LLM) performance. A central challenge in these tasks is how to aggregate potentially conflicting information from various sources, especially when the quality and reliability of these sources are variable. The most straightforward strategy is majority voting (MV), which assigns the most frequent label or answer across sources. However, MV can be error-prone, especially when dealing with sources of varying reliability. To address this, studies such as Karger et al. (); Liu et al. (); Yue et al. (); Li & Yu (); Aydin et al. (); Li et al. (); Geng et al. () have proposed weighted majority voting (WMV) approaches that account for source reliability, leading to more accurate aggregation of information.

Robust aggregation also plays a crucial role in enhancing the reliability of LLM outputs, particularly in recent complex reasoning tasks. For instance, Wang et al. () introduces a method that samples diverse reasoning outputs in CoT (Wei et al., ) and aggregates the final output through majority voting. Similarly, Zhou et al. (); Wan et al. () calculate confidence scores for each CoT output to perform weighted majority voting, thereby improving the robustness of answers. Further, Chen & Li () adopts a reasoning roll-back strategy in Tree-of-Thoughts (ToT) (Yao et al., ) and applies weighted majority voting to produce the final output.

## Appendix B Detailed algorithm for RA-RAG

Figure: Algorithm 1 First Stage: Iterative Reliability Estimation

Figure: Algorithm 2 Second Stage: Reliable and Efficient Inference

## Appendix C Extended Experimental Results and Analysis

### C.1 Experimental Results of Beta Prior on HotpotQA Dataset

Figure: Figure 8: EM against the number of sources, comparing the heterogeneous reliability via *beta* priors on the HotpotQA dataset across the Llama3-8B, Phi3-mini, and GPT-4o-mini language models.
Refer to caption: x8.png

### C.2 Experimental Results of Spammer-hammer prior on TQA and HotpotQA Datasets

Figure: Figure 9: EM against the number of spammers, comparing robustness using *spammer-hammer* priors on the TQA and HotpotQA datasets.
Refer to caption: x9.png

### C.3 Ablation Study of κ 𝜅 \kappa italic_κ -RRSS for TQA and HotpotQA Datasets

Figure: Figure 10: EM for different numbers of $\kappa$ on the TQA and HotpotQA datasets.
Refer to caption: x10.png

### C.4 Qualitative Results of Filtering With f align subscript 𝑓 align f_{\text{align}} italic_f start_POSTSUBSCRIPT align end_POSTSUBSCRIPT

As shown in Table 2, LLMs often fail to respond with “I don’t know” when no relevant document is provided. Instead, they tend to hallucinate or even generate the correct answer. To address this issue, which significantly affects our datasets, we use $f_{\text{align}}$ to filter out ungrounded responses to the provided contexts. The impact of $f_{\text{align}}$ is illustrated in the following examples in Figure 11: In the first example, the LLM responds with “Andrew Garfield,” which is correct but not grounded in any relevant information from the context. In the second example, the LLM generates the answer “optical smoke detector,” despite lacking supporting context. Utilizing $f_{\text{align}}$, we identify these responses as ungrounded to the contexts, and therefore replace the answer with “I don’t know.”

Figure: Figure 11: Examples of a situation where an LLM provides a correct answer based on its internal knowledge, despite the context containing the misinformation.

### C.5 Extended Ablation studies for filtering

Table: Table 3: Percentage of types of answers by retrieved document type in the filtering with $f_{\text{align}}$ ablation study on Phi-3 mini and NQ dataset.

Table: Table 4: Percentage of types of answers by retrieved document type in the filtering with $f_{\text{align}}$ ablation study on Phi-3 mini and TQA dataset.

Table: Table 5: Percentage of types of answers by retrieved document type in the filtering with $f_{\text{align}}$ ablation study on Phi-3 mini and HotpotQA dataset.

Table: Table 6: Percentage of types of answers by retrieved document type in the filtering with $f_{\text{align}}$ ablation study on GPT-4o-mini and NQ dataset.

Table: Table 7: Percentage of types of answers by retrieved document type in the filtering with $f_{\text{align}}$ ablation study on GPT-4o-mini and TQA dataset.

Table: Table 8: Percentage of types of answers by retrieved document type in the filtering with $f_{\text{align}}$ ablation study on GPT-4o-mini and Hotpot QA dataset.

## Appendix D Qualitative Results of MV and Ours

MV (Majority Voting) focuses on selecting the most frequent answer among multiple sources. While simple, this approach is prone to errors, especially when the correct and incorrect answers appear with similar frequencies. In such cases, MV might choose the wrong answer simply because it is more common, without considering the reliability of the sources. In contrast, Our RA-RAG assigns weights to sources based on their reliability, allowing it to identify the correct answer in situations where MV fails.

Figure: Figure 12: The comparisons between MV and Our RA-RAG answers.

## Appendix E Comparison of performance between keyword-based answer generation using prompt engineering and keyword extraction methods

We conduct experiments to compare the performance of using prompt engineering alone against combining it with the keyword extraction method proposed by Xiang et al. (). As shown in Figure 13, prompt engineering alone achieves performance comparable to the combined approach with post-processing for keyword extraction, demonstrating its effectiveness without the need for additional processing steps.

Figure: Figure 13: Performance Comparison Between Prompt Engineering and Keyword Extraction Methods
Refer to caption: x11.png

## Appendix F Prompt for constructing multi-source benchmark

### F.1 Prompt for open-ended question filtering

Figure: Figure 14: The prompt used for filtering open-ended queries.

### F.2 Prompts for Factual Data Generation

For Natural Questions (NQ) (Kwiatkowski et al., ) and HotpotQA (Yang et al., ), we use Contriever (Izacard et al., ) to retrieve passages that are likely to contain relevant answers. For TriviaQA (Joshi et al., ), we focus on single-hop queries from its training subset, where the answer-containing contexts are already provided.

From the retrieved passages across all datasets, GPT-4o-mini (OpenAI, ) is employed to paraphrase up to two original contexts at a time. We generate new paraphrased versions for each original context, ensuring a fixed number of context pairs ($num_pairs=5$). Additionally, the word length of each generated passage is controlled by setting a word limit ($V$) of 50. We finally choose 9 contexts after these processes.

Figure: Figure 15: The prompt used for generating factual contexts.

### F.3 Prompts for Misinformation Generation

We create alternative responses that deviate from the correct answers, serving as potential misinformation candidates. A secondary prompt is then designed to incorporate these incorrect alternatives, to elicit misleading or false information from the model.

We use the GPT-4o-mini (OpenAI, ) to generate plausible misinformation. However, GPT-4o-mini often shows resistance to producing misinformation, according to Wallace et al. (), sometimes reinserting correct answers even in contexts intended to contain falsehoods. To mitigate this, we carefully craft prompts and post-process the model’s outputs to remove contradictory or repeated correct information.

Figure: Figure 16: The prompt used for generating counterfactual answers.

Figure: Figure 17: The prompt used for generating counterfactual contexts.

## Appendix G Instruction prompt for a keyword-based answer generation.

Figure: Figure 18: The in-context learning prompt used for keyword based answer generation.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 3
presentation: 4
questions: In practice, would this reliability prediction result in multiplied API consumption and reduced efficiency?
It is necessary to compare with some advanced RAG methods to validate the necessity of "considering multi-source reliability".
soundness: 2
strengths: The paper is well-written.
Considering multi-source reliability is innovative and addresses a critical yet often overlooked aspect of RAG methods.
summary: These authors aim to address the challenge of heterogeneous source reliability in RAG, and propose a novel framework, Reliability-Aware RAG (RA-RAG), which incorporates source reliability into both the retrieval and aggregation processes.
weaknesses: 1. Despite using prompts for constraints, voting remains influenced by expression diversity and synonyms, which creates a frustrating lack of control in practical applications.
2. Generalization issues, such as in multi-hop scenarios and open-ended questions.
3. I question the motivation behind using RAG responses to certain queries about a resource as the basis for assessing that resource's reliability. For instance, a small amount of data does not necessarily indicate unreliability, and it is challenging to distinguish a small amount of correct information when faced with a large volume of outdated or incorrect data. Similarly, as the retriever is a critical component in RAG, the reliability of the retriever itself should not be overlooked when evaluating the reliability of a resource through retrieval-based methods(The authors' method for predicting reliability can still be viewed as a variation of relevance. ).
4. Lack of baseline to experimentally demonstrate the effectiveness.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: see Weaknesses
soundness: 3
strengths: 1. The idea of iteratively reliability estimation is interesting, which provides an effective estimation for source reliability in certain scenarios.
2. The proposed benchmark can be applied to future related studies.
summary: This paper proposes Reliability-Aware RAG, which enhances traditional RAG models by incorporating source reliability into both retrieval and aggregation, reducing the risk of misinformation propagation.

RA-RAG iteratively estimates source reliability and performs inference based on this reliability, achieving improved performance on the proposed benchmark.
weaknesses: 1. Questioning the effectiveness of the method.

a) The method proposed by the author relies heavily on the correctness of majority voting, both in reliability assessment and during the inference phase. However, in noisy scenarios (for example, when there is only one correct document), this method may not precisely select reliable document. This is precisely an important scenario that the paper aims to address.

b) In my opinion, the core assumption of this method is that the higher the probability of different documents in a certain source providing the same answer, the greater the overall reliability of that source. Furthermore, the author's approach to constructing the benchmark seems to follow this assumption, which could be the reason that the reliability estimation is effectively applicable on the benchmark created in this paper. However. due to the imperfect retrieval and the spread of misinformation, this assumption may not hold true in real RAG systems. I believe the author should validate the effectiveness of this method in more realistic scenarios.

2. Inappropriate experimental settings

a) In Figure 2 and 4, I cannot observe a significant performance improvement compared to the baseline WMV. I strongly recommend that the authors present the experimental results in a table. And the author should provide a comparison with more other relevant methods (such as CAG / RobustRAG).

3. Limitations of the proposed benchmark

• The paper claims to present a realistic multi-source RAG benchmark. However, all the misinformation is generated by GPT-4 mini rather than real-world data. This will limit the demonstration of the method's effectiveness in actual scenarios.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 2
questions: 1. The paper needs better adherence to writing conventions, particularly in maintaining consistency in capitalization for acronyms.

2. Many sentences are ambiguous and difficult to comprehend, requiring clearer expression. e.g. The abstract contains confusing statements, particularly regarding "true answers" and "no labelling." For instance, the sentence "Specifically, it iteratively estimates source reliability and true answers for a set of queries with no labelling" is unclear. Does "no labelling" refer to the absence of ground truth answers? This ambiguity creates confusion for first-time readers.

3. Although the authors mentioned in the introduction that using LLMs to evaluate the reliability of documents based on their internal knowledge would be less effective when external knowledge needs to be consulted (the second paragraph in the Introduction), in this paper, when designing hypothetical answers as the basis for reliability judgment, the same problem will also be faced. The retrieved content may not necessarily contain the correct information.

4. How to ensure that the role of the language model in the RA - RAG framework is based on reliable retrieved information rather than overly relying on its internal knowledge, especially when dealing with complex or ambiguous queries? The generalizability of the method needs to be verified.
soundness: 2
strengths: The research topic is novel and timely. In multi-source RAG systems, evaluating the reliability of information from different sources during retrieval, identifying heterogeneity across sources, mitigating conflicts and redundancy, and achieving complementarity are significant research challenges that have received limited attention from the RAG community.
summary: This paper introduces Reliability-Aware Retrieval-Augmented Generation (RA-RAG), a approach to address misinformation challenges in multi-source retrieval. RA-RAG operates in two stages: first estimating source reliability through an iterative process without labeled data, then efficiently retrieving and aggregating information from reliable sources using weighted majority voting. The authors developed a realistic multi-source benchmark reflecting real-world complexity, unlike previous benchmarks using artificially injected misinformation. Experimental results show RA-RAG consistently outperforms baselines when handling conflicting and unreliable information, demonstrating its robustness and effectiveness.
weaknesses: 1. The motivation, particularly regarding the propagation of misinformation, is inadequately explained. The paper fails to clearly illustrate how misinformation propagates and accumulates, and how this manifests in heterogeneous multi-source retrieval systems.

2. The research lacks focus. While the paper should primarily address reliability assessment in multi-source retrieval scenarios, it digresses into discussing a lot about response misalignment (where models generate answers based on internal knowledge rather than retrieved documents). This represents a separate research direction in RAG concerning conflicts between LLM's internal and external knowledge, and should not be a major focus of this work.

3. The methodology is  simplistic. The weighted majority voting approach, while classical, relies primarily on statistical scores and assumption-based document filtering. The paper lacks in-depth analysis of the feature of different sources, failing to adequately address the heterogeneity among them - a limitation the authors themselves identified in related work. Furthermore, there's no mechanism for refining initial voting results based on actual response patterns.

4. The use of ROUGE-1 to evaluate the reliability of estimated answer y~ in retrieved documents, and subsequent filtering of irrelevant sources based on these scores, is questionable. This approach might perpetuate errors in the RAG system due to incorrect hypothetical generations. Moreover, it appears suitable only for extractive questions  where answers can be directly found in document blocks due to the principle of ROUGE, not for tasks requiring information synthesis. This limitation is evident in the chosen datasets (HotpotQA, NQ, TriviaQA), which primarily focus on fact QA.

---

confidence: 3
contribution: 1
initial_rating: 5
presentation: 4
questions: What is the pipeline sensitivity to the Prompt and the f_{align} threshold (0.9) ?

I am not sure to understand how keeping the k RRSS is relevant to decrease computational cost as one need to infer the LLM answer to verify if it is not IDK, therefore requiring no additional computational power to compute the majority vote. This is more of a reliability filter than an efficiency wise operation. 

Doesn’t Exact Match benefit methods that use a prompt leading to short answers? Naive RAG on the opposite might contain long answer with LLM verbose presentation of the answer? 

It was not clear if a specific prompt was used for the naive RAG approach
soundness: 3
strengths: The approach is well motivated, leveraging and solving several prior works limitations.

The proposed evaluation benchmark is an important contribution that could benefit the community, 

The method outperforms baselines.
summary: This article proposes a novel pipeline for open domain question answering based on RAG, that first estimates sources reliability score before performing majority vote for answer selection. Authors built a benchmark by sampling sources reliability and generating set of documents for each sources and answers which are true are false depending on the sampled reliability score. Then, they evaluated their approach compared to several baselines, such as naive RAG, simple majority voting or answers from the LLM parametric memory. The approach outperforms baselines.
weaknesses: Relies on many engineering blocks, with no real scientific contribution. 

Reliability is evaluated at the source level. The issue is that some sources such as Wikipedia or social media have huge variability is source quality, and the current approach cannot take this into account. 

I don’t get how prompting alone can solve the answer format alignment problem (section 3.1, not 3.2). Name could be written F. Lastname, Firstname Lastname, Lastname Firstname, etc… For real deployment of the proposition, it could be a major limitation as the pipeline needs aligned answers for efficient voting. 

For niche or specialized topics, the approach will give lesser weight to highly specialized sources, that will probably provide more precise answers, therefore different answers than the majority, even if the retriever computed a very high score for the document. 

The generated benchmark does not completely cover real life scenarios, such as source format variability (social media posts are much shorter than news article). This impact of source format is not evaluated here, and this could lead to high impact in open QA regime.

Potentially unfair comparison to baselines (see questions)

Meta-review: This paper introudces a new RAG framework, named reliability-aware RAG (RA-RAG), which estimates the reliability of multiple sources and incorporates this information into both the retrieval and aggregation processes. Moreover, the authors also introduce a benchmark dataset designed to reflect the real scenarios with heterougeneous source reliability and demonstrate the effectiveness of the proposed method.

Overall, this paper studies an interesting problem. However, the motivation of the proposed method is not well explained. The experimental analysis is not sufficient, lacking relevant baselines to demonstrate the effectiveness of the proposed method. Moreover, the application of the proposed method in real scenarios is limited.

Decision: Reject