Retrieval-Augmented Knowledge Integration into Language Models: A Survey (2024)

Abstract: This survey analyses how external knowledge can be integrated into language models in the context of retrieval-augmentation. The main goal of this work is to give an overview of: (1) Which external knowledge can be augmented? (2) Given a knowledge source, how to retrieve from it and then integrate the retrieved knowledge? To achieve this, we define and give a mathematical formulation of retrievalaugmented knowledge integration (RAKI). We discuss retrieval and integration techniques separately in detail, for each of the following knowledge formats: knowledge graph, tabular and natural language.

heading: 1 Introduction
text: In natural language processing (NLP), external knowledge or information refers to information that is not explicitly present in the language model (LM) input yet helpful for LMs to produce target output (Zhu et al., 2022). Traditional methods to integrate knowledge, especially those before large language models (LLMs) (Touvron et al., 2023; Chowdhery et al., 2023), include pre-training over a knowledge corpus (Beltagy et al., 2019; Huang et al., 2019; Chalkidis et al., 2020), and fine-tuning in the domain that the knowledge is concerned with (Huang et al., 2019). Despite improved performance of the resulting models (Yin et al., 2022), such methods typically require (re-)training on the whole (without filtering) knowledge. This is not efficient, as the ever-growing size of language models (Chowdhery et al., 2023) raises hardware and energy issues (Bannour et al., 2021; Treviso et al., 2023) of applying these training-intensive methods originally proposed for smaller models.
As an alternative to traditional pre-training and fine-tuning to integrate knowledge into LLMs, retrieval-augmented (RA) methods (Karpukhin et al., 2020; Yu et al., 2023) have become more and more popular in recent years. RA methods
leverage pre-trained internal knowledge already parameterized in LMs as well as retrieved external knowledge (Lewis et al., 2020). In the setting of retrieval augmentation, LMs access for instance only the most relevant, top-k retrieved items without seeing the entire external sources, thus enabling efficiency (Cai et al., 2022). Previous works also demonstrate decoupling knowledge and language model can lead to better adaptability (Long et al., 2023), straightforward knowledge edit (Zheng et al., 2023; Ovadia et al., 2023) and improved explainability (Samarinas et al., 2021).
To track the research intersection of retrieving knowledge to augment LMs, we study the topic of retrieval-augmented knowledge integration (RAKI) in this survey. In RAKI, the retrieval base is some specific external knowledge (Baek et al., 2023b) (e.g. a knowledge graph or a set of Wikipedia articles), where the knowledge is typically written by experts and thus enjoys higher factuality than general texts. This survey is mainly based on recent (2018-2024) publications (See Appendix A.1, A.2 for more details of literature). Inspired by Hu et al. (2024), we categorize the published works in this line of research based on the format of knowledge source: knowledge graph, tabular and natural language. For each knowledge source, we start by introducing the source format using the annotations proposed in Section 2. Then, we discuss in detail the retrieval and integration techniques proposed in the reviewed methods. Finally, we point out the challenges of RAKI and list some relevant work to deal with them. We would like to point out that this survey aims to focus on (pure) NLP and does not consider work on vision (Yang et al., 2021; Lin and Byrne, 2022) or audio (Zhao et al., 2023a).

heading: 2 Preliminaries
text: In the following, we briefly introduce retrievalaugmented generation (RAG) and then define and
45
formulate retrieval-augmented knowledge integration (RAKI). Retrieval-augmented generation is first proposed by Lewis et al. (2020), where world knowledge is retrieved from a vector index constructed over Wikipedia articles and then sent to a seq2seq (Sutskever et al., 2014) model for generation. More formally, given an input-output pair (x, y) from a generation task, retrieval-augmented generation aims to generate the target output y conditioned on the input x and an accessible document set Z for reference (Lewis et al., 2020; Yu, 2022). Retrieval-augmented knowledge integration Baek et al. (2023b) uses the term knowledge augmentation to address the practice of retrieving knowledge for language models. In this work, we adopt the term retrieval-augmented knowledge integration (RAKI) for better clarification, since we would like to avoid confusion with non-retrieval based knowledge-integration methods, as mentioned in Section 1, that involve heavy pre-training or fine-tuning. RAKI also follows the first-retrievethen-infer paradigm as in RAG, and we identify the differences as follows: (1) RAG, by its nature, deals with generation tasks, while RAKI is compatible with classification tasks as well, i.e. y being a class label (Yu et al., 2023). (2) RAG typically retrieves general documents for generation, while RAKI further specifies certain knowledge sources (e.g. an external knowledge graph) as retrieval base for better factuality (Baek et al., 2023b). Definition The setting of RAKI can then be formulated as follows: Given a user input x from task T and a specific knowledge source (to be discussed in Section 3), we denote y as target output and K as whole knowledge from the source. RAKI consists of two components (Baek et al., 2023b): (1) a retriever R which selects a subset K′ from knowledge K:
K′ = R(x;K), (1)
where normally |K ′| ≪ |K| in this retrieval step; (2) a language model M targeted for task T . M takes both the input x and the retrieved knowledge K′ for prediction:
y′ = M(x;K′). (2)
This step is referred to as integration. Due to the growing in-context reasoning skills (Brown et al., 2020; Chen, 2023) of language models, prompting (Schick and Schütze, 2021; Liu et al., 2023b)
has become the go-to paradigm to integrate external knowledge. In prompting, the retrieved K′ is formulated as text to be inserted into a prompt containing x (Baek et al., 2023b; Zhang et al., 2023c). Then the formulated prompt is sent to LMs for generation. Besides augmentation via prompts, this survey also discusses non-prompting techniques to integrate retrieved K′, which are often based on LMs as encoders to produce representations of x and K′ (e.g. in Section 3.1.2 and Section 3.2.2).
In the following, we use the definitions and notations above to discuss retrieval and integration in detail for the cases of K specified as knowledge graph (Section 3.1), tabular (Section 3.2) and natural language (Section 3.3).

heading: 3 Different Knowledge Sources as K
text: We cover two structured knowledge: graph-based (knowledge graph) and row-based (tabular), as well as unstructured knowledge (natural language).

heading: 3.1 Knowledge Graph
text: Knowledge graphs (KGs) store rich factual knowledge of things, especially relational information by its graph structure. A KG can be defined as:
K := (E,R), (3)
where E is the set of entity nodes, and each edge r ∈ R is a relation that connects a head entity eh and a tail entity et in the graph (Wang et al., 2019). The corresponding 3-element tuple (eh, r, et) is then referred to as a triple.
Table 1 in Appendix presents an overview of the KGs applied in the literature related to retrievalbased knowledge integration. Table 2 in Appendix summarizes the application of these KGs, showing that retrieving KGs can help with knowledgeintensive tasks such as knowledge graph question answering (Baek et al., 2023a). The entity-centered nature of KGs also makes them suitable for information extraction tasks such as named entity recognition (Zhang et al., 2023a; Fu et al., 2023) and relation classification (Fu et al., 2023).

heading: 3.1.1 Graph Retrieval
text: The goal of graph retrieval is to extract a subgraph K′ of K given input x. Subgraph K′ can be represented as a list of top-k retrieved triples (Andrus et al., 2022; Baek et al., 2023b; Fu et al., 2023):
K′ = R(x;K) = {(ehi, ri, eti)}ki=1, (4)
where ehi, ri and eti denote the head entity, the relation and the tail entity in the i-th triple.
Some previous work (Zhang et al., 2023a) requires only entity information such as entity descriptions from the knowledge graph. The resulting subgraph is then a list of entities without relations:
K′ = {ei}ki=1. (5)
In both cases, entity retrieval can usually be the first step. Therefore, we next introduce entity retrieval first, and then triple retrieval. Entity retrieval Entity retrieval finds the most relevant entity candidates that match input x, as described in Equation 5. Linked entity IDs and recognized entity names are intuitive features for entity retrieval, requiring an additional entity recognition (Akbik et al., 2019) or entity linking (De Cao et al., 2021) procedure over x before retrieval.
As for entity IDs: Fu et al. (2023) employ TagMe (Ferragina and Scaiella, 2010) to detect and link entity mentions in x. TagMe provides linked entities as their IDs from Wikipedia, thus enabling Fu et al. (2023) to find exact match in the Wiki-based KG Wikidata5M (Wang et al., 2021).
As for entity names: Li et al. (2023) use a large language model Codex (Chen et al., 2021) to extract entity names of interest automatically. The authors design a text-to-logic template “Question: {x} Logic Form: {logic form containing target retrieved entities}”, and provide few-shot examples of user query and corresponding logical forms for in-context learning. Given input x, the last element in the logical language generated by Codex is extracted as the entity name of interest. To deal with a multiple-choice QA task, Lv et al. (2020) identify1 potential entities both in question and in all five answer candidates, and find their matches in ConceptNet (Speer et al., 2017). Zhang et al. (2023a) train a binary classifier (Su et al., 2022) to identify potential entity mentions. Then for each positive span as a potential entity, Zhang et al. (2023a) use the tool ElasticSearch2 for its best matches in Wikidata (Vrandečić and Krötzsch, 2014). Shu et al. (2022) also employs span classifiers as mention detection models, but followed by an extra alias mapping tool (Gabrilovich et al., 2013) to obtain better candidate entities for each potential mention.
Other features such as n-gram have also been studied for entity retrieval. In this case, a preceding
1Their entity identification tool is not explicitly given. 2https://www.elastic.co/
entity detection step is not required before querying the KG. Young et al. (2018) and Li et al. (2022) enumerate n-grams out of input x, and then retrieve by checking if an n-gram is an exact entity entry in the KG. Bian et al. (2021) adapt similar settings to the task of multiple-choice question answering (QA), requiring exact match of n-grams between concept words from ConceptNet (Speer et al., 2017), and question and answer candidates from the task. Triple retrieval As described in Equation 4, triple retrieval finds the most relevant triples (eh, r, et) as KG facts for final augmentation.
(1) Triple retrieval from retrieved entities. A simple and intuitive solution is to base on the result of the above-mentioned entity retrieval: given candidate entities {ei} resulted from entity retrieval, this solution retrieves triples that contain a candidate entity (i.e. from {ei}) either as head or tail (Fu et al., 2023; Young et al., 2018; Li et al., 2022; Zhang et al., 2023a; Baek et al., 2023b):
K′ = {(eh, r, et) ∈ K|eh or et ∈ {ei}}. (6)
Since retrieved entities {ei} are considered relevant to the input x, and triples in K′ explicitly involve at least one retrieved entity in {ei}, these triples are supposed to be relevant to x as well. Note that Equation 6 only includes triples that are directly connected to a retrieved entity, i.e. 1-hop away. To tackle problems that require multi-hop reasoning over graph, Feng et al. (2020) and Bian et al. (2021) further consider triples within a specified maximum distance from retrieved entities.
(2) Triple retrieval from triple semantics. One problem with such triple retrieval based on explicit entity-retrieval is, that not all triples involving retrieved entities are necessarily relevant to input x. Therefore, an alternative is the triple retrieval without prerequisite entity retrieval. In the course of that, a promising direction is to model relation r (or (eh, r, et)) and x directly. Most work in this direction study language models as shared encoder for x and verbalized relation r. They for instance reformulate r or (eh, r, et) in natural language. That enables pre-computable representations (Oguz et al., 2022) of relational knowledge before retrieval. Andrus et al. (2022), for instance, verbalize KG triples into natural language by joining eh, r, et with space and making necessary adjustments such as adding an auxiliary verb if r does not contain a verb, or adding the article the. The resulting verbalization is treated as a KG fact and denoted as v(eh, r, et).
In the case of a question answering task, Andrus et al. (2022) retrieve the KG fact with the minimum edit distance from x as top-1 relevant:
K′ = (e′h, r′, e′t) = argmin (eh,r,et)∈K dist(x, v(eh, r, et)). (7) For story completion though, Andrus et al. (2022) apply Sentence-BERT (Reimers and Gurevych, 2019) to embed x and KG facts. The KG fact with the maximum cosine similarity from x is retrieved. Baek et al. (2023a) also follow this first-verbalizethen-embed methodology, but apply MPNet (Song et al., 2020) as the shared encoder.
To summarize this retrieval subsection (Section 3.1.1), Table 3 in Appendix presents the discussed retrieval methods (both entity and triple).

heading: 3.1.2 Subgraph Integration
text: With the selected graph knowledge from graph retrieval (described in Section 3.1.1), the final step is to augment the input x with retrieved subgraph K′ for task T , given as:
y′ = M(x; {(ehi, ri, eti)}ki=1), (8)
or alternatively
y′ = M(x; {ei}ki=1) (9)
when only entity information is required (Zhang et al., 2023a) to perform task T . Based on the form of K′ when augmented to the language model, we discuss K′ represented as hard, discrete natural language prompts and soft, continuous embeddings. Prompt-based integration Table 4 (See Appendix) presents the prompts employed in prior work of knowledge graph integration. In promptbased settings, knowledge is inserted as text into a language model. A simple implementation is to append (Li et al., 2022; Fu et al., 2023) or prepend (Baek et al., 2023a,b) the retrieved triple(s) ‘as is’ to the input x, preserving the triple-structure of K′. Triples can also be augmented with task instruction (e.g. Below are the facts ...) (Baek et al., 2023a) or special tokens to highlight recognized entities (Fu et al., 2023) before concatenation with input.
Other works transform triples to natural phrases, to make the inserted knowledge more similar to input. The easiest way is to manually design a mapping from relation names to a descriptive natural language (NL) (Lv et al., 2020; Bian et al.,
2021; Zhang et al., 2023a), which will finally connect the head and tail entities in the prompt. For example, Bian et al. (2021) suggest mapping the relation Synonym to NL is the same as, so to reformulate the triple (Problem, Synonym, Challenge) as descriptive Problem is the same as Challenge.
Due to the advanced capability of LLMs of understanding and paraphrasing knowledge, even rewriting prompts (Wu et al., 2023; Zhu et al., 2023), some prior work studies the possibility of reformulating the retrieved KG triple with a language model. Bian et al. (2021) discuss paraphraseand retrieval-based reformulation of KG triples. They send the mapping-based descriptions (e.g. Problem is the same as Challenge) to an encoderdecoder LM to generate top decoded paraphrases. Besides, they also use the mapping-based descriptions to retrieve Wikipedia texts for retrieval-based descriptions. Bian et al. (2021) also point out that concatenation of the three types of reformulation (i.e. mapping-based, paraphrase-based and retrieval-based) delivers better performance than using any single type. Wu et al. (2023) adopt ChatGPT to paraphrase KG triples to free-form texts. Andrus et al. (2022) and Li et al. (2023) provide few-shot triple-to-text examples in user input to assist GPT models with paraphrase generation. Embedding integration In embedding-based KG integration , the retrieved entities {ei}ki=1 are explicitly embedded (denoted as E) before sending them to the language model:
y′ = M(x; {E(ehi,ri,eti)}ki=1) (10)
in the case of relations, and
y′ = M(x; {Eei}ki=1) (11)
in the case of entities. To integrate relation embeddings, Young et al. (2018) apply an LSTM to encode each retrieved triple r (such as incomnia, IsA, sleep_problem) and candidate response (such as A cup of milk could help you sleep.) in dialogue task. Bi-linear products of the encodings are then used to compute activation for each possible response. As for entity embeddings, Fu et al. (2023) evaluate entity embeddings of retrieved entities from various knowledge-intensive pre-trained LMs (Peters et al., 2019; Zhang et al., 2019). They point out the challenge of integrating multiple knowledge via embeddings (Fu et al., 2023), that it is hard to simply add embeddings from different entities and models
at a time without losing much information in each embedding.

heading: 3.2 Tabular
text: A tabular is a row-based format to store knowledge efficiently, with each row representing one entry:
K := {ri}i=1 = {(ai1, ai2, · · · , aiM )}i=1 (12)
Each row ri is a tabular item, normally describing an entity or event. ai1, ai2, · · · , aiM are M attributes of the i-th row, which can be given as text (e.g. entity description) or numerical values. Prior works also discuss the case of K being multiple tables (Herzig et al., 2021; Li et al., 2021).

heading: 3.2.1 Tabular Retrieval
text: Tabular retrieval can be performed on three levels: (1) Retrieve relevant tables from a collection of tables (Herzig et al., 2021; Li et al., 2021). (2) Retrieve relevant rows from a table, which describes the standard setting in table-QA (Wan et al., 2023). (3) Retrieve relevant blocks from relevant rows, by removing less important columns (Wan et al., 2023). The goal of tabular retrieval is to find the most relevant table blocks (i.e. sub-tabular):
K′ := {(aij1 , aij2 , · · · , aijm)}ki=1 (13)
where j1, · · · , jm are involved columns. (First-)Retrieval Retrieval based on neural representations have been adapted to tabular tasks since the success of deep passage retrieval (Karpukhin et al., 2020) over text. Herzig et al. (2021) employ TaPas (Herzig et al., 2020), a BERT (Devlin et al., 2019) model pre-trained with weak supervison for table parsing. For a table-QA task, both the question x and the table T ∈ K are encoded by TaPas, where the table T is textualized by concatenating the cell contents left-to-right, row by row. The top-k tables yielding maximum inner product with x at [CLS] token are retrieved. Instead of simply concatenating cells (Herzig et al., 2021; Oguz et al., 2022) for encoding tabular data, Wan et al. (2023) and Shi et al. (2023) rewrite each cell into “(column, value)” text, and concatenate this semistructured text of each row into a textual sequence. Refinement of tabular retrieval K′ from the first retrieval can still contain redundant information, e.g. less relevant rows from a retrieved table in a multi-table setting. Park et al. (2023) further refine the retriever setup by adding a reranking module after retrieval, to score each retrieved block
b ∈ K′. The relevance score is given by the output distribution of T5 (Raffel et al., 2020) over Rel (relevance) and Nonrel (non-relevance) from the prompt “query: {q} block: {b} relevant: ”. While this reranking technique aims to filter out less relevant rows from K′, Wan et al. (2023) propose to filter out columns: by applying a shared LM to encode x and rows given by a sequence of (attribute, value) pairs. The top-k rows are retrieved through maximum inner product search (Mussmann and Ermon, 2016). Irrelevant columns are removed by leveraging the encodings of x, K and previously retrieved rows. To further enrich augmentation, Zhong et al. (2022) perform an extra retrieval step over natural language sources for an informative passage and reformulate this tabular task to tabletext task (Li et al., 2021). This passage is then sent with retrieved table cells for final answer.

heading: 3.2.2 Sub-Tabular Integration
text: Prompt-based integration Given the top-k rows K′ = {ri}ki=1 from previous tabular retrieval, the most studied technique to integrate them is to textualize K′ and insert them into a prompt.
Herzig et al. (2021) and Zhong et al. (2022) formulate the prompt learning problem as extractive QA, by restricting the final output to be an exact span from retrieved table K′. As suggested in Devlin et al. (2019), they add a multi-layer perception on top of the LM and train the model to predict the start and end position correctly from textualized K′ in the prompt. Li et al. (2021) and Wan et al. (2023) regard the problem as a generative QA task, where normally a seq2seq LM is trained to generate the expected response.
Embedding integration To tackle very long contexts from retrieved tabulars {ri}ki=1 and original user input x, some works integrate encodings instead of text forms of tabular. Oguz et al. (2022), Park et al. (2023) and Shi et al. (2023) utilize an encoder-decoder where each retrieved row ri is textualized and then converted by the encoder into a contextualized embedding Ei := Enc(x||ri), where “||” concatenates a retrieved tabular row ri and the user input x. x denotes a question in a QA task (Park et al., 2023) or current conversation context in a dialogue system (Shi et al., 2023). Finally, the concatenation of {Ei}ki=1 is sent to the decoder to generate an answer (Park et al., 2023) or next response (Shi et al., 2023).

heading: 3.3 Natural Language
text: While the previous sections describe incorporating structured information, most RAG systems retrieve natural language (NL) documents, mainly because there is more knowledge available in text form than in structured form such as knowledge graph, and converting text to knowledge graph is challenging (Melnyk et al., 2022).
Formally, we define a natural language (NL) source to be the composite of text resources:
K := {Di}, (14)
where each Di is a document consisting of a sequence of tokens. While text is widely considered as unstructured (Hu et al., 2024; Mo et al., 2022), some works see that text can be semistructured, because of the sentence and paragraph structure (Ruan et al., 2022) by its nature, as well as handcrafted structural clues (Arivazhagan et al., 2023) such as headings and meta information. Despite their differences in structure, unstructured and semi-structured texts are predominately treated equally in the reader stage following the concatenation and/or compression of retrieved texts.
NL-based RAG systems like LangChain (Chase, 2022) and LlamaIndex (Liu, 2022) usually incorporate the following steps: (1) preparation including chunking and indexing, (2) (first-)retrieval, (3) reranking and (4) generation. Respectively, in this RAKI survey, we will describe (1), (2) and (3) in Section 3.3.1 (NL retrieval) and final prediction/generation in Section 3.3.2 (NL integration).

heading: 3.3.1 Natural Language Retrieval
text: Similar to graph and tabular retrieval, the goal of natural language retrieval is to get top-k text documents from K given the input query x, normally by using the scoring function of the retriever R:
K′ = R(x;K) = {Di}ki=1. (15)
Preparation Retrieval systems for natural language start with the collection of text features, including chunking and indexing. (1) Chunking: Since language models as retrievers have limited context size (e.g. 512 in BERT (Devlin et al., 2019)), documents might need to be split into smaller chunks. Choosing when to split a text into chunks without losing surrounding information is a difficult problem (Chen et al., 2023). While libraries like LangChain have several techniques that
split based on textual features like ending paragraphs, many approaches employ strides (overlapping text spans) (Wu and Mooney, 2022; Ram et al., 2023) to prevent incomplete information. In the case of semi-structured text, structural information such as title and meta information can be utilized in text/chunk preparation. Arivazhagan et al. (2023), for instance, proposes to first filter relevant documents based on abstracts and table of contents before considering passage snippets. (2) Indexing then computes and stores features of each chunk for fast retrieval. The features to be indexed depend on the applied retriever R, which will be discussed in the following paragraph. (First-)Retrieval Choosing a suitable retriever R for one’s setting comes with the following considerations: While sparse retrieval such as TF-IDF is straightforward and easy to compute, dense retrieval based on dense embeddings proves substantial effectiveness (Arabzadeh et al., 2021), especially when the query x and the document Di have limited common lexicon (Karpukhin et al., 2020). In RAG systems (Lewis et al., 2020; Chase, 2022), two dense retrieval approaches are mainly applied:
(1) Bi-encoder is normally a Transformer model that can produce text-level embeddings (Reimers and Gurevych, 2019): Document embeddings E(Di) are pre-computed offline during indexing, while query embedding E(x) is computed at inference. Embedding query and document separately (Lewis et al., 2020) by bi-encoder allows inner-product search within O(|K|) time, but results in weak interaction between query and documents (Erker et al., 2024) since bi-encoder was query-unaware when embedding documents.
(2) Cross-encoder directly models the relevance between query and documents, and produces a score S(x,Di) ∈ [0, 1] for each candidate document Di at inference, which is slow given a large K. Despite the cross-encoders can be substantially better than dense retrievers (Wang et al., 2022a), the computational cost makes cross-encoder only applicable to small datasets (Reimers and Gurevych, 2019) or as a re-ranking model (See next paragraph) based on first-retrieval results (Zhou et al., 2023b). Re-ranking Re-ranking bridges the gap between the two encoders (Glass et al., 2022; Ma et al., 2023): First, a bi-encoder is employed in a previous first-retrieval to quickly filter a (larger than k) set K of candidate documents. Then in re-ranking, a cross-encoder encodes x with each document Di in K and yields a ranking score S(x;Di) to get the
final k results. Besides the retrieve-then-rerank technique, other approaches have been proposed to achieve querydocument interaction or computational efficiency. ColBERT (Khattab and Zaharia, 2020) introduce a late interaction method based on the contextualized tokens of BERT that computes dot-product between multiple query vectors and multiple document vectors. PolyEncoders and PreTTR (MacAvaney et al., 2020) pre-compute representations offline and used self-attentive aggregators on top of these representations. Liu et al. (2024) sequentially feed all retrieved K′ alongside x through an accordingly fine-tuned LLM, resulting in a binary classification of their relevance. Similarly, Asai et al. (2024) and Jeong et al. (2024) propose an extended framework where an LLM predicts special tokens in the text indicating both the relevance of external knowledge.

heading: 3.3.2 Natural Language Integration
text: The integration of NL in RAG systems follows the retrieve-then-read paradigm (Lewis et al., 2020), where a small set of relevant context documents is retrieved and subsequently used alongside the question to generate an informed response. In this survey of RAKI, we generalize retrieval augmentation to generation and classification tasks, and also cover embedding-based methods for integration. Therefore, natural language integration can be categorized into the following three cases:
(1) Prompt integration for generation, by concatenating retrieved documents K′ = {Di}ki=1 and combining with query x in a prompt (Lewis et al., 2020; Guu et al., 2020; Wang et al., 2022b; Cai et al., 2023):
y′ = M(prompt(x,D1||D2|| · · · ||Dk)), (16) where M is the (generative) language model for final output and prompt(·) denotes the template that includes all its variables in a prompt.
(2) Embedding integration for generation, by processing query-document pairs separately:
Ei = Enc(x||Di), i = 1, · · · , k, (17) and combining the intermediate encodings in a final decoding stage (Izacard and Grave, 2021; Hofstätter et al., 2023; Zhang et al., 2023b):
y′ = Dec(x||E1||E2|| · · · ||Ek), (18) where Enc and Dec denote a LM encoder and decoder. The fusion of query x and encodings
{Ei}ki=1 during decoding stage mitigates the risk of exceeding the input context length.
(3) Embedding integration for classification, by embedding retrieved documents {Di}ki=1 as features in a kNN model (Khandelwal et al., 2020; Drozdov et al., 2022). The prediction is based on the majority vote or nearest neighbor over supervised labels of {Di}ki=1.

heading: 4 Challenges & Outlook
text: Here we summarize some challenges of retrievalaugmented knowledge integration techniques, followed by an outlook of the RAKI framework. Necessity of external knowledge In this survey, our definition in Section 2 and the many included works dive into retrieving and augmenting external knowledge, without questioning before retrieval if external knowledge is necessary. We discern two methodologies in identifying the need for external information during the pre-retrieval stage:
(1) Passively, by relying on self-consistency decoding techniques (Wang et al., 2023; Zhao et al., 2023b; Li et al., 2024). For example, Wang et al. (2023) allows to quantify the uncertainty associated with the use of parametric knowledge. By employing a non-zero temperature to ensure diversity, multiple generations are sampled and compared for similarity in the final output. If a set of answers yields a significant deviation above a threshold, it indicates substantial uncertainty, necessitating the introduction of external knowledge.
(2) Actively, by guiding the language model to generate special tokens as assessment of retrieved information (Asai et al., 2024; Jeong et al., 2024), or employing a separate model to score the need for external knowledge (Liu et al., 2024; Chen et al., 2024). For example, Chen et al. (2024) uses ChatGPT to score generated knowledge (based on internal, parameterized knowledge of LM) against retrieved passages (external) in a QA task. They find out for time-sensitive questions, external information is prioritized, while non-time-sensitive ones prompt comparison between generated and retrieved knowledge to determine the best source. Prediction consistency with knowledge RAKI formulated in Section 2 does not verify if LM predictions reflect knowledge. To address this issue, Sun et al. (2023) utilize an LLM discriminator framework to ensure consistent citations by prompting about various aspects of the generation: (1) whether the cited source supports the claim, (2)
whether any of the retrieved documents support the claim, and (3) whether the cited set of documents is minimal. Here minimal refers to the document set not containing any documents that are unnecessary for supporting the claim. Asai et al. (2024) and Jeong et al. (2024) again apply their special token generation scheme (discussed in Section 3.3.1 for reranking) to predict whether the generated claim is fully supported by the retrieved knowledge. Multi-step reasoning For simplicity of modelling, we formulate the RAKI problem in Section 2 as single pass. Apart from the single-pass pipeline, multi-step reasoning frameworks leverage multiple retrieve-and-read cycles. This approach facilitates the construction of coherent reasoning chains, enabling the system to address complex questions effectively (Liu et al., 2024, 2023a; Wang et al., 2024; Li et al., 2024; Zhou et al., 2023a). We summarize two primary approaches to integrating knowledge into reasoning frameworks: (1) Knowledge as a tool for verifying and refining reasoning steps postcreation (Li et al., 2024; Zhao et al., 2023b; Wang et al., 2024). For example, Zhao et al. (2023b) improve factuality during Chain-of-Thought (CoT) generation (Wei et al., 2022) by integrating an optional RAG stage, where an uninformed CoT chain undergoes self-consistency tests (Wang et al., 2023). Failing chains are refined by verifying questions for each step, retrieving relevant information, and creating a new knowledge-informed rationale. Based on this refined CoT rationale the final answer is corrected.
(2) Knowledge retrieval as an integral part of creating informed reasoning steps. Liu et al. (2023a) propose a framework for multi-step reasoning where questions are sequentially decomposed. A central component of this framework is an agent LLM delegating the answering process. This agent is tasked with determining whether to decompose a query further into sub-questions and deciding whether to retrieve external knowledge or answer internally for each step. Once enough information is collected, the LLM provides a final answer, ensuring grounded reasoning without the need for post-reasoning verification. Outlook As can be seen from the above mentioned challanges and solutions, research in retrievalaugmented knowledge integration has witnessed a growing role of LLMs. Besides the generation (integration) step where LLMs are good fits for by their nature, LLMs can also serve in the retrieval step, as retriever itself (Gao et al., 2023) or as dis-
criminator to assess the quality of retrieval (Liu et al., 2024). Beyond the retrieve-and-integrate framework of RAKI, LLMs bring several enrichment steps which are not discussed in Section 3, such as knowledge extraction (Xu et al., 2023) and consistency verification (Asai et al., 2024).

heading: 5 Related Work
text: Survey of surveys Recent surveys show the paradigm shift from traditional knowledge integration to retrieval augmentation: Wei et al. (2021) and Hu et al. (2024) provide an overview on different pre-training and fine-tuning techniques of knowledge enhancement, organized by different knowledge formats. Hu et al. (2024) cover retrievalaugmented methods also but restrict the source of retrieval to be text and the task to be natural language generation. Mialon et al. (2023) compare various retrieval augmentation methods over textual documents. Pan et al. (2024) narrow the source of knowledge to knowledge graphs (KGs). Ling et al. (2023) survey different methods to apply LLMs in a specialized domain, including retrieving explicit domain information for in-context learning. Zhao et al. (2023a) focus on the topic of multi-modal (such as vision and audio) retrieval-augmented generation (RAG) but also discuss structured knowledge for four tasks such as knowledge-grounded dialogue. Gao et al. (2023) and Hu and Lu (2024) both provide a short introduction of unstructured and structured data for augmentation, with a focus on available datasets/corpus. To our knowledge, there is still no comprehensive survey that studies both structured and unstructured sources and describes respective NLP techniques accordingly.

heading: 6 Conclusion
text: This survey paper studies recent works that augment language models by retrieving external knowledge sources. We categorize research in retrievalaugmented knowledge integration (RAKI) into three sections, according to knowledge format: knowledge graph, tabular, and natural language. Besides a comprehensive collection of knowledge retrieval and integration approaches, we also point out the limitations and challenges of current RAKI. We hope this survey could (1) help researchers who are looking for a technical-intensive overview and (2) encourage future work to improve current RAKI.
Limitations
Collecting papers for this survey using search engines (e.g. Google Scholar and dblp) is very challenging, mainly because: (1) It is infeasible to enumerate all possible search words to approach every potential paper of our interest. For example, we include knowledge augmentation/integration/enhancement in the search word list (See Appendix A.1 for complete list of search words), as well as their variants with suffix changes (e.g. knowledge augment/-ed). These words would still leave out a paper using knowledge augmenting or we fuse knowledge. (2) Each search engine has its own drawbacks (Appendix A.1 presents a detailed comparison of our employed search engines): e.g. ACL Anthology supports full-text search but mainly includes publications from *CL venues; dblp covers most venues but only supports search over title. Therefore, a relevant non-*CL publication might have been left out if its title does not match one of our specified search words.
We would also like to point out that this survey is focused on the methodological part of RAKI rather than performance. The idea of retrievalaugmentation is general and can thus be applied to a great variety of NLP tasks. Therefore, it makes limited sense to compare scores reported by papers that conduct different tasks.
Ethics Statement
In this survey, we (1) formulate the problem setting of RAKI and (2) collect, explain and analyse searched literature. As for (1), we try to make formulation objective by giving a general mathematical definition.
As for (2), we make the paper selection criteria public in Appendix A.1. As shown in Appendix A.2, 51.8% of the included papers are accepted at *CL venues, which require a mandatory ethics review since 2022. While we cannot ensure the absence of ethical issues in the selected papers from prior *CL and other venues (especially arXiv), we ensure the explanations and findings in this survey are presented objectively.

heading: Acknowledgments
text: We would like to thank the anonymous reviewers for their valuable comments and feedback on the paper. This work has been supported by the Federal Joint Committee of Germany (Gemeinsamer
Bundesausschuss) as part of the project ADBoard (01VSF21047).

heading: A Appendix
text: A.1 Literature Search Setup
Search words The search words we used are listed below3:
• retriev-e/-al augment/-ed/-ion • knowledge retriev-e/-al • open domain/book • knowledge inject-ed/–ion • knowledge augment/-ed/-ion • knowledge enhance/-ed/-ment • knowledge integrat-ed/-ion
Search engines We first considered the following four search engines: ACL Anthology, dblp, Google Scholar and Semantic Scholar. We summarized the pros and cons as follows after conducting some probation searches.
(1) ACL Anthology is the only one among the four that supports full-time search. However, it does not include most non-*CL publications.
(2) dblp supports partial match, so a word stem such as augment can also match augmentation and augmented, which greatly reduces our workload. However, it searches only over titles.
(3) Google Scholar searches over title and abstract, and also supports partial match as dblp. However, one paper can have duplicate items which require handcraft to de-duplicate.
(4) Semantic Scholar also searches over title and abstract as Google Scholar. However, applying its built-in filter (year, conference, etc.) can wrongly lead to only very few results. Search pipeline We use dblp and Google Scholar for literature search, since their pros and cons are complementary. Our search pipeline is defined as follows:
(1) We search on dblp and then Google Scholar the search words listed in the previous section.
(2) For all our searches, we filter those from after 2017 since this survey model-wise focuses on Tranformer-based language models.
(3) All search results are manually filtered based on their relevance to retrieval-augmented knowledge integration. For example, papers that match knowledge injection need to be further checked to contain retrieval-related content to be eligible.
(4) Finally, we de-duplicate results from Google Scholar and dblp. According to the ACL author
3Note that some words have variants: For example, augmentation and augmented for augment. Therefore, we need 6 separate searches for retriev-e/-al augment/-ed/-ion.
guidelines4 that referred version should be prioritized over preprints, we only keep the refereed version (mostly from dblp) of an accepted publication.
A.2 Statistics of Literature Statistics over years Our literature search resulted in 56 papers of RAKI, among which 1 from 2018, 1 from 2019, 5 from 2020, 4 from 2021, 12 from 2022, 24 from 2023 and 9 from 2024 (until April 2024). The trend of paper counts by year is given by Figure 1. Statistics over venues To get an overview of which venues publish the most works, we sort the venues by the number of their accepted papers in the resulted literature search:
• EMNLP (11): 8 from main + 3 from findings. • arXiv (10). • ACL (10): 8 from main + 2 from workshops. • NAACL (6): 4 from main + 1 from finding + 1 from workshop. • AAAI (5). • ICLR (4). • NeurIPS (2). • TKDE (2). • EACL (2): 1 from main + 1 from finding. • Other venues (5): 1 from ICML, IJCAI, SIGIR, TACL and TMLR each. Statistics of knowledge formats Among the 56 analysed papers, 19 are from knowledge graph, 8 from tabular and 32 from natural language. Note that the sum here exceeds 56 since a paper can involve more than one knowledge sources (Oguz et al., 2022; Mo et al., 2022; Hu and Lu, 2024).
4https://acl-org.github.io/policies/submission

heading: Future Work
text: We hope this survey could (1) help researchers who are looking for a technical-intensive overview and (2) encourage future work to improve current RAKI. Limitations
Collecting papers for this survey using search engines (e. g. Google Scholar and dblp) is very challenging, mainly because: (1) It is infeasible to enumerate all possible search words to approach every potential paper of our interest. For example, we include knowledge augmentation/integration/enhancement in the search word list (See Appendix A. 1 for complete list of search words), as well as their variants with suffix changes (e. g. knowledge augment/-ed). These words would still leave out a paper using knowledge augmenting or we fuse knowledge. (2) Each search engine has its own drawbacks (Appendix A. 1 presents a detailed comparison of our employed search engines): e. g. ACL Anthology supports full-text search but mainly includes publications from *CL venues; dblp covers most venues but only supports search over title. Therefore, a relevant non-*CL publication might have been left out if its title does not match one of our specified search words. We would also like to point out that this survey is focused on the methodological part of RAKI rather than performance. The idea of retrievalaugmentation is general and can thus be applied to a great variety of NLP tasks. Therefore, it makes limited sense to compare scores reported by papers that conduct different tasks