CFT-RAG: An Entity Tree Based Retrieval Augmented Generation Algorithm With Cuckoo Filter
Authors: Zihang Li
Yangdong Ruan
Wenjun Liu
Zhengyang Wang
Tong Yang
Venue: ICLR 2026 Poster (2026)
Keywords: Retrieval-Augmented Generation
Tree-RAG
Cuckoo Filter
Knowledge Retrieval
Primary area: applications to computer vision, audio, language, and other modalities

Abstract: Although retrieval-augmented generation(RAG) significantly improves generation quality by retrieving external knowledge bases and integrating generated content, it faces computational efficiency bottlenecks, particularly in knowledge retrieval tasks involving hierarchical structures for Tree-RAG. This paper proposes a Tree-RAG acceleration method based on the improved Cuckoo Filter, which optimizes entity localization during the retrieval process to achieve significant performance improvements. Tree-RAG effectively organizes entities through the introduction of a hierarchical tree structure, while the Cuckoo Filter serves as an efficient data structure that supports rapid membership queries and dynamic updates. The experiment results demonstrate that our method is much faster than baseline methods while maintaining high levels of generative quality. For instance, our method is more than 800% faster than naive Tree-RAG on DART dataset. Our work is available at https://github.com/TUPYP7180/CFT-RAG-2025.

Published as a conference paper at ICLR 2026
CFT-RAG: AN ENTITY TREE BASED RETRIEVAL AUG- MENTED GENERATION ALGORITHM WITH CUCKOO FILTER
Zihang Li, Wenjun Liu, Zhengyang Wang & Tong Yang State Key Laboratory of Multimedia Information Processing
School Computer Science
Peking University
Beijing, China
(liz.hang@stu, pku. cn, yangtongfpku.edu.co
Yangdong Ruan
School of Software
Beijing University of Aeronautics and Astronautics
Beijing, China
ABSTRACT
Although retrieval-augmented generation (RAG) significantly improves generation quality by retrieving external knowledge bases and integrating generated content, it faces computational efficiency bottlenecks, particularly in knowledge retrieval tasks involving hierarchical structures for Tree-RAG. This paper proposes a Tree- RAG acceleration method based on the improved Cuckoo Filter, which optimizes entity localization during the retrieval process to achieve significant performance improvements. Tree-RAG effectively organizes entities through the introduction of a hierarchical tree structure, while the Cuckoo Filter serves an efficient data struc- ture that supports rapid membership queries and dynamic updates. The experiment results demonstrate that method is much faster than baseline methods while maintaining high levels of generative quality. For instance, our method is more than 800% faster than naive RAAe on DART dataset. Our work is available at http:///gghtuuacmmmm//////////11 TTP.YPT
INTRODUCTION
In the era of information explosion, Sotrieval-Augmennt Generation (RAG), a technology integrating retrieval mechanisms with generative models, has gained significant attention. It allows models to draw on external knowledge bases during text generation, effectively overcoming the limitations of traditional generative models in knowledge-intensinn tasks (Lewis et al.) 2020). The knowledge base, a vital part of the RAG system, stores wealth of structured and unstructured knowledge, acting as the main source of external information for the model. However, with the continuous expansion of the knowledge base and the rapid pace of knowledge update, the challenge of efficiently retrieving relevant and accurate information from has become major obstacle improving the performance of RAG system. The experiment results of time ratio in Table show that the retrieval time accounts for 10% 72% of the total response time all baseline RAG methods. Enhancing the retrieval speed and accuracy of the knowledge base is crucial for boosting the overall performance of the RAG system (Zhong et al. 2024). Faster and more accurate retrieval enables the model to access relevant knowledge promptly, improving response speed and the quality of generated content. In contrast, inefficient or inaccurate retrieval can result incorrect or irrelevant outputs, degrading user experience and system usability. Therefore, exploring ways to optimize the knowledge base retrieval
"Corresponding Author.

---

Published as a conference paper at ICLR 2026
mechanism is of great theoretical and practical importance, and this paper will focus on this key issue.
User Query
Query
Query
Vector
Inpui +
Input
Document Retrieval
Ercodding
Spacy
Compare
Get Entilas
Ranking
Entities Identification
Search In Trees
Vector Search
Chunks
Context Retrieval
Please answer the question
Combine
based on the information below. The basi: informatio is:
Integrated Prompt
Document
Cuckoo Filter
Context
Respond
Augment
hicrarchical relations
Augmented LLM
Context
Figure 1: The workflow of CFT-RAG begins with user query, which undergoes vector search to retrieve relevant documents. Key entities are then identified from entity trees by applying SpaCy and hierarchical tree searches. Context information related to these entities retrieved and filtered efficiently by applying Cuckoo Filter. The retrieved context and hicrarchical relationships integrated into a comprehensive prompt, which is fed into an augmented large language model (LLM). The LLM processes this enriched prompt to generate a context-aware and accurate response to the user query.
Knowledge bases in Serrivall-Agmentte Generation (RAG) systems are mainly of three types: text-based, graph-hased, and tree-based (Han et al. 2025). Text-based ones store information as text, easy to manage but slow in retrieval due to complex language processing. Graph-based knowledge bases represent knowledge as graphs, excelling in handling complex relationships with relatively fast retrieval for certain queries, thanks to graph neural networks. Tree-based knowledge bases structure knowledge hierarchically. Despite eext-based and graph-based based knowledge bases having made good progress, the retrieval speed of all three types, especially tree-based ones, needs improvement. For RAG systems to provide faster and more accurate responses, optimizing retrieval from these knowledge bases, particularly tree-RAG, is key research challenge.
Tree-RAG, an extension of RAG, improves on traditional RAG frameworks by using hierarchical tree structure to organize the retrieved knowledge, thus providing richer context and capturing complex relationships among entities. Tree-RAG, entities are arranged hierarchically, allowing the retrieval process to more effectively traverse related entities at multiple levels. This results in enhanced response accuracy and coherence, as the tree structure maintains connections between entities that are essential for contextually rich answers (Fatehkia et al. 2024a). However, critical limitation of Tree-RAG lies in its computational inefficiency: as the datasets and tree depth grow, the time required to locate and retrieve relevant entities within the hierarchical structure significantly increases. posing scalability challenges. This paper aims to greatly improve the retrieval efficiency of Tree-RAG without sacrificing the accuracy of the generated responses.
To address the retrieval bottleneck, we introduce an optimized method to Tree-RAG by integrating the Cuckoo Filter (Fan et al. 2014), high-performance data structure. Its basic workflow is presented in Figure [ The Cuckoo Filter excels in fast membership queries and supports dynamic operations, such as element insertions and deletions, making it suitable for dynamic data management scenarios (Fan) et al.) 2014). Unlike traditional filters, such as Bloom Filter (Guo et al., (010)), which is limited by fixed false-positive rates and lack deletion capability, the Cuckoo Filter allows for both flexible updates and reduced storage requirements. Therefore, it is particularly advantagcous for handling large hicrarchical datasets. The comparison experiment is designed to demonstrate that our method is significantly better than the three baseline methods including naive Tree-RAG.
Theoretically, the time complexity of Cuckoo Filter for searching entities is O(1), which is significantly lower than that of naive RAG. From spatial point of view, entities are stored in the Cuckoo Filter in the form of fingerprints (12-bit), which greatly saves memory usage. On the other hand, when the load factor of Cuckoo Filter exceeds the preset threshold, the storage capacity is usually
2

---

Published as a conference paper at ICLR 2026
increased by double expansion, while the original elements re-hashed and migrated to the new storage location to complete the automatic expansion. This keeps the loading rate of cuckoo filter high and not too high, thus saving memory while avoiding hash collisions much as possible.
Moreover, we propose two novel designs. The first design introduces a temperature variable. with each entity stored in the Cuckoo Filter maintaining additional variable called temperature. The variable is used to record the frequency of the entity being accessed. The Cuckoo Filter sorts the entities according to the frequency, and the entities with the highest temperature are placed in the front of the bucket, thus speeding up the retrieval. The second design is to introduce block linked list, where Cuckoo Filter stores the addresses of entities at different locations in the tree. The utilization of the space of block linked list is high, it can support relatively efficient random access, reduce the number of linked list nodes, and perform well in balancing time and space complexity, especially for processing large-scale data. Therefore, we achieve acceleration by storing these addresses in the form of a block linked list. An ablation experiment is performed to demonstrate the effectiveness of the design.
1.1 RELATED WORK
Cuckoo Filter Cuckoo Filter is efficient data structure for supporting fast element lookup and deletion operations. which is mainly used for collection operations and data stream processing (Fan al. 2014). It developed based on the idea of Cuckoo Hashing (Pagh & Rodler, 200T). Cuckoo Filter outperforms traditional Bloom filters in terms of storage efficiency and query performance, especially in scenarios where frequent insertion and deletion of elements are required. The main advantage of Cuckoo Filter is its support for dynamic updates, which enables it to efficiently handle element changes in a collection. Unlike Bloom Filter, Cuckoo Filter can not only query whether an element exists not, but also support the deletion operation of an element, feature that is important in many practical applications (Gupta & Breitinger 2015). The working principle of Cuckoo Filter is based multiple hash functions and a bucket structure, which is utilized by storing the elements in fixed-size buckets and using the hash conflicts to achieve fast lookup of elements. This efficient data structure provides new ideas for handling large-scale datasets, which can accelerate the retrieval process and improve response efficiency.
Retrieval Augmented Generation Retrieval Augmented Generation(RAG) is a state-of-the-ard method that combines information retrieval with large language models, with the aim of addressing the limitations of it in the absence of specific knowledge (Lewis et al. 2020). The core idea of RAG is to utilize an external knowledge base for retrieval and to incorporate relevant information into the generation process. Specifically, RAG first retrieves multiple relevant documents from the knowledge base on the basis of the input query, and then combines the retrieved knowledge with the input query to form the context and then generate the final answer through the generative model. This approach significantly improves the quality and relevance of the generated text (Karpukhin jet al., 2020) and avoids the limitations of fixed model knowledge (Gupta et al., 2024). Compared to fine-tuning, RAG has greater ability to update knowledge and also reduces the dependence on large-scale data. Moreover, CRUD- RAG (Lyu et al. (2024) provides a Chinese benchmark covering four main application scenarios of RAG. Memory Bank (Zhong al. (023) enhances long-term memory for L.Mss, improving recall and user adaptation. RAPTOR (Sarthi et al. (002)) employs a tree-structured retrieval approach with recursive embedding, clustering, and summarization, excelling in semantic understanding. These works emphasize relationship extraction and dynamic updating but lack strong retrieval efficiency across diverse applications. CFT-RAG addresses these gaps with Cuckoo Filter.
Generation (Graph- is an extension of RAG. where the information retrieval process is augmented by leveraging graph-based structures to organize and retrieve information (Lewis et al. 2020). The key difference between traditional RAG and Graph-RAG is the use of graph, such as knowledge graph, to model relationships between entities and concepts, which can improve the relevance and contextuality of the retrieved information (Hu et al. 2024). The algorithmic process of Graph-RAG enhances the understanding of relationships and provides more precise information retrieval than traditional RAG (Darrin et al. 2024). However, the complexity in graph construction and maintenance will be a trouble, the quality and completeness of the graph can also affect the accuracy of responses generated by the model. For instance, EMG-RA (Wang et al. 2024) integrates Editable Memory Graph for partition management and relation capture,
Graph-RAG Graph
3

---

Published as a conference paper at ICLR 2026
improving answer quality but suffering from high computational cost. Therefore, in comparison to Free-RAG (Fatehkia et al., 2024b), Graph-RAG -AGG still has certain disadvantages.
Tree-RAG Tree-RAG(TRRAG) is emerging method that combines tree structure and large language models to improve the effectiveness of knowledge retrieval and generation tasks. Compared to traditional RAG, T-RAG further enhances the context retrieved from vector databases by introducing a tree data structure to represent the hierarchy of entities in an organization. The algorithmic process of Tree-RAG consists of the following steps: first, the input query is parsed identify relevant entities and the retrieval of relevant entities is performed in the constructed forest. Next, the system traverses through the hierarchical structure of the tree obtain the nodes related to the query entity and its upper and lower multilevel parent-child nodes. Subsequently, the retrieved knowledge is fused with the query to generate the augmented context. Finally, the generative model generates the final answer based on the augmented context. This process effectively combines knowledge retrieval and generation and improves the accuracy and contextual relevance of the generative model (Fatehkial al. 2024a). However, T-RAG runs inefficiently due to the time-consuming nature of finding all the locations of related entities in forest with a large amount data. Our method applies the improved Cuckoo Filter to the retrieval process of Tree-RAG, making it greatly faster.
2
DATA PRE-PROCESSING
is important to recognize entities and construct hierarchical relationships (e.g., tree diagrams) be- tween entities from datasets. It mainly involves the steps of entity recognition, relationship extraction and filtering. For existing hierarchical data, binary pairs representing parent-child relationships are directly extracted. For raw textual data, text cleansing is first performed manually to remove irrelevant information.
2.1 ENTITIES RECOGNITION
SpaCy is Python library, and its entity recognition function is based on deep learning models (e.g.. CNN and Transformer). captures information by transforming the text into word vectors and feature vectors. The models trained names of people and places. We adopt the method in T-RAG by using the spaCy library to recognize and extract entities from user's query (Fatehkia al. 2024a).
labeled corpus recognize named entities in the text, such as
2.2 RELATIONSHIP EXTRACTION
Various relationships are identified from the data, including organizational, categorization, temporal, geographic, inclusion, functional, and attribute relationships. The relationships manifest through grammatical structures such as noun phrases, prepositional phrases, relative clauses, and appositive structures (Vaswani al., 2017 Devlin al., (219). We focus on extracting relationships that express dependency, such as "belongs to," "contains," " and "is dependent on." The process is presented in Figure
Extract
Build
Text
Hint
Relations
This hospital providing exceptional services has a psycciatric clinic a brain clinic, and aneurological clinic
Hospital
include
Parent
Psychiatric Clinic
Brain Clinic
Neurological
Child
Clinic
Figure 2: The process of relationship extraction
4

---

Published as a conference paper at ICLR 2026
We apply several dependency parsing models(gpt-4 and open-source NLP libraries) to analyze the grammatical structure of the data. This helps identify relationships between words, such as subject-verb-object modifier relationships.
We define rules to identify hierarchical relationships. a word modifies another noun, it can be interpreted child-parent relationship; If there conjunctions (e.g., "and", "or"), handle them to group entities under the same parent. As result, there a list of tuples representing the hierarchical structure.
2.3 RELATIONSHIPP FILTERING
After extracting relations, certain relationships are filtered out to ensure maintain the tree structure:
Transitive Relations: If transitive relations are detected (e.g.. "A belongs to B", "B belongs C" and "A belongs to C"), remove distant relations.
Cycle Relations: cycles are detected (e.g.. "A belongs to B" and "B belongs to A"), only the closest relationship is retained.
Self- Pelft-oin Edges: Any relation where a node points itself is removed.
Duplicate Edges: Multiple edges between same nodes are pruned, leaving only one edge.
(a)
(b)
(c)
(d)
Figure 3: Error relation examples.
METHODOLOGY
In this section, we propose novel design of Cuckoo Filter that combines the advantages traditional Cuckoo Hashing and applies it to Tree-RAC by introducing additional designs that greatly improve the speed of knowledge retrieval in Tree-RAG.
3.1 STORAGE MODE
In addition to entity trees, we set up an additional Cuckoo Filter to store some entities to improve retrieval efficiency. Based the naive Cuckoo Filter, we introduce the block linked list for optimiza- tion, which can greatly reduce memory fragmentation. We first find out all locations of each entity in the forest and then store these addresses in block linked list.
To further optimize the retrieval performance, we propose an adaptive sorting strategy to reorder the entities in each bucket in the Cuckoo Filter based on the temperature variable which stored the head of the block list. The temperature variable records how often each entity is accessed, and entities with high-frequency access are prioritized to be placed at the front the bucket. Since the Cuckoo Filter looks up the elements in the buckets linearly, this reordering mechanism can significantly optimize the query process, which can further improve the response speed the model. In summary, in each entry of the bucket, entity's fingerprint. its temperature, and head pointer of its block linked list are stored. The storage mode included in Figure and details about the process of insertion and eviction of entities provided in Appendix A
5

---

Published as a conference paper at ICLR 2026
Entities
Single Table
Bucket
Get Information
Block Linked List
Find Buckets
Find Item
item 1 &
fingerpennt
Each block has three addresses
0010130...
bucket
Head
Adari
Addrz
Addr
Next
Semperature
item &
Using
hash functions
B-O-
information
Get context from each entity address
Forest
kick
item3
Sort by temperature
Collection of entities to be queried
bucket2
item &
context2
context3
context1
Figure 4: The workflow of CFT-RAG when query contains entity The entity with high temperature will placed ahead which with low temperature in the bucket. All the addresses in different trees of the entity are linked by the block linked list.
3.2 CONTEXT GENERATION
After the fingerprint of the target entity is found, the temperature of the entity is added by one and pointer the head of the corresponding block linked list of that entity is returned. From this pointer, the location of the entity node in different trees including multi-level parent nodes, child nodes, etc. can be accessed through the address stored the block list. If no matching fingerprint found, the null pointer is returned. For the queried entity and its parent and child nodes in different trees, we form a context between the entity and its relevant nodes based on the template. For instance, the upward hierarchical relationship of entity A are: B, C and D. Finally, we fuse this information with the query to generate the augmented context. After that, the augmented context combined with system prompt and query is regarded as the prompt. The lookup and context generation process is stated in Figure 4
Algorithm 1: Context Generation Algorithm
Input: x: Input entity
Output: contezt: Context generated for entity
f() + fingerprint(z):
if bucketfin I bucketfizl contains ((x) then
Lemperabure &- lemperalure +
return head;
end
current Block + head next; while current & NULL do
foreach location in currentBlock do
Let loc be the current location of entity x in the block;
Find the of hierarchical relationship nodes at location loe in the tree;
Hap + {h1, h2...., An)
Haown [h1 h/ ... Ky
Record the first upward and downward hierarchical relationship nodes; n +++) do
for (i
Store (hs, K)) in context;
end end end for
currentBlock + current + next;
(i 1i=1;ia n; :::1;ik;;tt+)e do context contezt h));
end

---

Published as a conference paper at ICLR 2026
4 EXPERIMENTS
In this section, describe our experimental setup, baseline methods, and CFT-RAG, and compre- hensively evaluate the results. Our experiments aim to assess the efficiency of CFT-RAG approach under diverse experimental conditions, particularly in terms of retrieval speed and computational overhead.
4.1 BASELINE
To benchmark the effectiveness of the proposed Cuckoo Filter T-RAG, we compare it against several baseline models. Our baselines include the text-based RAG, Naive T-RAG without filtering mechanisms, T-RAG with ANN and Graph-RAG with ANN. These baselines allow us to quantify improvements introduced by Cuckoo Filter T-RAG.
Naive T-RAG This basic implementation of T-RAG (Fatehkia et al., 2024b) does not include any filtering optimizations. The method constructs entity tree using entities extracted from the dataset and employs a Breadth-First Search (BFS) algorithm for entity lookup. Although this approach has high time complexity and prolonged search time, it provides straightforward baseline for evaluating the benefits of incorporating filtering mechanisms.
Text-based RAG This baseline RAG model retrieves the top- K relevant documents from vector store based purely on similarity scores, without considering entity relationships or structural information. It performs standard dense retrieval followed by response generation using peuuencc-to-sequeee model. Although simple and easy to implement, this approach may suffer from irrelevant or redundant information due lack of context-aware filtering or reasoning capabilities. serves as a foundational benchmark to assess the advantages of incorporating more structured or semantic retrieval strategies.
ANN Graph RAG This model integrates approximate nearest neighbor (ANN) search with a graph- based entity structure to accelerate retrieval while maintaining semantic relevance. Entities and their relationships are organized into a directed graph, enabling multi-hop traversal and contextual inference. During retrieval, ANN is used to identify the closest matching entities efficiently, and the graph structure guides the expansion to related entities for enriched context. This method balances speed and accuracy by leveraging the fast lookup capabilities of ANN and the expressive power of graph reasoning.
ANN Tree-RAG In this variant, Approximate Nearest Neighbor (ANN) search is employed to accelerate document retrieval in the entity tree structure. Instead of performing exact similarity search, the model leverages efficient ANN indexing techniques (e.g., FAISS HNSW) to retrieve top-K candidates for each entity. ANN T-RAG provides a strong balance between performance and efficiency, especially compared to the Naive T-RAG baseline.
4.2 CFT-RAG
Cuckoo Filter supports entity deletion operation, which is suitable for ongoing data update, and it has lower false positive rate and is more space efficient. The CFT-RAG method stores the individual nodes of the entity in the forest in each bucket of the Cuckoo Filter, i.e. it merges the Cuckoo Hash with the Cuckoo Filter. After the entity tree generated, the nodes with the same entity details in each tree are concatenated into block list, where the pointer to the head of the list corresponds to the fingerprint, and stored together in buckets.
An improved CFT-RAG is to maintain access popularity of each entity, called temperature, at the head node each block list, and raise the level of temperature corresponding to the hit entity during retrieval. For each bucket, if there is bucket that has not been searched, i.e. if it is free, the fingerprints and block list header pointers in the bucket can be sorted according to temperature, and the fingerprints with higher access popularity placed at the front of the bucket, which can take advantage of the locality of the entities contained in the user questions to improve the running speed of the algorithm.
7

---

Published as a conference paper at ICLR 2026
4.3 DATASETS AND ENTITY FOREST
Our experiments use three datasets: the large-scale dataset MedQA (Jin et al. 2021 and two medium-sized datasets AESLC (Zhang & Tetreault 2019) and DART (Nan 2021). We leverage dependency parsing models to extract entities and relationships among them and construct the entity forest based on these extracted entities and relationships. The resulting entity forest is structured to allow efficient retrieval and provides a practical evaluation scenario for our approach. The cost is stated in Appendix A
4.4 SETUP
We implement the core RAG architecture in Python, while key data structures, including Cuckoo Filters, are optimized in C++ for performance. All experiments were conducted on a system equipped with Nvidia H100 GPU, 22 CPU cores, and 220 GiB of memory. Each algorithm was repeated 108 times to account for variability and ensure reliable results, with averages calculated across runs to mitigate the influence of outliers. We apply the LangSmith framework evaluate the accuracy of answers, where the OpenAl scoring model used by Lmngh was replaced with doubao (Doubao AI 2024).
Table Retrieval time and accuracy on MedQA, AESLC and DART datasets
Dataset
Algorithm
Time(s)
Time Ratio %)
Acc(%) (%)
Text-based RAG
51 +
Naive T-RAG
19.45
58
65 +
ANN T-RAG
7.65
25
67 + 4
MedQA
ANN G-RAG
8.78
26
61
CFT-RAG
5.24
16
69 + 4
Text-based RAG
42 6
Naive T-RAG
12.87
62
55
ANN T-RAG
2.52
13
56 6
AESLC
ANN G-RAG
2.38
11
5
CFT-RAG
0.97
5
57 17
Text-based RAG
53
Naive T-RAG
16.03
74
65 5
ANN T-RAG
3.28
66
DART
ANN G-RAG
3.95
19
65 15500 6
CFT-RAG
1.81
9
68 1
CFT-RAG Cuokoo Filter T-RAG. ANN G-RAG represents Graph-RAG with ANN. represents 'hre-RAA Time represents the retrieval time.
Time Ratio represents proportion retrivval time response time. Ace represents the model's accuracy of answer.
4.5 RESULTS AND EVALUATIONS
4.5.1 COMPARISON EXPERIMENT
We conduct the experiments by selecting 1,000 questions on each dataset. Then we record the average retrieval time and average response accuracy by LangSmith. Table presenns the retrieval time and accuracy of various RAG-based models across the MedQA, AESLC. and DART datasets. expected, the Naive T-RAG model incurs the highest retrieval latency due to its exhaustive BFS-based search, while offering moderate accuracy improvements over the text-based baseline. Further efficiency gains are observed in ANN-based methods (ANN T-RAG and ANN G-RAG), which leverage approximate nearest neighbor search to achieve faster response times with comparable accuracy. Notably, CFT- RAG consistently outperforms other variants by achieving the lowest retrieval time across all datasets while maintaining high accuracy, demonstrating the effectiveness of integrating probabilistic filtering with structural optimization. Moreover, when the problem is complex involving multi-hop and the
8

---

Published as a conference paper at ICLR 2026
required entity relationships precise, method shows obvious advantage the other methods. Use cases are provided in Appendix A
Moreover, the error rate of our method in the process of searching entities is very low. After building the trees based on the dataset, the Cuckoo Filter includes 1024 buckets, each of which can hold up to 4 fingerprints and block linked list head pointers. The Cuckoo Filter's strategy to increase the number of buckets by power of two. In the experimental datasets, there are thousands of entities that be extracted, and the space load factor for the Cuckoo Filter is more than 70%. Because the space load factor is not too high and searching errors are mainly caused by hash collisions, the eтror rate is almost O, showing that the number of entities causing the lookup error is O to 1 out of 1024 buckets for thousands of entities.
memory expansion
tree number: 300 entity number: 200
0.40
free_ are__numerr.aee 400 entity_ 200
0.30
tree_nne @ree__umbrr:: 300 entity number: 100
free_ pre__nuberr 400 entity_nurmnn number: 100
0.32
0.24
0.24
0.18
Search Time (s)
0.16
0.12
10
10
0.50
tree_ :om__n 500 entity Bulbbrr 200
tree_ @ee__n 600 entity entilynnumber 200
tree number: 500 entity number: 100
0.55
tree number: 600 entity hnttty_uumbrrr: 100
0.40
0.44
0.30
0.33
0.20
0.22
0.10
0.11
5
10
10
Round
Figure 5: We record the search time per round of query with different number of trees and entities. Each round represents a search the entities forest, and entities are inserted into the improved Cuckoo Filter before the first search is performed.
4.5.2 ABLATION EXPERIMENT
Sorting the fingerprints and head pointers of the block linked lists by temperature can optimize the retrieval time without occupying any extra space, which is eminently useful when the query given by the user contains large number entities. We design experiments to measure the effect having or not having the sorting design on the result. In figure we can observe that the retrieval time after the first round is significantly shorter than that of the first round. This is because the temperatures are updated according to the access frequency in each round and after each query, the Cuckoo Filter sorts the entities according to the entities' temperatures. This sorting design allows the 'hot' entities to be found more quickly in subsequent queries.

---

Published as a conference paper at ICLR 2026
5 CONCLUSION
In this paper, we have introduced efficient acceleration method for the Tree-RAG framework by integrating the improved Cuckoo Filter into the knowledge retrieval process. Tree-RAG, which combines hierarchical tree structures for knowledge representation with generative models, holds great promise for improving the quality and contextual relevance of generated responses. However, its performance is hindered by the computational inefficiencies of retrieving and organizing large-scale knowledge within complex tree structures.
By leveraging the Cuckoo Filter, which supports fast membership queries and dynamic updates, we have significantly enhanced the speed and efficiency the retrieval process in Tree-RAG. Our experimental results show that the Cuckoo Filter improves retrieval times without sacrificing the quality of generated responses, making the system more scalable for real-world applications. This acceleration particularly valuable in scenarios where real-time knowledge updates and rapid information retrieval are critical, such as in large-scale question answering, decision support systems, and conversational agents.
Future work could explore further optimizations, such as adapting the method for different knowledge structures or extending more complex multimodal tasks. Overall, this research demonstrates the potential of efficient data structures to enhance the performance of large language models in retrieval-intensive applications.
ACKNOWLEDGMENTS
This work was supported by the National Key Research and Development Program of China under Grant 20.20224YF2906601, and part by the National Natural Science Foundation of China (NSFC) (No.62372009).
REFERENCES
E. Darrin, T. Ha, C. Newman, Joshua Bradley, Alex Chao, Apurva Mody, Steven Truitt, and Jonathan Larson. From local to global: A graph rag approach to query foccusd summarization. arXiv preprint:2404.166 16130, 2024.
Jacob Devlin, Ming-Wei Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the Conference of the North American Chapter of the Association for Computational Linguistics (NAACL-HLT), pp. 4171-4186, 2019.
Doubao AI. Doubao large language model. 2025.
wwwp:/wwwwwwbooooooooo.. com 2024. Accessed May
Bin Fan, David G. Andersen, Michael Kaminsky, and Michael Mitzenmacher. Cuckoo filter: Practi- cally better than bloom. In Proceedings of the 10th ACM International Conference on Emerging Networking Experiments and Technologies, pp. 75-88. Association for Computing Machinery, 2014. doi: 10. 10.1145/2674005.26776900
Masoomali Fatehkia, Ji Kim Lucas, and Sanjay Chawla. T-rag: Proceedings of the Annual Conference on Neural Networks and Information Retrieval (NNIR), pp- 102-112, 12, 2024a.
Lessons from the Ilm trenches. In
Masoomali Fatehkia, Ji Kim Lucas, and Sanjay Chawla. T-rag: Lessons from the lim trenches. arXiv preprint:2402.07445 2024b.
Deke Guo, Jie Wu, Honghui Chen, and Xueshan Luo. The dynamic bloom filters. IEEE Transactions on Knowledge and Data Engineering, 22(1):120-133, 2010. doi: 10.1 10.1009K....200955..
Shashank Gupta, Rahul Ranan, and Sat Narayan Singh. A comprehensive survey of retrieval- augmented generation (rag): Evolution, landscape and future directions. arXiv preprint:2410.12 12837, 2024.
10

---

Published as a conference paper at ICLR 2026
Vikas Gupta and Frank Breitinger. How cuckoo filter can improve existing approximate matching techniques. In Digital Forensics and Cyber Crime: 7th International Conference. ICDF2C 2015, Seoul, South Korea, October 6-8, 2015. Revised Selected Papers 7, pp. 157-168. Springer, 2015.
Haoyu Han, Li Ma, Harry Shomer, Yu Wang, Yongjia Lei, Kai Guo, Zhigang Hua, Bo Long. Hui Liu, Charu C. Aggarwal, and Jiliang Tang. Rag vs. graphrag: A systematic evaluation and key insights. arXiv preprint:2502. /1371, 2025.
Yuntong Hu, Zhihan Lei, Zheng Zhang, Bo Pan, Chen Ling, and Liang Zhao. Grag; Graph retrieval- augmented generation. arXiv preprint:2405. 16506 2024.
Danqing Jin, Endang Pan, Nabeel Oufattole, Wei-Hung Weng, Hanyi Fang, and Peter Szolovits. What disease does this patient have? large- scale open domain question answering dataset from medical exams. Applied Sciences, 11(14):6421, 2021.
doi: 10.3390/app1 146421.
Vladimir Karpukhin, Barlas Oğuz. Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen tau Yih. Dense passage retrieval for open-domain question answering. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 6769-6781, 2020.
Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. Retrieval-augmennee generation for knowledge-intens intensive nlp tasks. In Advances in Neural Information Processing Systems, volume 34, pp. 9459-9474, 2020.
Yuanjie Lyu, Zhiyu Li, Simin Niu, Feiyu Xiong, Bo Tang, Wenjin Wang, Hao Wu, Huanyong Liu, Tong Xu, and Enhong Chen. Crud-rag: A comprehensive chinese benchmark for retrieval- augmented generation of large language models. arXiv preprimt:2011. 17043, 2024.
Linyong Nan, Dragomir Radev, Rui Zhang, Amrit Rau, Abhinand Sivaprasad, Chiachun Hsieh, Xiangru Tang, Aadit Vyas, Neha Verma, Pranav Krishna, Yangxiaokang Liu, Nadia Irwanto, Jessica Pan, Faiaz Rahman, Ahmad Zaidi, Mutethia Mutuma, Yasin Tarabar, Ankit Gupta, Tao Yu, Yi Chern Tan, Xi Victoria Lin, Caiming Xiong, Richard Socher, and Nazneen Fatema Rajani. Dart: Open-domain structured data record to text generation. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 432 332-447, 2021. doi: 10.18653/v1/2000 1/t.:////222../// maac..mm.....
URL https://
aclanthology.orze
naacl main.377
Rasmus Pagh and Flemming Friche Rodler. Cuckoo hashing. In Proceedings of the Annual European Symposium on Algorithms (ESA), volume 2161, pp. 121-133, 2001.
Parth Sarthi, Salman Abdullah, Aditi Tuli, Shubh Khanna, Anna Goldie, and Christopher D. Manning. Raptor: Recursive abstractive processing for tree-organized retrieval. arXiv preprint:2401. 2401. 2024.
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Proceedings of the Advances in Neural Information Processing Systems (NeurIPS), pp. 5998-6008, 2017.
Zheng Wang, Zhongyang Li, Zeren Jiang, Dandan Tu, and Wei Shi. Crafting personalized agents through retrieval-augmentt generation editable memory graphs. arXiv preprint:2409.199 2024.
Rui Zhang and Joel Tetreault. This email could save your life: Introducing the task of email subject line generation. arXiv preprint: /906 034907 2019.
Wanjun Zhong, Lianghong Guo, Qiqi Gao, He Ye, and Yanlin Wang. Memorybank: Enhancing large language models with long-term memory. arXiv preprint:2305.1 200..m000..00..2...... 2023.
Wanjun Zhong, Lianghong Guo, Qiqi Gao, He Ye, and Yanlin Wang. Memorybank: Enhancing large language models with long-term memory. Proceedings of the AAAI Conference on Artificial Intelligence,
2024. URL https: /arxivv..v.. org/ abs /200 10250

---

Published as a conference paper at ICLR 2026
A APPENDIX
A. ENTITY INSERTION STRATEGY
The fingerprint is shorter hash representation of entity which is usually represented in fixed- length bits. Thus, we introduce fingerprints to save memory. After the tree structure is constructed, the fingerprint is first computed for each entity before inserting. Furthermore, the insertion and eviction strategy is consistent with the traditional Cuckoo Filter, where the locations of the fingerprint are determined by two hash functions Fan al. (2014). When inserting an entity by applying the Cuckoo Filter, it first tries to store its fingerprint the empty position l or ig. which can be calculated as:
1 = 12 1 ((f(x))
where h(x) is the hash value of entity x and h((())) the hash value of fingerprint fa). The two locations i and i2 are candidate storage locations to increase the flexibility of the lookup and insertion operations.
Algorithm 2: Entity Insertion Algorithm
[(x) fingerprint(x);
either bucket(i,] / or bucketfin] | has an empty entry then add (a) and the initialized temperature that bucket; add the addresses of the entity as block linked list to that bucket;
return True
end
randomly select i or iz as i;
for k = 0; k Max Wum Kicks; k + do select an entry m from bucket(i] randomly;
interchange f(x) and the fingerprint stored in entry m; i = i @ hash(f(x)):
if bucket[i] has empty entry then add f(x) and the initialized temperature to bucket[i];
add the addresses of the entity as block linked list to bucket[i]; return True
end end
return False
Then check if there are empty slots at locations i and ig. If empty slot exists in either position, the information of entity x including its fingerprint f(x)., its temperature and its addresses are inserted into that empty slot and the insertion process is completed. If both locations are occupied, the Cuckoo Filter activates the eviction mechanism and tries to free up space for inserting new entity by evicting the existing entity. practice, the Cuekoo Filter sets the maximum number of evictions to avoid infinite recursive eviction operations; after reaching the maximum number of evictions, it means that the insertion operation fails.
B. ENTITY EVICTION STRATEGY
In the eviction mechanism, the Cuckoo Filter randomly selects a location from i or iz to evict the fingerprints therein and then calculate the alternative position j of the fingerprint. Next, inserts the fingerprint into the empty slot of j. If it is already occupied, the eviction operation repeated until an empty location is found or the maximum number of iterations is reached.
12

---

Published as a conference paper at ICLR 2026
Algorithm 3: Entity Eviction Algorithm
f()) =fingerprin(x);
hash(x);
f2 i @ ha))(
if bucketfi, bucket[ig] has f()) then
remove f()) together with its information from this bucket;
return True
end
return False
Through the eviction mechanism, Cuckoo Filter able to continue inserting new entities under high load conditions, avoiding the high misclassification rate caused by direct rejection of insertion.
C. 1-HOP EASY QUESTION
Question: What causes Horner's syndrome?
Key Answer: Paralysis of ocular sympathetic nerves.
Rare Entity: ocular ocular..ympather www.sssytppptttetneennee
nerves. nerves....
Text-Based RAG
Retrieval Time
Response Time 25,87s
Time Ratio
Accuracy
56%
Question:
What causes Horner's syndrome?
Answer:
Horner's syndrome is caused by disruption of the sympathetic nerve pathway that supplies the eye and face. This disruption can occur at any point along the three-neuron sympathetic chain, which extends from the hypothalamus to the eye...
ANN Graph-RAG
Retrieval Time
Response Time
Time Ratio
Accuracy
7.53s
24.30s
30.99%
60%
Question:
What causes Horner's syndrome?
Answer:
Symptoms of Horner's ss syndrome include ptosis (drooping eyclid), miosis (con- stricted pupil), anhidrosis (lack of sweating), and enophthalmos (sunken eye appearance). Identifying the underlying cause is crucial, require urgent medical attention...
causes, such carotid artery dissection,
Cuckoo Filter Tree-RAG
Retrieval Time
Response Time
Time Ratio
Accuracy 66%
4.72s
21.54s
21.92%
Relation: Horner ocular sympathetic nerves
Question:
What causes Homeer's syndrome?
Answer: Horner's syndrome is caused by paralysis of the ocular sympathetic nerves. Because Homeer' syndrome can be a sign of serious conditions like carotid artery dissection lung tumors, often requires urgent medical evaluation...
13

---

Published as a conference paper at ICLR 2026
D. 2-HoP EASY QUESTION
Question: What is the most essential component for culturing Mycoplasma?
Key Answer: Cholesterol supplements.
Rare Entity: cholesterol supplements.
Text-Based RAG
Retrieval Time
Response Time
Time Ratio
Accuracy
25.12s
45%
Question:
What is the most essential component for culturing Mycoplasma?
The most essential component for culturing Mycoplasma is a specialized growth medium containing sterols. Since Mycoplasma lack cell wall, they require sterols to maintain membrane integrity...
Answer:
ANN Graph-RAG
Retrieval Time
Response Time
Time Ratio
Accuracy
7.98s
23.46s
34.01%
61%
Question: What is the most essential component for culturing Mycoplasma?
Answer:
The most essential component for culturing Mycoplasma a rich growth medium supplemented with sterols. Since Mycoplasma species lack cell wall and cannot synthesize sterols on their own, they require cholesterol for membrane stability...
Cuckoo Filter Tree-RAG
Retrieval Time
Response Time
Time Ratio
Accuracy
3.86s
19.62s
19.67%
67%
Relation: Mycoplasma cholesterol*, cholesterol* horse serum, cholesterol* cholesterol supplements
Question: What is the most essential component for culturing Mycoplasma?
The most essential component for culturing Mycoplasma is cholesterol. My- coplasma are prokaryotic organisms that lack cell wall, and their cell membrane requires cholesterol for stability and function. Therefore, the culture medium must include choles- terol, such horse serum cholesterol supplements, support their growth. Additionally...
Answer:
E. MULTI-HOP HARD QUESTION
When the problem is complex and the required entity relationships are precise, Tree-RAG shows an obvious advantage over the other two methods.
Question: Here five types of hydrogen carriers involved in electron transfer, which proceed in a specific order. Can you describe the detailed process?
Answer: flavoprotein, coenzyme iron-sulfur protein, ubiquinone, eytochrome.
Rare Entity: flavoprotein, coenzyme I, iron-sulfur_proteld ubiquinone, eytochrome.
Text-Based RAG
Retrieval Time
Response Time
Time Ratio
Accuracy
38.62s
40%
14

---

Published as a conference paper at ICLR 2026
Question: There five types of hydrogen carriers involved in electron transfer, which proceed in a specific order. Can you describe the detailed process?
NADH donates electrons to Complex I, FADHz donates to Complex II. Electrons transfer to ubiquinone (CoQ) converted to ubiquinol (QH2). Ubiquinol transfers electrons to cytochrome b-c complex (Complex III). Electrons pass through eytochrome e and reach Complex IV...
Answer:
ANN Graph-RAG
Retrieval Time
Response Time
Time Ratio
Accuracy 49%
9.02s
30.15s
29.91%
Question: There are five types of hydrogen carriers involved in electron transfer, which proceed in a specific order. Can you describe the detailed process?
Answer: NADH donates electrons Complex (via FMN) FADHz donates Complex II. Fe-S clusters pass electrons one at a time to downstream carriers, Ubiquinone (CoQ) accepts electrons and protons. becoming ubiquinol (QH2), which shuttles electrons to Complex III. Cytochromes in Complex III pass electrons to cytochrome which carries them to Complex IV. Complex IV (cytochrome oxidase) transfers electrons O2, reducing it to H,O...
Cuckoo Filter Tree-RAG
Retrieval Time
Response Time 27.02s
Time Ratio
Accuracy
4.75s
17.58%
69%
electron transfer hydrogen carriers, hydrogen carriers process* process* 1.flavorrotein, process* 2.coenzyme I, process* 3.iron-sulfur protein, process* 4. 4.ubiquinone, process* 5.cytochrome
Relation:
Question:
There five types of hydrogen carriers involved in electron transfer, which proceed in a specific order. Can you describe the detailed process?
flavoprotein -> coenzyme iron- sulfur protein ubiquinone - cytochrome. Flavoproteins, such NADH dehydrogenase (Complex 1) and succinate dehydrogenase (Complex II), contain flavin mononucleotide (FMN) flavin adenine dinucleotide (FAD) prosthetic groups. These enzymes play crucial role electron transfer from NADH or succinate to downstream components the ETC...
Answer: The process can be summarized follows:
F. OFFLINE CONSTRUCTION COST
The complexity of Entity Extraction is linear O(N) with respect the number of documents in the corpus, as each document is processed independently by the LLM (or smaller IE models). While extraction is the most expensive step, it is one-time offline cost. The Tree Construction and Cuckoo Filter insertion are negligible (O(M) where M is the number of entities) compared to the extraction.
G. THE USE OF LLMS
We use Ilm to check and correct grammar and spelling mistakes. In addition, we also use Ilm to polish the sentences our paper to make them more fluent.
15


Reviews:
[{"review_id": "f4EawC2y0P", "reviewer": "Reviewer_rJQQ", "summary": "This paper addresses the limitation of Tree-RAG that as the dataset and tree depth grow, the time required to locate and retrieve relevant entities within the hierarchical structure significantly increases. A cuckoo filter is interated to optimize Tree-RAG. The experimental shows that the proposed method reduces the retrieval time while maintaining the accuracy.", "questions": "Is there any limitations about the CFT-RAG compared to T-RAG?\nHow does the performance change when the dataset is much smaller or much larger?", "limitations": "", "rating": 4, "confidence": 2, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "The result of the paper is promising. In the reported benchmark datasets, the retrieval time reduces significantly without sacrificing the accuracy.", "weaknesses": "The paper lacks detailed analysis on the impact of the introduced method. For example, what is the gains of the method compared to the T-Rag method as the dataset grows or reduces?\nThe paper is not theoretically novel. It is more like an engineering practice.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "R8UNLPHYLe", "reviewer": "Reviewer_EJBh", "summary": "This paper addresses the efficiency problem in tree-based RAG and enhances entity-based information retrieval using the Cuckoo filter. The Cuckoo filter is adapted for entity-based retrieval by sorting buckets according to the temperature of the block-linked list, where each block contains three addresses in the forest. This improved Cuckoo filter contributes to faster processing and better overall performance.", "questions": "**Writing Suggestions**\n- Citations are missing.\n  - L38: \"Enhancing the retrieval speed and accuracy of the knowledge base is crucial for boosting ~\"\n  - L45–L46: \"Knowledge bases in RAG systems are mainly of three types: …\"\n  - L84: Cuckoo Filter, and L87: Bloom Filter\n  - L152: No citation for Tree-RAG.\n  - 4.1 Baselines \n\n**Duplicate Sentence**\n- L115: \"The main advantage of Cuckoo Filter is its support for dynamic updates.”", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "- The problem statement regarding the efficiency of RAG is reasonable.\n- The introduction of a cuckoo filter equipped with bucket sorting and a block-linked list improves efficiency while enhancing accuracy.", "weaknesses": "- The main idea is to introduce the cuckoo filter into Tree-RAG, which limits its contribution to an engineering technique rather than a conceptual advance.\n- The cuckoo filter can only be applied to questions containing multiple entities, raising concerns about its applicability to entity-poor questions.\n- The baselines are limited, as the experiments were conducted with only simple baselines. More advanced text-based, graph-based, and tree-based RAG methods may be required to better demonstrate the effectiveness of the proposed method.\n- The rationale for selecting benchmarks is missing. It is unclear whether the chosen benchmarks include questions rich in entities, which might make the experimental settings favorable to the proposed method.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "iYEJfZdiax", "reviewer": "Reviewer_K35b", "summary": "CFT-RAG proposes an acceleration method for Tree-RAG by integrating an improved Cuckoo Filter into the retrieval process. The method optimizes entity localization in hierarchical tree structures through two novel designs: a temperature variable that prioritizes frequently accessed entities, and a block linked list that efficiently stores entity addresses. Experimental results on MedQA, AESLC, and DART datasets show that CFT-RAG achieves up to 800% faster retrieval than naive Tree-RAG while maintaining comparable accuracy.", "questions": "See the above weaknesses.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 2, "contribution": 3, "strengths": "1. The integration of Cuckoo Filter reduces retrieval time substantially (e.g., 1.78s vs. 15.88s on DART) while preserving accuracy, addressing a key bottleneck in Tree-RAG scalability.  \n2. The temperature variable and block linked list optimize both temporal and spatial efficiency, enabling dynamic updates and reduced memory fragmentation without extra storage costs.", "weaknesses": "1. Limited Generalization to Non-Tree Structures: The method is tailored for hierarchical tree-based knowledge bases and may not directly apply to graph-based or unstructured data formats without modifications.  \n2. Some key experimental settings are missing: What are the hyperparameters of the proposed method? Are the baselines you chose run in Python or C++? These settings are key to ensuring fair experiments.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "7yPyoRRRqn", "reviewer": "Reviewer_cJ79", "summary": "This paper proposes a method named CFT-RAG, which aims to accelerate the entity retrieval process in Tree-RAG by introducing a Cuckoo Filter. The authors identify that traversing entity trees in a hierarchical knowledge base is the primary performance bottleneck for Tree-RAG. The core contribution is the application and enhancement of the Cuckoo Filter by adding a temperature variable to prioritize the retrieval of frequently used entities and using a block linked list to efficiently store entity locations.", "questions": "1. Your Text-Based RAG baseline appears to lack a vector index, causing it to be unusually slow. Standard RAG implementations typically use efficient indexes like FAISS, and their retrieval speed often surpasses that of Tree-RAG. Could you clarify the specific implementation of this baseline and explain why a standard indexed approach was not used for a fairer comparison?\n2. Could you provide a computational cost analysis for the entity forest construction process (especially the relationship extraction)? How does this offline cost scale with the size of the knowledge base?", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "The paper addresses a practical and important problem. Retrieval latency is a critical barrier to the real-world application of Tree-RAG. Besides,  the experimental results show that CFT-RAG achieves a significant speedup in retrieval compared to baselines, including a naive Tree-RAG and more complex ANN-based methods, while maintaining comparable answer accuracy. This provides strong experimental proof of its effectiveness.", "weaknesses": "1. Misrepresentation and unfair comparison of text-based RAG: the introduction claims that text-based RAG is slow due to complex language processing, which is misleading. In practice, Text-Based RAG leveraging efficient vector indexes (e.g., FAISS/HNSW) is often one of the fastest retrieval methods. Besides, the experimental setup is unfair. The reported retrieval times for Text-Based RAG are extremely long, suggesting that the authors likely used a brute-force search without any indexing. This is not a reasonable or competitive baseline, which undermines the paper's claims about its speed advantage.\n2. The core of this work is based on an existing data structure: the Cuckoo Filter. The main contributions are incremental improvements rather than a new framework or a fundamental shift in the RAG paradigm. Therefore, the conceptual novelty of this work is relatively limited.\n3. All experiments were conducted by selecting only 36 questions from each dataset. This sample size is too small and may lead to coincidental results, casting doubt on the statistical significance and generalizability of the findings.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)