Graph of Records: Boosting Retrieval Augmented Generation for Long-context Summarization with Graphs

## Abstract

Abstract Retrieval-augmented generation (RAG) has revitalized Large Language Models (LLMs) by injecting non-parametric factual knowledge.
Compared with long-context LLMs, RAG is considered an effective summarization tool in a more concise and lightweight manner, which can interact with LLMs multiple times using diverse queries to get comprehensive responses.
However, the LLM-generated historical responses, which contain potentially insightful information, are largely neglected and discarded by existing approaches, leading to suboptimal results.
In this paper, we propose graph of records ( GoR ), which leverages historical responses generated by LLMs to enhance RAG for long-context global summarization.
Inspired by the retrieve-then-generate paradigm of RAG, we construct a graph by establishing an edge between the retrieved text chunks and the corresponding LLM-generated response.
To further uncover the intricate correlations between them, GoR further features a graph neural network and an elaborately designed BERTScore -based objective for self-supervised model training, enabling seamless supervision signal backpropagation between reference summaries and node embeddings.
We comprehensively compare GoR with 12 baselines across four long-context summarization datasets, and the results indicate that our proposed method reaches the best performance ( e.g. , 15%, 8%, and 19% improvement over retrievers w.r.t. Rouge-L, Rouge-1, and Rouge-2 on the WCEP dataset).
Extensive experiments further demonstrate the effectiveness of GoR.
Code is available at https://github.com/ulab-uiuc/GoR

## 1 Introduction

Large Language Models (LLMs) have recently achieved remarkable performance across sorts of language modeling tasks Achiam et al. (); AI@Meta ().
Among them, the long-context global summarization task is of great importance, which requires ultra-long context understanding capabilities of LLMs Li et al. (); Liu et al. ().
Current attempts to accomplish this task mainly include long-context LLMs Touvron et al. (); GLM et al. (); Li* et al. (); Tworkowski et al. () and retrieval-augmented generation (RAG) Ram et al. (); Yu et al. (); Trivedi et al. (); Jiang et al. (); Asai et al. ().
In comparison with long-context LLMs that expand their context window to accommodate long-context inputs, RAG performs a cost-effective retrieve-then-generate paradigm and provides a few retrieved short text chunks from a long document to LLMs.
In a running RAG system (Figure 1), there are usually a large number of historical user queries and LLM-generated responses for a long document.
Nevertheless, these historical responses, which contain informative task-related content, are mostly neglected without sufficient utilization by current RAG approaches.

Unfortunately, utilizing LLM historical responses for long-context global summarization presents two major challenges.
(1) Sophisticated yet implicit correlations between historical responses and text.
Given a long document, there will inevitably be complicated correlations among plentiful user queries (e.g., logical correlations), which are further inherited by LLM-generated responses and the retrieved text chunks.
However, uncovering these correlations is non-trivial since most text embeddings from language models (e.g., SBERT Reimers & Gurevych ()) or retrievers Karpukhin et al. () concentrate on semantic similarity, which faces degrading performance in this case.
(2) Lack of supervision signal.
In contrast with local (e.g., query-based) summarization Zhong et al. (); Wang et al. () that includes golden reference text as labels, global summarization needs to be considered from the perspective of the long document as a whole and only has global reference summaries, which makes it difficult to directly backpropagate effective, accurate, and deterministic supervision signals to optimize the model in the direction of a few relevant text chunks.

Figure: Figure 1: Long document summarization with a RAG system. The RAG system utilizes user queries to retrieve relevant text chunks in documents, which are further fed into LLMs to generate responses back to users. In this process, massive historical responses are not sufficiently utilized.
Refer to caption: x1.png

Based on the above observations, we propose graph of records (GoR), which utilizes and organizes LLM historical responses as a graph of records for enhancing long-context global summarization in RAG.
In detail, we first leverage LLMs to simulate some user queries conditioned on arbitrary text chunks in a long document to obtain historical responses under the paradigm of RAG, and an edge is then created between the retrieved text chunks and the LLM-generated response to construct a graph of records.
To learn fine-grained correlations among nodes, we employ a graph neural network and reuse the simulated user queries with the corresponding source text chunk as self-supervised training data.
Intuitively, we hope the node embeddings can be adaptively learned to reflect the semantic and logical correlations with a given query.
Inspired by the well-received BERTScore Zhang et al. () that quantifies the semantic similarity between two paragraphs of text, we rely on it to rank the nodes according to their similarity with the self-supervised label of a given simulated query.
In this way, node embeddings can benefit the indirect supervision signal from the self-supervised labels and be flexibly optimized using a contrastive loss and a pair-wise ranking loss based on the node rankings.
In the experiments, we adopt four long-context summarization datasets, and the results demonstrate the superiority and effectiveness of our proposed method.
For example, we show that GoR outperforms retrievers by 15%, 8%, and 19% w.r.t. Rouge-L, Rouge-1, and Rouge-2, respectively, on the WCEP dataset.
We also provide detailed comparisons and insightful analyses through extensive experiments, further showcasing the effectiveness of our approach.
Our contributions are summarized as follows:

- •
We propose graph of records (GoR), which utilizes and organizes LLM-generated historical responses as a graph of records to strengthen RAG for long-context global summarization. We reveal that the fine-grained correlations between LLM historical responses and text chunks from long documents can be uncovered and utilized effectively to improve RAG performance.
- •
We leverage a  graph neural network and design a  BERTScore-based objective to optimize node embeddings, which can be adaptively learned in a self-supervised manner to reflect the semantic and complex correlations with input queries. Furthermore, the indirect supervision signal from self-supervised labels is crucial and conducive to the effective optimization of node embeddings.
- •
We evaluate our proposed method on four long-context summarization datasets, and the experimental results show that GoR outperforms several competitive baselines by a significant margin. Extensive experiments and detailed analysis verify the superiority of GoR.

## 2 Graph of Records

In this section, we first present some necessary backgrounds in Section 2.1.
Then, we describe our proposed method sequentially through two sections, i.e., Graph Construction (Section 2.2) and BERTScore-based Objective for Self-supervised Training (Section 2.3).

### 2.1 Preliminaries

Retrieval-augmented Generation.
Retrieval-augmented Generation (RAG) Ram et al. () can typically be summarized into the following two processes.
(1) Retrieval.
Give a long document which consists of several split text chunks $\mathbf{C}=\{\mathbf{c}_{\mathbf{i}}\}_{i=1}^{|\mathbf{C}|}$ as retrieval corpus, RAG first employs a retriever (e.g., Contriever Izacard et al. ()) to retrieve $\mathbf{K}$ text chunks that are most relevant to a given query $\mathbf{q}$ based on semantic similarity.
The retriever typically embeds the query $\mathbf{q}$ and a text chunk $\mathbf{c}$ from $\mathbf{C}$ using a query encoder $\mathbf{E}_{\mathbf{q}}(\cdot)$ and a context encoder $\mathbf{E}_{\mathbf{c}}(\cdot)$, respectively, and quantify their semantic similarity by the dot product operation described as $\operatorname{Sim}(\mathbf{q},\mathbf{c})=\mathbf{E}_{\mathbf{q}}(\mathbf{q})^
{T}\cdot\mathbf{E}_{\mathbf{c}}(\mathbf{c})$.
(2) Generation.
The retrieved text chunks are fed into LLMs with the query $\mathbf{q}$ to obtain the final response $\mathbf{r}$.
The whole process can be described as:

$$ $\mathbf{r}=\operatorname{Generation}(\mathbf{q},\{\mathbf{c}_{\mathbf{1}}, \cdots,\mathbf{c}_{\mathbf{K}}\}),\quad\{\mathbf{c}_{\mathbf{1}},\cdots, \mathbf{c}_{\mathbf{K}}\}=\operatorname{Retrieval}(\mathbf{q}|\mathbf{C})$ (1) $$

Graph Neural Networks.
Graph Neural Networks (GNNs) Kipf & Welling () stand out for their excellent representation learning ability on graph data.
GNNs update node embeddings iteratively by aggregating messages from their neighboring nodes.
Generally, the $l$-th layer of GNNs can be formalized as:

$$ $\mathbf{h}_{v}^{(l)}=\mathrm{AGG}^{(l)}\left(\mathbf{h}_{v}^{(l-1)},\mathrm{ MSG}^{(l)}\left(\{\mathbf{h}_{u}^{(l-1)},u\in N(v)\};\theta_{m}^{l}\right); \theta_{a}^{l}\right)$ (2) $$

where $\mathbf{h}_{u}^{(l)}\in\mathbb{R}^{d_{l}}$ is the embedding vector of nodes $u$ in layer $l$ and the embedding dimension is $d_{l}$.
$\mathrm{MSG}^{(l)}(\cdot)$ is a message computation function parameterized by $\theta_{m}^{l}$ and
$\mathrm{AGG}^{(l)}(\cdot)$ is a message aggregation function parameterized by $\theta_{a}^{l}$ in layer $l$.

### 2.2 Graph Construction

In this section, we describe how to organize LLM historical responses into a graph of records by simulating user queries.

Query Simulation. User queries play a very critical role in the design of GoR since LLM historical responses generated by lots of repetitive, nonsense, or meaningless questions are inherently not beneficial for summarization.
One solution is to use doc2query Nogueira et al. () to simulate queries for a long document, but the generated results inevitably suffer from simplicity and rigidity due to the limited text generation capabilities of T5 Raffel et al. ().
To this end, we directly turn to LLMs for query simulation with temperature sampling instead of greedy decoding for generating meaningful, insightful, and diverse questions.
Specifically, we split a long document into several text chunks $\mathbf{C}$ following the standard procedure of RAG and prompt LLMs to generate a query $\mathbf{q}^{\mathbf{s}}$ based on a randomly selected text chunk $\mathbf{c}^{\mathbf{s}}$.
We repeat the above process until a certain number of non-duplicate queries are generated, which are gathered in pairs with the corresponding text chunks to form a corpus $\mathbf{T}=\{(\mathbf{q}^{\mathbf{s}}_{i},\mathbf{c}^{\mathbf{s}}_{i})\}_{i=1}
^{|\mathbf{T}|}$ for further model training (Section 2.3).
The prompt for query simulation can be found in Appendix B.

Organize LLM Historical Responses into A Graph. After obtaining simulated queries, we utilize them to perform RAG on the long document.
LLM-generated responses during this process include informative and valuable understanding, summarizing, and answering of retrieved text chunks in the long document.
Moreover, since there may exist sophisticated correlations among simulated queries, the text chunks and responses can inherit these features and potentially assist in answering a more comprehensive query, especially global summarization that needs to be understood from a holistic perspective.
Nevertheless, it is a significant challenge to find correlations among complex and massive text at the linguistic level and the embeddings from language models (e.g., SBERT Reimers & Gurevych ()) or retrievers Karpukhin et al. () focus on semantic similarity, which also suffers from poor performance in this case.
To this end, we propose to break out of this dilemma by organizing these historical responses into a graph.

Inspired by the retrieve-then-generate process of RAG, we can connect the retrieved chunks to the corresponding response generated by LLMs since they are naturally relevant in content.
Sequentially, during the $\mathbf{i}$-th round RAG, given the simulated query $\mathbf{q}^{\mathbf{s}}_{\mathbf{i}}$, we expand the retrieval corpus $\mathbf{C}$ with previously generated responses $\{\mathbf{r}_{\mathbf{1}},\cdots,\mathbf{r}_{\mathbf{i-1}}\}$ and then build an edge between each retrieved chunk $\mathbf{c}_{\mathbf{j}}\in\{\mathbf{c}_{\mathbf{1}},\cdots,\mathbf{c}_{\mathbf
{K}}\}$ and the newly generated LLM response $\mathbf{r}_{\mathbf{i}}$, resulting in $\mathbf{K}$ edges constructed in each round.
Note that we append the responses generated by each round of RAG to the retrieval corpus because they contain more refined knowledge compared with the text chunks from $\mathbf{C}$ and can help LLMs generate comprehensive responses in a self-evolving manner.
Formally, the $\mathbf{i}$-th round RAG on simulated queries $\{\mathbf{q}^{\mathbf{s}}_{i}\}_{i=1}^{|\mathbf{T}|}$ can be described as:

$$ $\mathbf{r}_{\mathbf{i}}=\operatorname{Generation}(\mathbf{q}^{\mathbf{s}}_{ \mathbf{i}},\{\mathbf{c}_{\mathbf{1}},\cdots,\mathbf{c}_{\mathbf{K}}\}),\quad \{\mathbf{c}_{\mathbf{1}},\cdots,\mathbf{c}_{\mathbf{K}}\}=\operatorname{ Retrieval}(\mathbf{q}^{\mathbf{s}}_{\mathbf{i}}|\mathbf{C},\{\mathbf{r}_{ \mathbf{1}},\cdots,\mathbf{r}_{\mathbf{i-1}}\})$ (3) $$

In this way, the LLM-generated responses serve as bridges to connect the originally scattered text chunks $\mathbf{C}$ so that the fine-grained and sophisticated correlations among them can be better modeled and explored.
Furthermore, we can potentially make sufficient use of historical responses generated by LLMs and improve the quality of future LLM responses.

Figure: Figure 2: GoR model architecture. GoR randomly selects text chunks $\mathbf{c}_{\mathbf{i}}$ from long documents to feed into LLMs for query simulation, which are saved as a self-supervised training corpus $\mathbf{T}$ and further used for graph construction inspired by the retrieve-then-generate paradigm in RAG. For model training, GoR leverages GNNs to obtain node embeddings and calculate their similarities to the query embedding. Finally, GoR features contrastive learning and pair-wise ranking objectives based on the node ranking list $\mathbf{M}_{i}$ derived from BERTScore calculation.
Refer to caption: x2.png

### 2.3 BERTScore-based Objective for Self-supervised Training

So far, we have constructed a graph using LLM-generated historical responses during RAG given the simulated queries.
The key in this section lies in designing a reasonable and effective objective function for model optimization.
Considering that some random walk Grover & Leskovec () or propagation-based Zhu & Ghahramani () algorithms are not differentiable, we turn to graph neural networks (GNNs) for learning node embeddings, which are backpropagation-friendly.
Intuitively, given a global summarization query $\mathbf{q}$, our ultimate optimization goal is to make the learned node embeddings adaptively reflect the similarity with the query embedding $\mathbf{E}_{\mathbf{q}}(\mathbf{q})$ by taking the complicated correlations among nodes into account.
However, in global summarization tasks, there are essentially no text chunk indices as labels to indicate which nodes are most relevant for a query since it needs to consider the long document as a whole.
Another naive solution is to use global reference summaries as labels, but there is a gap in supervision signal backpropagation between them and node embeddings because we still need to find out which nodes are most relevant to them.

Therefore, inspired by BERTScore Zhang et al. (), which measures the semantic similarity between the reference and the generated text, we propose to use it to rank all nodes based on the similarity with reference summaries.
By this means, BERTScore fills the gap in the backpropagation so that node embeddings can benefit the indirect supervision signal from the reference summaries.
Nevertheless, global reference summaries contain broad information about long documents, making them highly semantically relevant to many nodes, which will confuse the model optimization direction and degrade the performance (we will discuss it in Section 3.4).

Contrastive Loss Driven by BERTScore. Based on the above observations, we directly reuse the simulated queries $\mathbf{T}=\{(\mathbf{q}^{\mathbf{s}}_{i},\mathbf{c}^{\mathbf{s}}_{i})\}_{i=1}
^{|\mathbf{T}|}$ to serve as self-supervised training data, in which the text chunk $\mathbf{c}^{\mathbf{s}}_{i}$ is highly relevant to the query $\mathbf{q}^{\mathbf{s}}_{i}$ and has more focused content.
Given node embeddings output by the last $L$-th layer of GNNs, for the $i$-th query $\mathbf{q}^{\mathbf{s}}_{i}$, we rank them according to the similarity with the $i$-th text chunk $\mathbf{c}^{\mathbf{s}}_{i}$ and obtain a node embedding ranking list $\mathbf{M}_{i}$, which can be described as:

$$ $\mathbf{M}_{i}=[\mathbf{h}_{+}^{(L)},\mathbf{h}_{1}^{(L)},\cdots,\mathbf{h}_{| \mathbf{C}|+|\mathbf{T}|}^{(L)}]$ (4) $$

where $\mathbf{h}_{+}^{(L)}$ stands for the node embedding with highest similarity. Note that we utilize the context encoder $\mathbf{E}_{\mathbf{c}}(\cdot)$ from the retriever to initialize node embeddings for simplicity.
Then, we regard $\mathbf{h}_{+}^{(L)}$ as the positive while the rest in $\mathbf{M}_{i}$ as negative samples to conduct contrastive learning using InfoNCE van den Oord et al. (), which brings the query $\mathbf{q}^{\mathbf{s}}_{i}$ and the positive sample $\mathbf{h}_{+}^{(L)}$ closer in the semantic embedding space.
We formulate the contrastive training objective as follows:

$$ $\mathcal{L}_{\mathrm{CL}}=-\frac{1}{|\mathbf{T}|}\sum_{j=1}^{|\mathbf{T}|}\log \frac{\exp\left({\mathbf{E}_{\mathbf{q}}(\mathbf{q}^{\mathbf{s}}_{j})}^{\top} \mathbf{h}_{+}^{(L)}/\tau\right)}{\exp\left({\mathbf{E}_{\mathbf{q}}(\mathbf{q }^{\mathbf{s}}_{j})}^{\top}\mathbf{h}_{+}^{(L)}/\tau\right)+\sum_{i=1}^{| \mathbf{M}_{j}-1|}\exp\left({\mathbf{E}_{\mathbf{q}}(\mathbf{q}^{\mathbf{s}}_{ j})}^{\top}\mathbf{h}_{i}^{(L)}/\tau\right)}$ (5) $$

where $\tau$ is the temperature coefficient.
Note that in the optimization pipeline of GoR, we conduct mini-batch training on the graph level, and each graph is associated with an independent self-supervised training dataset $\mathbf{T}$.
We also leverage in-batch negatives from other graphs since the nodes in them are completely irrelevant content from other long documents (it is not shown in Formula 5 for brevity).

Auxiliary Pair-wise Ranking Loss.
In the above-described contrastive loss $\mathcal{L}_{\mathrm{CL}}$, although we impose constraints on positive and negative samples, the ranking of negative samples themselves is not well utilized.
Inspired by LambdaRank Burges (), we further introduce an auxiliary pair-wise ranking loss on the ranking list $\mathbf{M}_{i}$, which can be formulated as:

$$ $\mathcal{L}_{\mathrm{RANK}}=\frac{1}{|\mathbf{T}|}\sum_{k=1}^{|\mathbf{T}|} \sum_{\mathbf{h}_{i}^{(L)},\mathbf{h}_{j}^{(L)}\in\mathbf{M}_{k}}\mathbb{I}_{ \operatorname{r}(\mathbf{h}_{j}^{(L)})>\operatorname{r}(\mathbf{h}_{i}^{(L)})} \log\left(1+e^{{\mathbf{E}_{\mathbf{q}}(\mathbf{q}^{\mathbf{s}}_{k})}^{\top} \mathbf{h}_{j}^{(L)}-{\mathbf{E}_{\mathbf{q}}(\mathbf{q}^{\mathbf{s}}_{k})}^{ \top}\mathbf{h}_{i}^{(L)}}\right)$ (6) $$

where $\operatorname{r}(\cdot)$ denotes the ranking index (e.g., $\operatorname{r}(\mathbf{h}_{+}^{(L)})<\operatorname{r}(\mathbf{h}_{1}^{(L)})$).
Given $\mathbf{h}_{i}^{(L)},\mathbf{h}_{j}^{(L)}\in\mathbf{M}_{k}$ that satisfies $\operatorname{r}(\mathbf{h}_{j}^{(L)})>\operatorname{r}(\mathbf{h}_{i}^{(L)})$, the pair-wise ranking loss will explicitly optimize in the direction of ${\mathbf{E}_{\mathbf{q}}(\mathbf{q}^{\mathbf{s}}_{k})}^{\top}\mathbf{h}_{j}^{(
L)}<{\mathbf{E}_{\mathbf{q}}(\mathbf{q}^{\mathbf{s}}_{k})}^{\top}\mathbf{h}_{i
}^{(L)}$, thus imposing stricter constraints to the pair-wise ranking.

Overall Training Objective.
To sum up, the overall training objective can be formulated as:

$$ $\mathcal{L}=\mathcal{L}_{\mathrm{CL}}+\alpha\cdot\mathcal{L}_{\mathrm{RANK}}$ (7) $$

where $\alpha\in[0,1]$ is a hyper-parameter.
It is worth noting that GoR’s training costs are lightweight since the only trainable module is GNNs, and no human-crafted labels are needed.

## 3 Experiments

### 3.1 Experimental Setup

Datasets.
We evaluate our proposed method on four long-context summarization datasets, i.e., AcademicEval Feng et al. (), QMSum Zhong et al. (), WCEP Gholipour Ghalandari et al. (), and BookSum Kryściński et al. ().
Among them, AcademicEval collects scientific papers from arXiv for abstract writing, given the long inputs of its main body.
QMSum is a query-based summarization dataset, and we only use ”general queries” for evaluating global summarization.
WCEP is a multi-document summarization dataset about news events, while BookSum features long-form narrative summarization.
For metrics, we adopt Rouge-1 (R-1), Rouge-2 (R-2), and Rouge-L (R-L) Lin () to assess the text alignment between the reference summaries and the predicted content generated by our proposed method.
More details about adopted datasets are described in Appendix A.

Implementation Details.
Following the standard procedure of RAG, we adopt TokenTextSplitter from LangChain(^1^11 https://www.langchain.com/) to split each long document into text chunks. Each chunk has a size of 256, and the chunk overlapping is 32.
We generate 30 queries for each long document using Mixtral-8x7B-Instruct-v0.1 Jiang et al. (), and the temperature coefficient is set to 0.5 by default in the query simulation stage.
For RAG, we use Contriever Izacard et al. () for query and document embedding and retrieve 6 text chunks by default, which are fed into LLaMA-2-7b-chat Touvron et al. () with greedy decoding to generate predicted summaries.

In the training stage, we initialize the graph neural network as a two-layer graph attention network (GAT) Veličković et al. (), with a 768-dim hidden dimension following the default setting of most retrievers.
The batch size is 32, and the max training epoch is set to 150.
We use Adam optimizer for model training and gradually decay the learning rate from 1e-3 to 0 with LambdaLR scheduler.
The dropout rate and loss coefficient $\alpha$ depend on the specific dataset, and we detail them in Appendix A.
We implement our proposed method using PyTorch(^2^22 https://pytorch.org/) and Deep Graph Library (DGL)(^3^33 https://www.dgl.ai/), and all the experiments are conducted on a single RTX 3080 GPU.
As for LLMs, we rely on API calling from Together AI(^4^44 https://www.together.ai/) to obtain responses.

Baselines.
To have a comprehensive evaluation, we compare our proposed GoR with dozens of baselines, including (1) Random Walk based Node Embedding (i.e., Node2Vec Grover & Leskovec ()), (2) Sparse Retriever (i.e., BM25 Robertson et al. () and TF-IDF Ramos et al. ()), (3) Dense Retriever (i.e., Contriever Izacard et al. (), DPR Karpukhin et al. (), Dragon Lin et al. (), and Sentence-BERT (SBERT) Reimers & Gurevych ()(^5^55 We use all-MiniLM-L6-v2 as the backbone.)), (4) Hybrid Retriever (i.e., BM25+DPR with Reciprocal Rerank Fusion), (5) Long-context LLMs (i.e., Gemma-8K Team et al. () and Mistral-8K Jiang et al. ()), (6) Full Context (i.e., feeds all inputs to LLMs for summary generation(^6^66 If the input length exceeds the context window limit, we randomly sample continuous text spans of maximum length multiple times to feed into LLMs and calculate the average result.)), and (7) Thought Retriever (Thought-R) Feng et al. ().

### 3.2 Main Results

**Table 1: Experimental results on QMSum, AcademicEval, WCEP, and BookSum datasets over long-context global summarization tasks w.r.t. Rouge-L (R-L), Rouge-1 (R-1), and Rouge-2 (R-2). Note that the average LLM input token length of GoR and retriever-based baselines is $6\times 256$, which is about 1.5K. (BOLD indicates the best score)**
| Model | QMSum | AcademicEval | WCEP | BookSum |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| R-L | R-1 | R-2 | R-L | R-1 | R-2 | R-L | R-1 | R-2 | R-L | R-1 | R-2 |  |
| Node2Vec | 18.5 | 31.8 | 6.3 | 19.3 | 38.3 | 10.6 | 13.9 | 20.1 | 6.3 | 13.6 | 27.4 | 4.6 |
| BM25 | 18.4 | 32.1 | 6.1 | 20.4 | 39.6 | 11.3 | 15.5 | 22.6 | 7.3 | 13.7 | 26.7 | 4.9 |
| TF-IDF | 18.3 | 31.2 | 6.3 | 19.5 | 38.0 | 10.6 | 15.3 | 22.3 | 7.3 | 13.6 | 26.6 | 4.9 |
| Contriever | 19.1 | 32.7 | 7.7 | 23.6 | 44.8 | 16.0 | 15.7 | 23.5 | 7.7 | 14.4 | 29.8 | 5.5 |
| DPR | 18.6 | 32.1 | 6.7 | 20.9 | 41.4 | 13.2 | 15.6 | 22.5 | 7.5 | 13.8 | 27.1 | 4.8 |
| Dragon | 19.2 | 33.5 | 7.7 | 23.5 | 43.8 | 15.1 | 14.6 | 21.8 | 6.8 | 13.7 | 27.2 | 4.8 |
| SBERT | 19.0 | 33.0 | 7.4 | 23.4 | 45.2 | 15.8 | 13.7 | 20.5 | 5.5 | 14.4 | 29.5 | 5.4 |
| BM25+DPR | 18.3 | 31.8 | 6.6 | 19.9 | 39.0 | 10.8 | 15.7 | 22.1 | 7.6 | 14.1 | 28.9 | 5.4 |
| Gemma-8K | 19.8 | 33.5 | 7.3 | 21.9 | 42.0 | 12.9 | 15.6 | 21.9 | 7.7 | 12.8 | 23.4 | 4.2 |
| Mistral-8K | 19.6 | 31.2 | 7.2 | 21.6 | 41.6 | 13.1 | 16.7 | 24.2 | 8.8 | 13.5 | 26.2 | 5.3 |
| Full Context | 19.4 | 33.1 | 6.8 | 21.5 | 41.1 | 12.5 | 14.4 | 21.0 | 7.1 | 14.4 | 28.9 | 5.9 |
| Thought-R | 19.0 | 33.9 | 7.6 | 22.0 | 42.6 | 13.2 | 15.2 | 22.4 | 7.4 | 14.2 | 29.5 | 5.7 |
| GoR (Ours) | 19.8 | 34.5 | 7.8 | 24.7 | 46.5 | 17.3 | 18.1 | 25.4 | 9.2 | 14.9 | 31.5 | 6.6 |

We conduct comprehensive experiments on QMSum, AcademicEval, WCEP, and BookSum datasets compared with dozens of baselines to evaluate the long-context global summarization capabilities of our proposed method. The results are shown in Table 1.

GoR consistently outperforms retriever-based methods.
From Table 1, our proposed GoR beats sparse retrievers, dense retrievers, and hybrid retrievers in every aspect.
Thanks to the constructed graph, which integrates text chunks from long documents and LLM historical responses into a whole, node embeddings can better reflect the complicated correlations with given queries, thus significantly improving the retrieval performance of GoR.
Moreover, the informative content of historical responses can also potentially enhance the summarization task.

GoR shows superiority over long-context LLMs.
We compare Gemma-8K and Mistral-8K with a longer context window to accommodate long-context inputs. However, longer inputs may contain minor information, and long-context LLMs struggle with this situation. In contrast, GoR can effectively differentiate key and topic-related content in long texts using learned node embeddings and achieve better results with shorter input lengths.

Additional Findings.
(1) Node2Vec produces unsatisfactory results, and the node embeddings cannot be optimized effectively since it is based on a non-differentiable algorithm.
(2) Although Thought Retriever demonstrates competitive results, it is still inferior to GoR due to the lack of exploration of the correlations between retrieved text chunks and LLM-generated responses.
(3) Since the context window length limit of LLMs is exceeded, “Full Context” truncates the long-context input, thus losing some information that may be important for global summarization, resulting in suboptimal results.

Overall, GoR achieves the best results compared with various baselines, demonstrating the effectiveness of our proposed method.

**Table 2: Ablation study on QMSum, AcademicEval, WCEP, and BookSum datasets w.r.t. R-L, R-1, and R-2. (BOLD indicates the best score)**
| Variant | QMSum | AcademicEval | WCEP | BookSum |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| R-L | R-1 | R-2 | R-L | R-1 | R-2 | R-L | R-1 | R-2 | R-L | R-1 | R-2 |  |
| w/o train | 18.2 | 33.0 | 7.6 | 23.3 | 45.0 | 15.5 | 15.3 | 22.4 | 7.4 | 13.7 | 27.7 | 4.7 |
| w/o $\mathcal{L}_{\mathrm{CL}}$ | 18.4 | 33.3 | 6.9 | 23.5 | 44.9 | 15.5 | 14.7 | 21.9 | 7.2 | 14.1 | 28.8 | 5.1 |
| w/o $\mathcal{L}_{\mathrm{RANK}}$ | 19.6 | 33.1 | 7.8 | 23.1 | 44.4 | 15.1 | 16.6 | 24.2 | 8.2 | 14.0 | 28.0 | 4.9 |
| w/o in-b neg | 19.8 | 34.7 | 7.8 | 24.5 | 46.4 | 16.5 | 17.2 | 24.9 | 8.8 | 13.3 | 26.3 | 5.2 |
| w/ sup | 18.1 | 32.3 | 6.9 | 21.4 | 43.3 | 13.9 | 15.5 | 22.8 | 7.3 | 13.8 | 29.0 | 5.2 |
| GoR (Ours) | 19.8 | 34.5 | 7.8 | 24.7 | 46.5 | 17.3 | 18.1 | 25.4 | 9.2 | 14.9 | 31.5 | 6.6 |

### 3.3 Ablation Study

To investigate how each component of GoR contributes to its performance, we conduct an ablation experiment, and the results are shown in Table 2.

From Table 2, we can draw several conclusions.
(1) Directly using the text embeddings from the retriever without training leads to degraded performance (i.e., w/o train), highlighting the effectiveness of the learned node embeddings.
(2) Both the contrastive loss $\mathcal{L}_{\mathrm{CL}}$ and pair-wise ranking loss $\mathcal{L}_{\mathrm{RANK}}$ significantly improve performance. The pair-wise ranking loss imposes stricter ranking constraints on node embeddings, making effective use of the indirect supervision signal from the self-supervised reference summaries.
(3) In-batch negatives are crucial to the performance of contrastive learning. Removing in-batch negatives (i.e., w/o in-b neg) leads to a significant drop in results, especially on the WCEP and BookSum datasets.
(4) Compared with self-supervised training, we utilize global reference summaries as labels to conduct supervised training (i.e., w/ sup), and the results are significantly worse than the self-supervised setting. We will further discuss it in Section 3.4.

In general, GoR’s reasonable module design enables it to achieve superior performance.

### 3.4 Discussions

Impact of GNN Architectures.
GNNs play a vital role in learning node embeddings. we explore various GNN architectures to study their impact on learning node embeddings, including GCN Kipf & Welling (), SGC Wu et al. (), GIN Xu et al. (), and GraphSAGE Hamilton et al. (). Our findings, illustrated in Figure 3, show that GAT outperforms the other architectures. This is because GAT considers the significance of neighboring nodes when updating node embeddings, allowing the model to effectively capture essential information from the nodes.
Among the other architectures, GraphSAGE performs poorly due to its unstable neighbor sampling mechanism.

Overall, GAT reaches the best results, which shows that considering the importance of neighboring nodes is effective in mining complicated correlations and is critical to improving performance.

Figure: Figure 3: Impact of GNN architectures w.r.t. R-L, R-1, and R-2. The left figure shows results on the WCEP dataset, while the right one shows results with the BookSum dataset.
Refer to caption: x3.png

Impact of the Number of Simulated Queries During Training.
Query Simulation is a crucial stage in our method design, and we will discuss the impact of the number of simulated queries used during training on learning performance. In particular, we explore this effect by gradually increasing the number of simulated queries used in training.
We present the results in Figure 4. From a holistic perspective, R-L shows an upward trend as the number of simulated queries increases. Nevertheless, since fewer queries cover less relevant content from long documents, the curves of each dataset have some fluctuations, indicating the occurrence of underfitting.

In general, 30 simulated queries can optimize the model well across these four datasets, which indicates that our proposed GoR is cost-effective.
Nevertheless, increasing the number of simulated queries may still potentially further improve the performance of the model. Due to budget constraints, we will leave this for future work.

Figure: Figure 4: Impact of the number of simulated queries during training w.r.t. R-L. We show the results on the four datasets QMSum, AcademicEval, WCEP, and BookSum from left to right.
Refer to caption: x5.png

Supervised Training on Global Summarization Queries.
To dive deeper into the differences between self-supervised and supervised training, we carry out additional experiments using global reference summaries.
Specifically, we utilize global summarization queries and reference summaries to serve as a training corpus under the supervised setting.
As there is only one global summarization query for each long document, we replicate it multiple times to match the quantity of self-supervised training data, thus eliminating the impact of the quantity difference.
We present the results on the WCEP and BookSum datasets in Figure 5, and the Entropy denotes the entropy of the similarity distribution between queries and node embeddings.

From Figure 5, it is evident that in the self-supervised setting, the loss is consistently lower than in the supervised setting.
This suggests that the global reference summaries are highly correlated with many nodes, causing most nodes to exhibit a high semantic similarity with the global query.
As a result, this confuses the model’s optimization direction.
Additionally, the entropy curve shows that the entropy in the supervised setting is consistently higher than in the self-supervised setting, indicating that the model struggles to select the most similar node.
In contrast, the self-supervised label, derived from a specific part of a long document, contains more focused content and can more effectively guide the model’s optimization direction.

Figure: Figure 5: Differences between self-supervised and supervised training w.r.t. loss and entropy. We show the loss and entropy curve during training on the WCEP and BookSum datasets from left to right.
Refer to caption: x9.png

## 4 Related Work

Long-context Summarization using LLMs.
In recent years, LLMs have demonstrated their excellent capabilities in long-context modeling Achiam et al. (); AI@Meta (); Team et al. (); Jiang et al. ().
Current approaches for summarizing long documents using LLMs are mainly divided into two categories: retrieval-augmented generation (RAG) Ram et al. (); Yu et al. () and long-context LLMs GLM et al. (); Li* et al. (); Tworkowski et al. ().
Long-context LLMs feature a large context window length to accommodate long-context inputs.
However, they may suffer from severe performance degradation when accessing some local key details in the middle of long contexts Liu et al. ().
In contrast, RAG emerges as a promising approach for cost-effective long-context summarization.
By equipping with a retriever Karpukhin et al. (); Robertson et al. (), RAG can first perform a relevance search based on user queries and then feed the retrieved text into LLMs for summary.
For a recent example, GraphRAG Edge et al. () conducts query-focused summarization by setting up a graph index and detecting graph communities for summary generation.

Nevertheless, most current RAG approaches still focus on enhancing LLMs’ reasoning and question-answering capabilities, which only require retrieving locally relevant information Trivedi et al. (); Jiang et al. (); Asai et al. (); Li et al. (); Zheng et al. ().
In comparison, our proposed method stands out from these methods by focusing on LLMs’ global summarization capability of long-context inputs.

Historical Response Utilization of LLMs.
Little work has been done on this under-explored topic.
Thought-retriever Feng et al. () saves the historical responses of each user-LLM interaction as high-level and informative thoughts to expand the retrieval corpus for future user queries.
However, the intricate correlations among thoughts are neglected, leaving room for further improvement.

Another line of work is the Chain-of-Thought (CoT), which is similar to our approach in terms of utilizing LLM historical responses and has been regarded as an effective means to enhance the reasoning ability of LLM during inference time in recent years.
Few-shot CoT Wei et al. () and zero-shot CoT Kojima et al. () elicit intermediate reasoning paths by prompting LLMs with several demonstrations or just appending ”Let’s think step by step.”
Self-consistency Wang et al. () samples diverse reasoning paths and conducts a majority vote to obtain the final answer.
ToT Yao et al. () and GoT Besta et al. () take a further step by integrating a tree or graph structure to manage its historical reasoning paths, enabling more flexible reasoning and reflection of LLMs.
By memorizing the solution paradigms of various queries into different templates, BoT Yang et al. () pushes LLM’s reasoning ability to a new level.
Although the above-mentioned CoT-series approaches improve the reasoning capabilities of LLMs by utilizing chains of intermediate reasoning responses, they usually concentrate on one specific QA-type query and cannot generalize to and benefit other queries.
Moreover, only a small number of historical reasoning responses are retained for the final generation, while most of the rest are just discarded.

Graph-assisted Retrieval-augmented Language Models.
As one of the effective structures for modeling data relations, graphs have recently been used to enhance the performance of retrieval-augmented language models on various QA tasks.
EtD Liu et al. () features a graph neural network (GNN) to traverse a knowledge graph hop by hop to discover more relevant knowledge, thus enhancing LLM generation quality.
GNN-RAG Mavromatis & Karypis () learns to reason over graphs using GNNs, and retrieves answer candidates for a given question.
PG-RAG Liang et al. () constructs pseudo-graphs with a retrieval indexer by prompting LLMs to organize document knowledge in a self-learning manner.
G-RAG Dong et al. () proposes to rerank documents by learning graph representation on abstract meaning representation graphs, while GNN-Ret Li et al. () refines semantic distances between documents and queries by modeling relationships among related passages.
ToG Sun et al. () and KGP Wang et al. () treat LLMs as agents to traverse and reason over knowledge graphs in an iterative way, while RoG Luo et al. () first generates plans for retrieval and then conducts reasoning.
G-Retriever He et al. () transforms retrieved knowledge subgraphs into graph embeddings by training a graph encoder and textualizes subgraphs to serve as inputs of LLMs.

Different from the above, GraphRAG Edge et al. () sets up a graph index for query-focused summarization, which is more relevant to our proposed approach.
Compared with GraphRAG, which is time-consuming and suffers from huge computational costs, our proposed GoR is lightweight and only draws on a few LLM historical responses with efficient training to achieve competitive performance.

## 5 Conclusion

In this work, we introduce a method named graph of records (GoR) to improve long-context global summarization in retrieval-augmented generation (RAG) by utilizing LLM-generated historical responses.
Intuitively, we establish connections between text chunks retrieved from long documents and LLM-generated historical responses to create a graph of records.
To uncover complex correlations between these connections, we use a graph neural network and develop a BERTScore-based objective for self-supervised training.
This allows for seamless supervision signal backpropagation between self-supervised reference summaries and node embeddings.
In our experiments, we assess our proposed method on four long-context summarization datasets, and the results consistently demonstrate that GoR outperforms numerous baselines by a significant margin, highlighting its effectiveness.

Despite the superiority of our proposed method, GoR has some limitations.
(1) Due to a limited budget, we only simulate and generate a small number of user queries, which may cause a bottleneck in further model optimization.
(2) The simulated queries may not accurately reflect the real-world distribution, as they do not account for the possibility of users asking many meaningless questions. Therefore, a filtering process may be necessary, which we leave for future work.

#### Acknowledgments

We gratefully acknowledge the support of the Illinois Campus Cluster, a computing resource that is operated by the Illinois Campus Cluster Program (ICCP) in conjunction with the National Center for Supercomputing Applications (NCSA) and which is supported by funds from the University of Illinois at Urbana-Champaign.

## Ethics Statement

The security of Large Language Models (LLMs) has always been a concern. Unfortunately, current LLMs sometimes produce harmful and biased information unexpectedly. Our proposed method uses LLMs to generate simulated queries and summary responses, which are only used to construct a graph of records and connect text chunks from long documents. However, more work is needed in real-world applications to ensure that LLMs’ responses are reliable and harmless, so that they do not harm users.

## Reproducibility Statement

In the experimental setup phase 3.1, we clearly describe the open-source LLMs used in this paper (Mixtral-8x7B-Instruct-v0.1 Jiang et al. () and LLaMA-2-7b-chat Touvron et al. ()), the data preprocessing details (including RAG-related chunk size settings and dataset descriptions, etc.), and the training hyper-parameters.
Moreover, we provide all the prompts used in this work in Appendix B.
More detailed information can be found in the Appendix.
The above description ensures the reproducibility of this work.

## Appendix A Experimental Details

### A.1 Dataset

We present dataset statistics in Table 3.
Due to the limited budget, we randomly select training and test samples for the training and test set and calculate the average input and output token lengths using the LLaMA-2 tokenizer Touvron et al. () (samples with short input lengths are filtered out).

We evaluate our proposed method on four long-context summarization datasets, i.e., AcademicEval Feng et al. (), QMSum Zhong et al. (), WCEP Gholipour Ghalandari et al. (), and BookSum Kryściński et al. ().

- •
QMSum Zhong et al. (). QMSum is a query-based summarization dataset that features lengthy meeting transcripts, specific queries, and general queries. Specific queries focus on query-based summarization, and general queries are questions that summarize the entire meeting transcript, such as “Summarize the whole meeting.”
We only use ”general queries” for evaluating global summarization.
- •
AcademicEval Feng et al. (). AcademicEval collects scientific papers from arXiv for abstract and related work writing. We use the abstract writing subset, which provides the main body of a paper as input and generates the predicted abstract.
- •
WCEP Gholipour Ghalandari et al. (). WCEP is a multi-document summarization dataset about news events, which requires comprehensive consideration of the contents of multiple documents.
- •
BookSum Kryściński et al. (). BookSum features long-form narrative summarization, which covers source documents from the literature domain and includes highly abstractive human-written summaries.

**Table 3: Dataset statistics**
| Dataset | #Train | #Test | Average Input<br>Token Length | Average Output<br>Token Length |
| --- | --- | --- | --- | --- |
| QMSum Zhong et al. () | 162 | 30 | 17K | 0.1K |
| AcademicEval Feng et al. () | 400 | 30 | 13K | 0.3K |
| WCEP Gholipour Ghalandari et al. () | 400 | 30 | 11K | 0.05K |
| BookSum Kryściński et al. () | 400 | 30 | 16K | 1K |

### A.2 Baselines

We present detailed descriptions of adopted baselines.

- •
Node2Vec Grover & Leskovec (). Node2Vec generates node embeddings for graphs by simulating biased random walks to capture both local and global structural properties of nodes.
- •
BM25 Robertson et al. (), TF-IDF Ramos et al. (). BM25 ranks documents based on term frequency, inverse document frequency, and document length normalization, while TF-IDF evaluates the importance of a term in a document relative to a corpus by combining term frequency and inverse document frequency.
- •
Contriever Izacard et al. (), DPR Karpukhin et al. (), Dragon Lin et al. (), SBERT Reimers & Gurevych (). Contriever is a self-supervised dense retriever that learns unsupervised document embeddings for information retrieval, DPR (Dense Passage Retriever) is a bi-encoder model that retrieves relevant passages by training on question-passage pairs, Dragon is a dense retrieval model optimized through diverse augmentation for generalizable dense retrieval, and SBERT (Sentence-BERT) is a modification of BERT that generates semantically meaningful sentence embeddings for tasks like similarity and clustering using a siamese network structure.
- •
BM25+DPR. BM25+DPR with Reciprocal Rerank Fusion is a hybrid retrieval method that combines the strengths of BM25’s lexical matching and DPR’s dense embeddings by reranking results from both models using a reciprocal rank fusion strategy to improve retrieval accuracy.
- •
Gemma-8K Team et al. (), Mistral-8K Jiang et al. (). Gemma-8K and Mistral-8K are LLMs with relatively long context window lengths.
- •
Full Context. We feed all inputs to LLMs for summary generation. If the input length exceeds the context window limit, we randomly sample continuous text spans of maximum length multiple times to feed into LLMs and calculate the average result.
- •
Thought-R Feng et al. (). Thought Retriever (Thought-R) generates thoughts for a series of simulated queries and appends them to the retrieval corpus as high-level knowledge.

### A.3 Additional Implementation Details

In the stage of graph construction, due to the number and randomness of the simulated queries, there may be some isolated nodes, and we just keep them in the graph with self-loop edges. During model optimization, BERTScore is pre-computed for efficient training. We present hyper-parameters on QMSum, AcademicEval, WCEP, and BookSum datasets in Table 4.

For metrics, we adopt Rouge-1 (R-1), Rouge-2 (R-2), and Rouge-L (R-L) Lin () to assess the text alignment between the reference summaries and the predicted content generated by our proposed method.
If a global summarization query has multiple reference summaries, we calculate the Rouge-L/1/2 of the predicted summary and all references, respectively, and take the maximum value as the final evaluation result. We follow this setting in all experiments, including the baseline evaluation.

**Table 4: Hyper-parameters**
| Datasets | QMSum | AcademicEval | WCEP | BookSum |
| --- | --- | --- | --- | --- |
| #GAT Layers | 2 | 2 | 2 | 2 |
| #GAT Heads | 4 | 4 | 4 | 4 |
| Batch Size | 32 | 32 | 32 | 32 |
| Epoch | 150 | 150 | 150 | 150 |
| Learning Rate | 1e-3 | 1e-3 | 1e-3 | 1e-3 |
| Hidden Dimension | 768 | 768 | 768 | 768 |
| Dropout Rate | 0.2 | 0.0 | 0.1 | 0.2 |
| Loss Coefficient $\alpha$ | 0.9 | 0.6 | 0.7 | 0.2 |

### A.4 Additional Experimental Results

We conduct extensive experiments on GovReport Huang et al. () and SQuALITY Wang et al. () datasets, and the results are shown in Table 5, which demonstrate our proposed GoR is still competitive among baselines on these two datasets.

**Table 5: Experimental results on GovReport and SQuALITY datasets over long-context global summarization tasks w.r.t. Rouge-L (R-L), Rouge-1 (R-1), and Rouge-2 (R-2). Note that the average LLM input token length of GoR and retriever-based baselines is $6\times 256$, which is about 1.5K. (BOLD indicates the best score)**
| Model | GovReport | SQuALITY |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| R-L | R-1 | R-2 | R-L | R-1 | R-2 |  |
| Node2Vec | 18.1 | 36.7 | 12.4 | 17.0 | 32.9 | 7.7 |
| BM25 | 18.2 | 39.2 | 13.0 | 17.0 | 31.4 | 8.1 |
| TF-IDF | 18.1 | 39.2 | 12.8 | 17.0 | 31.4 | 8.1 |
| Contriever | 20.2 | 39.8 | 17.6 | 16.8 | 32.6 | 8.3 |
| DPR | 19.1 | 39.4 | 15.5 | 17.4 | 33.1 | 8.4 |
| Dragon | 19.6 | 38.2 | 16.0 | 16.2 | 29.6 | 7.5 |
| SBERT | 20.0 | 39.8 | 15.8 | 17.1 | 32.1 | 7.8 |
| BM25+DPR | 19.4 | 37.4 | 15.0 | 16.6 | 31.5 | 7.4 |
| Gemma-8K | 17.4 | 33.8 | 11.4 | 12.9 | 19.7 | 5.8 |
| Mistral-8K | 16.0 | 28.9 | 9.4 | 16.9 | 32.2 | 8.1 |
| Full Context | 18.4 | 39.1 | 13.8 | 17.8 | 34.0 | 8.8 |
| Thought-R | 20.4 | 40.3 | 17.0 | 17.3 | 32.0 | 8.0 |
| GoR (Ours) | 20.9 | 41.4 | 16.8 | 17.8 | 34.0 | 8.5 |

## Appendix B LLM Prompts

In this section, we present LLM prompts used in GoR, including user query simulation and RAG prompts.

### B.1 LLM Prompts for User Query Simulation

### B.2 LLM Prompts for RAG

## Appendix C Broader Impacts

In the era of LLMs, countless interactions take place between users and these models on a daily basis, resulting in the generation of a vast amount of historical responses. Our proposed method demonstrates that these historical responses hold significant potential and can be effectively leveraged to further improve the quality of future responses generated by LLMs. By analyzing and reusing these past outputs, we can not only refine and enhance the overall performance of the models but also reduce computational overhead. This approach highlights the untapped value of historical data in optimizing response generation while making the process more efficient and resource-friendly.

## Peer Reviews

confidence: 5
contribution: 3
initial_rating: 6
presentation: 3
questions: I have no further questions about this paper. I am inclined to give it a weak positive score and will review the feedback from other reviewers before finalizing my assessment.
soundness: 3
strengths: 1. The paper is well-structured, with clear explanations and logically organized sections, making it easy for readers to follow the methodology and findings.

2. The authors test GoR on four long-context summarization datasets, and the comprehensive evaluation against a variety of baselines (including both sparse and dense retrievers) demonstrates the robustness and generalizability of the method.

3. The proposed approach builds upon existing RAG techniques, making it relatively easy to implement and reproduce, which is valuable for the research community and practical applications.
summary: The paper introduces the Graph of Records (GoR), a novel method designed to enhance retrieval-augmented generation (RAG) systems for long-context summarization using graph structures. RAG systems improve factuality and relevance in summarization by retrieving relevant content chunks and generating summaries based on those chunks. GoR innovates on traditional RAG by constructing a graph of linked nodes where historical user queries, LLM-generated responses, and retrieved text chunks are interconnected. This graph structure is then refined using a graph neural network (GNN), enabling the model to capture complex relationships between text chunks and responses. By employing a BERTScore-based self-supervised learning objective, GoR aligns node embeddings with semantic relevance to improve summarization accuracy. The model outperforms several baselines across four long-context summarization datasets (e.g., QMSum, AcademicEval), showcasing its effectiveness in creating more comprehensive summaries.
weaknesses: I didn’t find significant weaknesses in this paper. The entire architecture is built on existing modules, making the proposed framework both sound and replicable. However, this reliance on established methods might also be a limitation, as the framework feels less innovative or exciting despite being well-presented with informative experimental results.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: 1. What are Ec and Eq context encoders in line 224-230? Are they also optimized by eq. 7? 
2. The paper mentioned BERTscore many times in this paper but how does BERTscore contribute to the GoR? 
3. In both contrastive learning and ranking loss, what is the motivation of  choosing the positive samples based on the semantic similarity from the encoder? 
4. Provide a case study of GoR and other baseline methods' summarization.
soundness: 2
strengths: 1. Introduces an innovative approach to integrate LLMs' intermediate summaries with original document chunks in a structured graph representation
2. Implements an efficient sparse connectivity strategy using top-K similar textual chunks, reducing computational complexity while maintaining information flow
3. This hierarchical structure effectively bridges local and global document understanding
4. Develops a well-motivated semantic alignment mechanism for the GNN by leveraging BERTScore-based similarities
5. Employs a dual-objective training strategy combining contrastive learning and pairwise ranking loss
6. This approach ensures the GNN's representations capture meaningful semantic relationships beyond surface-level textual similarity
7. Provides a thorough analysis of existing long-context summarization approaches, clearly identifying their limitations
8. Effectively positions the work within two key research streams: retrieval-augmented generation and graph-based document processing
9. Demonstrates clear technological advancement over previous methods through thoughtful experimental design
summary: This paper presents a novel retrieval-augmented generation (RAG) approach for long-context document summarization. The method leverages a graph neural network (GNN) to retrieve relevant information from structured textual nodes. These nodes comprise two types of content: (1) original text chunks from the source document and (2) intermediate summaries previously generated by large language models (LLMs). To optimize the GNN retriever, the authors propose aligning the GNN's representations with semantic similarities from textual encoder, creating a more semantically-aware retrieval mechanism.

Key contributions include:

- A hierarchical text representation using GNNs that combines both source text and intermediate summaries
- A novel training objective that aligns GNN embeddings with semantic similarity metrics
- An end-to-end framework that integrates retrieval and generation for long-document summarization
weaknesses: 1. Clarity and Presentation Issues: 
- **Problem Definition** : Lacks a dedicated subsection that formally defines long-context summarization; Missing explicit comparison between GoR and existing RAG approaches for long-context summarization in the introduction; Would benefit from a clear positioning diagram or framework overview

- **Technical Clarity** : Graph construction description (lines 147-194) lacks sufficient detail and clear visualization; Equation 3's retrieval mechanism is ambiguous about whether it includes LLM-generated responses or only original document chunks; The relationship between the proposed contrastive learning approach and BERTScore needs clearer explanation; The semantic alignment objective would benefit from step-by-step derivation


2. Limited Evaluation Metric: Over-reliance on ROUGE metrics for evaluation; Absence of crucial evaluation metrics: Human evaluation for factual consistency and coherence; BERTScore for semantic similarity assessment; Coverage metrics for long-document comprehension.

3. Insufficient Analysis of Critical Components: Lacks detailed analysis of edge creation strategy between document chunks and LLM responses; Insufficient investigation of the impact of LLM-generated responses; No comparative analysis showing the benefit of including historical LLM responses.

---

confidence: 3
contribution: 3
initial_rating: 3
presentation: 2
questions: Please see weakness
soundness: 2
strengths: Innovative Use of Historical Responses: The paper introduces a novel approach by leveraging LLM-generated historical responses for enhancing RAG, which is largely neglected by existing methods. This approach enriches the summarization process, potentially increasing the relevance and depth of generated summaries.
summary: This paper proposes a novel method called GoR (Graph of Records) to enhance RAG in long-context global summarization tasks. GoR utilizes historical responses generated by LLMs to construct a graph structure that connects retrieved text chunks with their corresponding responses. This paper further employs a graph neural network and BERTScore-based self-supervised training to reveal correlations between them. Experimental results show that GoR outperforms 12 baselines across four long-context summarization datasets, demonstrating its effectiveness in improving summarization quality.
weaknesses: __I.__ Computational Efficiency Evaluation: The paper lacks experimental validation of computational efficiency. The reliance on LLM-generated responses and retrieved chunk graphs, combined with the incorporation of graph neural networks and BERTScore-based objectives, could introduce substantial computational overhead.

__II.__ Dependency on Data Quality: The effectiveness of GoR may rely heavily on the quality and coherence of the historical responses generated by LLMs. Inconsistencies in these responses could impact the model's overall summarization performance.

__III.__ The quality of the presentation is below ICLR 2025 standards. For example:

  a. The format of the references should be consistent to ensure neatness and professionalism. For instance, the names of conferences should be uniformly presented either in abbreviations or full names, rather than a mixture of both.

  b. For the line 265, it should be written as “we only use “general queries” for evaluating”, and the symbol use is wrong.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. The authors discuss the impact of different GNN architectures; however, a more fundamental research question remains: does the constructed structure itself actually improve performance? A follow-up question is: does the LLM's historical responses are really helpful, as claimed by the authors? I understand these are challenging to address, but the paper could benefit from empirical studies, such as ablation experiments on the constructed graph (e.g., ablating the response nodes).

2. A small issue for the presentation. In the analysis on L424, a more informative metric on the x-axis might be the number of tokens used for training. Increasing the number of simulated queries also scales the number of responses generated by the LLM, meaning the model could benefit from both the queries and the additional response tokens.

3. I would appreciate a comparison of inference time per query for the baselines in the main table. This information is valuable for readers interested in inference efficiency for deployment.

4. Regarding "Supervised Training on Global Summarization Queries," are you referring to a baseline where LLaMA-2-7B-chat is fine-tuned using supervised training on global summarization queries and reference summaries?

5. Would it make sense to add query nodes between the response and context nodes in the graph? My intuition is that query nodes could help the model better understand logical constraints between context and response (e.g., negation).
soundness: 2
strengths: 1. Using LLM's parametric knowledge—referred to as historical responses in this paper—to enhance retrieval-augmented generation (RAG) is a valuable addition to the static corpus used in traditional RAG. The authors claim to be the first to apply this approach to long-document summarization.
2. The experimental results are promising, though some analyses may not fully address the research question.
3. The paper is well-written and easy to follow.
summary: This paper presents GoR, a retrieval-augmented generation method aimed at enhancing the summarization of long documents. The authors propose a novel approach to distilling the knowledge of large language models (LLMs) to improve retrieval by incorporating both historical LLM responses and text chunks into a structured graph. Their second key contribution is a comprehensive framework for training a graph neural network (GNN)-based retriever on this graph, learning to rank chunk and response nodes using contrastive and ranking objectives. Experimental comparisons with traditional retrievers and long-context LLMs demonstrate the advantages of GoR in long-document summarization.
weaknesses: 1. The analyses lack sufficient convincing evidence. See the “Questions” section for more details.
2. The graph construction process is complex, which could potentially increase inference time—a critical factor in RAG systems.

Meta-review: **Summary:** 
The paper proposes Graph of Records (GoR), a method to enhance RAG for long-context summarization by leveraging LLM-generated historical responses, which are often neglected. GoR constructs a graph that links retrieved text chunks with their corresponding LLM responses, enabling the discovery of complex correlations through a GNN. A self-supervised training framework using a BERTScore-based objective ranks node embeddings by their relevance to global summaries, supported by contrastive and pairwise ranking losses. Evaluated on several long-context summarization datasets, the proposed method outperforms baselines, demonstrating its effectiveness in modeling and utilizing historical response data to improve summarization quality.

**Strength:** 
- The framework is sound, replicable, and built on established modules, ensuring reliability. The experimental results are informative and well-presented.
- Hierarchical structure seems to effectively bridge local and global document understanding

**Weakness:*
- The reliance on established methods might also be a limitation.
- Missing a formal definition of long-context summarization and a clear comparison with existing RAG approaches.
- Heavy reliance on ROUGE metrics, with no human evaluation or additional metrics like BERTScore or coverage for long-document comprehension.

Decision: Reject