diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4206bdbc693..ee15a83efb4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,11 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 
 ### Added
 
+- We introduced a settings parameters to manage citations' relations local storage time-to-live with a default value set to 30 days. [#11189](https://github.com/JabRef/jabref/issues/11189)
+
+### Changed
+
+- We improved the citations relations caching by implementing an offline storage. [#11189](https://github.com/JabRef/jabref/issues/11189)
 - We added a tooltip to keywords that resemble Math Subject Classification (MSC) codes. [#12944](https://github.com/JabRef/jabref/issues/12944)
 - We added a feature to convert keywords that resemble MSC codes to their descriptions. [#12944](https://github.com/JabRef/jabref/issues/12944)
 - We introduced a new command line application called `jabkit`. [#13012](https://github.com/JabRef/jabref/pull/13012) [#110](https://github.com/JabRef/jabref/issues/110)
diff --git a/gradle.properties b/gradle.properties
index 583f52980fb..25870ec2e93 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,7 +2,7 @@ org.gradle.vfs.watch=true
 
 # Hint by https://docs.gradle.org/current/userguide/performance.html#increase_the_heap_size
 # Otherwise, one gets "Java heap space" errors.
-org.gradle.jvmargs=-Xmx6096M
+org.gradle.jvmargs=-Xmx6g
 
 # hint by https://docs.gradle.org/current/userguide/performance.html#enable_configuration_cache
 # Blocked by https://github.com/beryx/badass-jlink-plugin/issues/304
diff --git a/jabgui/src/main/java/org/jabref/gui/JabRefGUI.java b/jabgui/src/main/java/org/jabref/gui/JabRefGUI.java
index 21aed8e8bfa..b1af3c9aa24 100644
--- a/jabgui/src/main/java/org/jabref/gui/JabRefGUI.java
+++ b/jabgui/src/main/java/org/jabref/gui/JabRefGUI.java
@@ -30,6 +30,7 @@
 import org.jabref.gui.util.WebViewStore;
 import org.jabref.logic.UiCommand;
 import org.jabref.logic.ai.AiService;
+import org.jabref.logic.citation.SearchCitationsRelationsService;
 import org.jabref.logic.journals.JournalAbbreviationLoader;
 import org.jabref.logic.journals.JournalAbbreviationRepository;
 import org.jabref.logic.l10n.Localization;
@@ -66,6 +67,8 @@ public class JabRefGUI extends Application {
 
     // AI Service handles chat messages etc. Therefore, it is tightly coupled to the GUI.
     private static AiService aiService;
+    // CitationsAndRelationsSearchService is here configured for a local machine and so to the GUI.
+    private static SearchCitationsRelationsService citationsAndRelationsSearchService;
 
     private static FileUpdateMonitor fileUpdateMonitor;
     private static StateManager stateManager;
@@ -187,6 +190,14 @@ public void initialize() {
                 dialogService,
                 taskExecutor);
         Injector.setModelOrService(AiService.class, aiService);
+
+        JabRefGUI.citationsAndRelationsSearchService = new SearchCitationsRelationsService(
+                preferences.getImporterPreferences(),
+                preferences.getImportFormatPreferences(),
+                preferences.getFieldPreferences(),
+                entryTypesManager
+        );
+        Injector.setModelOrService(SearchCitationsRelationsService.class, citationsAndRelationsSearchService);
     }
 
     private void setupProxy() {
@@ -407,6 +418,8 @@ public void stop() {
         stopBackgroundTasks();
         LOGGER.trace("Shutting down thread pools");
         shutdownThreadPools();
+        LOGGER.trace("Closing citations and relations search service");
+        citationsAndRelationsSearchService.close();
         LOGGER.trace("Finished stop");
     }
 
diff --git a/jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java b/jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java
index dfc7969d2f1..b66e4e67a67 100644
--- a/jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java
+++ b/jabgui/src/main/java/org/jabref/gui/entryeditor/EntryEditor.java
@@ -56,6 +56,7 @@
 import org.jabref.gui.util.UiTaskExecutor;
 import org.jabref.logic.ai.AiService;
 import org.jabref.logic.bibtex.TypedBibEntry;
+import org.jabref.logic.citation.SearchCitationsRelationsService;
 import org.jabref.logic.help.HelpFile;
 import org.jabref.logic.importer.EntryBasedFetcher;
 import org.jabref.logic.importer.WebFetchers;
@@ -118,6 +119,7 @@ public class EntryEditor extends BorderPane implements PreviewControls, AdaptVis
     @Inject private KeyBindingRepository keyBindingRepository;
     @Inject private JournalAbbreviationRepository journalAbbreviationRepository;
     @Inject private AiService aiService;
+    @Inject private SearchCitationsRelationsService searchCitationsRelationsService;
 
     private final List<EntryEditorTab> allPossibleTabs = new ArrayList<>();
 
@@ -323,7 +325,16 @@ private List<EntryEditorTab> createTabs() {
         tabs.add(new MathSciNetTab());
         tabs.add(new FileAnnotationTab(stateManager));
         tabs.add(new SciteTab(preferences, taskExecutor, dialogService));
-        tabs.add(new CitationRelationsTab(dialogService, undoManager, stateManager, fileMonitor, preferences, taskExecutor, bibEntryTypesManager));
+        tabs.add(new CitationRelationsTab(
+                dialogService,
+                undoManager,
+                stateManager,
+                fileMonitor,
+                preferences,
+                taskExecutor,
+                bibEntryTypesManager,
+                searchCitationsRelationsService
+        ));
         tabs.add(new RelatedArticlesTab(buildInfo, preferences, dialogService, stateManager, taskExecutor));
         sourceTab = new SourceTab(
                 undoManager,
diff --git a/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsCache.java b/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsCache.java
deleted file mode 100644
index 2bae9b9aadb..00000000000
--- a/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsCache.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package org.jabref.gui.entryeditor.citationrelationtab;
-
-import java.util.List;
-import java.util.Map;
-
-import org.jabref.model.entry.BibEntry;
-import org.jabref.model.entry.identifier.DOI;
-
-import org.eclipse.jgit.util.LRUMap;
-
-public class BibEntryRelationsCache {
-    private static final Integer MAX_CACHED_ENTRIES = 100;
-    private static final Map<String, List<BibEntry>> CITATIONS_MAP = new LRUMap<>(MAX_CACHED_ENTRIES, MAX_CACHED_ENTRIES);
-    private static final Map<String, List<BibEntry>> REFERENCES_MAP = new LRUMap<>(MAX_CACHED_ENTRIES, MAX_CACHED_ENTRIES);
-
-    public List<BibEntry> getCitations(BibEntry entry) {
-        return CITATIONS_MAP.getOrDefault(entry.getDOI().map(DOI::asString).orElse(""), List.of());
-    }
-
-    public List<BibEntry> getReferences(BibEntry entry) {
-        return REFERENCES_MAP.getOrDefault(entry.getDOI().map(DOI::asString).orElse(""), List.of());
-    }
-
-    public void cacheOrMergeCitations(BibEntry entry, List<BibEntry> citations) {
-        entry.getDOI().ifPresent(doi -> CITATIONS_MAP.put(doi.asString(), citations));
-    }
-
-    public void cacheOrMergeReferences(BibEntry entry, List<BibEntry> references) {
-        entry.getDOI().ifPresent(doi -> REFERENCES_MAP.putIfAbsent(doi.asString(), references));
-    }
-
-    public boolean citationsCached(BibEntry entry) {
-        return CITATIONS_MAP.containsKey(entry.getDOI().map(DOI::asString).orElse(""));
-    }
-
-    public boolean referencesCached(BibEntry entry) {
-        return REFERENCES_MAP.containsKey(entry.getDOI().map(DOI::asString).orElse(""));
-    }
-}
diff --git a/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsRepository.java b/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsRepository.java
deleted file mode 100644
index 9e7d6aff0f7..00000000000
--- a/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsRepository.java
+++ /dev/null
@@ -1,73 +0,0 @@
-package org.jabref.gui.entryeditor.citationrelationtab;
-
-import java.util.List;
-
-import org.jabref.logic.importer.FetcherException;
-import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarFetcher;
-import org.jabref.model.entry.BibEntry;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class BibEntryRelationsRepository {
-    private static final Logger LOGGER = LoggerFactory.getLogger(BibEntryRelationsRepository.class);
-
-    private final SemanticScholarFetcher fetcher;
-    private final BibEntryRelationsCache cache;
-
-    public BibEntryRelationsRepository(SemanticScholarFetcher fetcher, BibEntryRelationsCache cache) {
-        this.fetcher = fetcher;
-        this.cache = cache;
-    }
-
-    public List<BibEntry> getCitations(BibEntry entry) {
-        if (needToRefreshCitations(entry)) {
-            forceRefreshCitations(entry);
-        }
-
-        return cache.getCitations(entry);
-    }
-
-    public List<BibEntry> getReferences(BibEntry entry) {
-        if (needToRefreshReferences(entry)) {
-            List<BibEntry> references;
-            try {
-                references = fetcher.searchCiting(entry);
-            } catch (FetcherException e) {
-                LOGGER.error("Error while fetching references", e);
-                references = List.of();
-            }
-            cache.cacheOrMergeReferences(entry, references);
-        }
-
-        return cache.getReferences(entry);
-    }
-
-    public void forceRefreshCitations(BibEntry entry) {
-        try {
-            List<BibEntry> citations = fetcher.searchCitedBy(entry);
-            cache.cacheOrMergeCitations(entry, citations);
-        } catch (FetcherException e) {
-            LOGGER.error("Error while fetching citations", e);
-        }
-    }
-
-    public boolean needToRefreshCitations(BibEntry entry) {
-        return !cache.citationsCached(entry);
-    }
-
-    public boolean needToRefreshReferences(BibEntry entry) {
-        return !cache.referencesCached(entry);
-    }
-
-    public void forceRefreshReferences(BibEntry entry) {
-        List<BibEntry> references;
-        try {
-            references = fetcher.searchCiting(entry);
-        } catch (FetcherException e) {
-            LOGGER.error("Error while fetching references", e);
-            references = List.of();
-        }
-        cache.cacheOrMergeReferences(entry, references);
-    }
-}
diff --git a/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/CitationRelationsTab.java b/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/CitationRelationsTab.java
index 0c3a7994602..b883672d884 100644
--- a/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/CitationRelationsTab.java
+++ b/jabgui/src/main/java/org/jabref/gui/entryeditor/citationrelationtab/CitationRelationsTab.java
@@ -49,10 +49,10 @@
 import org.jabref.logic.bibtex.BibEntryWriter;
 import org.jabref.logic.bibtex.FieldPreferences;
 import org.jabref.logic.bibtex.FieldWriter;
+import org.jabref.logic.citation.SearchCitationsRelationsService;
 import org.jabref.logic.database.DuplicateCheck;
 import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.importer.fetcher.citation.CitationFetcher;
-import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarFetcher;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.logic.os.OS;
 import org.jabref.logic.util.BackgroundTask;
@@ -90,7 +90,7 @@ public class CitationRelationsTab extends EntryEditorTab {
     private final DialogService dialogService;
     private final GuiPreferences preferences;
     private final TaskExecutor taskExecutor;
-    private final BibEntryRelationsRepository bibEntryRelationsRepository;
+    private final SearchCitationsRelationsService searchCitationsRelationsService;
     private final CitationsRelationsTabViewModel citationsRelationsTabViewModel;
     private final DuplicateCheck duplicateCheck;
     private final BibEntryTypesManager entryTypesManager;
@@ -103,7 +103,8 @@ public CitationRelationsTab(DialogService dialogService,
                                 FileUpdateMonitor fileUpdateMonitor,
                                 GuiPreferences preferences,
                                 TaskExecutor taskExecutor,
-                                BibEntryTypesManager bibEntryTypesManager) {
+                                BibEntryTypesManager bibEntryTypesManager,
+                                SearchCitationsRelationsService searchCitationsRelationsService) {
         this.dialogService = dialogService;
         this.preferences = preferences;
         this.taskExecutor = taskExecutor;
@@ -115,9 +116,16 @@ public CitationRelationsTab(DialogService dialogService,
 
         this.entryTypesManager = bibEntryTypesManager;
         this.duplicateCheck = new DuplicateCheck(entryTypesManager);
-        this.bibEntryRelationsRepository = new BibEntryRelationsRepository(new SemanticScholarFetcher(preferences.getImporterPreferences()),
-                new BibEntryRelationsCache());
-        citationsRelationsTabViewModel = new CitationsRelationsTabViewModel(preferences, undoManager, stateManager, dialogService, fileUpdateMonitor, taskExecutor);
+        this.searchCitationsRelationsService = searchCitationsRelationsService;
+
+        this.citationsRelationsTabViewModel = new CitationsRelationsTabViewModel(
+            preferences,
+            undoManager,
+            stateManager,
+            dialogService,
+            fileUpdateMonitor,
+            taskExecutor
+        );
     }
 
     /**
@@ -191,29 +199,48 @@ private SplitPane getPaneAndStartSearch(BibEntry entry) {
         citingVBox.getChildren().addAll(citingHBox, citingListView);
         citedByVBox.getChildren().addAll(citedByHBox, citedByListView);
 
-        refreshCitingButton.setOnMouseClicked(event -> searchForRelations(
-            entry,
-            citingListView,
-            abortCitingButton,
-            refreshCitingButton,
-            CitationFetcher.SearchType.CITES,
-            importCitingButton,
-            citingProgress,
-            true));
+        refreshCitingButton.setOnMouseClicked(_ -> {
+            searchForRelations(
+                    entry, 
+                    citingListView, 
+                    abortCitingButton,
+                    refreshCitingButton, 
+                    CitationFetcher.SearchType.CITES, 
+                    importCitingButton, 
+                    citingProgress);
+        });
 
-        refreshCitedByButton.setOnMouseClicked(event -> searchForRelations(entry, citedByListView, abortCitedButton,
-                refreshCitedByButton, CitationFetcher.SearchType.CITED_BY, importCitedByButton, citedByProgress, true));
+        refreshCitedByButton.setOnMouseClicked(_ -> searchForRelations(
+                entry, 
+                citedByListView, 
+                abortCitedButton,
+                refreshCitedByButton, 
+                CitationFetcher.SearchType.CITED_BY, 
+                importCitedByButton, 
+                citedByProgress));
 
         // Create SplitPane to hold all nodes above
         SplitPane container = new SplitPane(citingVBox, citedByVBox);
         styleFetchedListView(citedByListView);
         styleFetchedListView(citingListView);
 
-        searchForRelations(entry, citingListView, abortCitingButton, refreshCitingButton,
-                CitationFetcher.SearchType.CITES, importCitingButton, citingProgress, false);
-
-        searchForRelations(entry, citedByListView, abortCitedButton, refreshCitedByButton,
-                CitationFetcher.SearchType.CITED_BY, importCitedByButton, citedByProgress, false);
+        searchForRelations(
+                entry, 
+                citingListView, 
+                abortCitingButton, 
+                refreshCitingButton,
+                CitationFetcher.SearchType.CITES, 
+                importCitingButton, 
+                citingProgress);
+
+        searchForRelations(
+                entry, 
+                citedByListView, 
+                abortCitedButton, 
+                refreshCitedByButton,
+                CitationFetcher.SearchType.CITED_BY, 
+                importCitedByButton, 
+                citedByProgress);
 
         return container;
     }
@@ -242,7 +269,7 @@ private void styleFetchedListView(CheckListView<CitationRelationItem> listView)
                         Button jumpTo = IconTheme.JabRefIcons.LINK.asButton();
                         jumpTo.setTooltip(new Tooltip(Localization.lang("Jump to entry in library")));
                         jumpTo.getStyleClass().add("addEntryButton");
-                        jumpTo.setOnMouseClicked(event -> jumpToEntry(entry));
+                        jumpTo.setOnMouseClicked(_ -> jumpToEntry(entry));
                         hContainer.setOnMouseClicked(event -> {
                                 if (event.getClickCount() == 2) {
                                     jumpToEntry(entry);
@@ -252,7 +279,7 @@ private void styleFetchedListView(CheckListView<CitationRelationItem> listView)
 
                         Button compareButton = IconTheme.JabRefIcons.MERGE_ENTRIES.asButton();
                         compareButton.setTooltip(new Tooltip(Localization.lang("Compare with existing entry")));
-                        compareButton.setOnMouseClicked(event -> openPossibleDuplicateEntriesWindow(entry, listView));
+                        compareButton.setOnMouseClicked(_ -> openPossibleDuplicateEntriesWindow(entry, listView));
                         vContainer.getChildren().add(compareButton);
                     } else {
                         ToggleButton addToggle = IconTheme.JabRefIcons.ADD.asToggleButton();
@@ -272,7 +299,7 @@ private void styleFetchedListView(CheckListView<CitationRelationItem> listView)
                     if (entry.entry().getDOI().isPresent() || entry.entry().getField(StandardField.URL).isPresent()) {
                         Button openWeb = IconTheme.JabRefIcons.OPEN_LINK.asButton();
                         openWeb.setTooltip(new Tooltip(Localization.lang("Open URL or DOI")));
-                        openWeb.setOnMouseClicked(event -> {
+                        openWeb.setOnMouseClicked(_ -> {
                             String url = entry.entry().getDOI().flatMap(DOI::getExternalURI).map(URI::toString)
                                               .or(() -> entry.entry().getField(StandardField.URL)).orElse("");
                             if (StringUtil.isNullOrEmpty(url)) {
@@ -289,7 +316,7 @@ private void styleFetchedListView(CheckListView<CitationRelationItem> listView)
 
                     Button showEntrySource = IconTheme.JabRefIcons.SOURCE.asButton();
                     showEntrySource.setTooltip(new Tooltip(Localization.lang("%0 source", "BibTeX")));
-                    showEntrySource.setOnMouseClicked(event -> showEntrySourceDialog(entry.entry()));
+                    showEntrySource.setOnMouseClicked(_ -> showEntrySourceDialog(entry.entry()));
 
                     vContainer.getChildren().addLast(showEntrySource);
 
@@ -298,9 +325,9 @@ private void styleFetchedListView(CheckListView<CitationRelationItem> listView)
 
                     return hContainer;
                 })
-                .withOnMouseClickedEvent((ee, event) -> {
-                    if (!ee.isLocal()) {
-                        listView.getCheckModel().toggleCheckState(ee);
+                .withOnMouseClickedEvent((citationRelationItem, _) -> {
+                    if (!citationRelationItem.isLocal()) {
+                        listView.getCheckModel().toggleCheckState(citationRelationItem);
                     }
                 })
                 .withPseudoClass(entrySelected, listView::getItemBooleanProperty)
@@ -407,7 +434,7 @@ protected void bindToEntry(BibEntry entry) {
      */
     private void searchForRelations(BibEntry entry, CheckListView<CitationRelationItem> listView, Button abortButton,
                                     Button refreshButton, CitationFetcher.SearchType searchType, Button importButton,
-                                    ProgressIndicator progress, boolean shouldRefresh) {
+                                    ProgressIndicator progress) {
         if (entry.getDOI().isEmpty()) {
             hideNodes(abortButton, progress);
             showNodes(refreshButton);
@@ -421,46 +448,61 @@ private void searchForRelations(BibEntry entry, CheckListView<CitationRelationIt
 
         listView.setItems(observableList);
 
+        // TODO: It should not be possible to cancel a search task that is already running for same tab
         if (citingTask != null && !citingTask.isCancelled() && searchType == CitationFetcher.SearchType.CITES) {
             citingTask.cancel();
         } else if (citedByTask != null && !citedByTask.isCancelled() && searchType == CitationFetcher.SearchType.CITED_BY) {
             citedByTask.cancel();
         }
 
-        BackgroundTask<List<BibEntry>> task;
-
-        if (searchType == CitationFetcher.SearchType.CITES) {
-            task = BackgroundTask.wrap(() -> {
-                if (shouldRefresh) {
-                    bibEntryRelationsRepository.forceRefreshReferences(entry);
-                }
-                return bibEntryRelationsRepository.getReferences(entry);
-            });
-            citingTask = task;
-        } else {
-            task = BackgroundTask.wrap(() -> {
-                if (shouldRefresh) {
-                    bibEntryRelationsRepository.forceRefreshCitations(entry);
-                }
-                return bibEntryRelationsRepository.getCitations(entry);
-            });
-            citedByTask = task;
-        }
-
-        task.onRunning(() -> prepareToSearchForRelations(abortButton, refreshButton, importButton, progress, task))
-            .onSuccess(fetchedList -> onSearchForRelationsSucceed(entry, listView, abortButton, refreshButton, searchType, importButton, progress, fetchedList, observableList))
+        this.createBackgroundTask(entry, searchType)
+            .consumeOnRunning(task -> prepareToSearchForRelations(
+                abortButton, refreshButton, importButton, progress, task
+            ))
+            .onSuccess(fetchedList -> onSearchForRelationsSucceed(
+                entry,
+                listView,
+                abortButton,
+                refreshButton,
+                searchType,
+                importButton,
+                progress,
+                fetchedList,
+                observableList
+            ))
             .onFailure(exception -> {
                 LOGGER.error("Error while fetching citing Articles", exception);
                 hideNodes(abortButton, progress, importButton);
                 listView.setPlaceholder(new Label(Localization.lang("Error while fetching citing entries: %0",
                         exception.getMessage())));
-
                 refreshButton.setVisible(true);
                 dialogService.notify(exception.getMessage());
             })
             .executeWith(taskExecutor);
     }
 
+    /**
+     * TODO: Make the method return a callable and let the calling method create the background task.
+     */
+    private BackgroundTask<List<BibEntry>> createBackgroundTask(
+        BibEntry entry, CitationFetcher.SearchType searchType
+    ) {
+        return switch (searchType) {
+            case CitationFetcher.SearchType.CITES -> {
+                citingTask = BackgroundTask.wrap(
+                    () -> this.searchCitationsRelationsService.searchReferences(entry)
+                );
+                yield citingTask;
+            }
+            case CitationFetcher.SearchType.CITED_BY -> {
+                citedByTask = BackgroundTask.wrap(
+                    () -> this.searchCitationsRelationsService.searchCitations(entry)
+                );
+                yield citedByTask;
+            }
+        };
+    }
+
     private void onSearchForRelationsSucceed(BibEntry entry, CheckListView<CitationRelationItem> listView,
                                              Button abortButton, Button refreshButton,
                                              CitationFetcher.SearchType searchType, Button importButton,
diff --git a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java
index 2a9073041d0..6a2f75f83b4 100644
--- a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java
+++ b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java
@@ -26,6 +26,7 @@
 
 import com.airhacks.afterburner.views.ViewLoader;
 import com.tobiasdiez.easybind.EasyBind;
+import org.apache.logging.log4j.util.Strings;
 
 public class WebSearchTab extends AbstractPreferenceTabView<WebSearchTabViewModel> implements PreferencesTab {
 
@@ -36,6 +37,7 @@ public class WebSearchTab extends AbstractPreferenceTabView<WebSearchTabViewMode
     @FXML private CheckBox addImportedEntries;
     @FXML private TextField addImportedEntriesGroupName;
     @FXML private ComboBox<PlainCitationParserChoice> defaultPlainCitationParser;
+    @FXML private TextField citationsRelationStoreTTL;
 
     @FXML private CheckBox useCustomDOI;
     @FXML private TextField useCustomDOIName;
@@ -88,6 +90,25 @@ public void initialize() {
         defaultPlainCitationParser.itemsProperty().bind(viewModel.plainCitationParsers());
         defaultPlainCitationParser.valueProperty().bindBidirectional(viewModel.defaultPlainCitationParserProperty());
 
+        viewModel.citationsRelationsStoreTTLProperty()
+                 .addListener((_, _, newValue) -> {
+                     if (newValue != null && !newValue.toString().equals(citationsRelationStoreTTL.getText())) {
+                         citationsRelationStoreTTL.setText(newValue.toString());
+                     }
+                 });
+        citationsRelationStoreTTL
+                .textProperty()
+                .addListener((_, _, newValue) -> {
+                    if (Strings.isBlank(newValue)) {
+                        return;
+                    }
+                    if (!newValue.matches("\\d*")) {
+                        citationsRelationStoreTTL.setText(newValue.replaceAll("\\D", ""));
+                        return;
+                    }
+                    viewModel.citationsRelationsStoreTTLProperty().set(Integer.parseInt(newValue));
+                });
+
         grobidEnabled.selectedProperty().bindBidirectional(viewModel.grobidEnabledProperty());
         grobidURL.textProperty().bindBidirectional(viewModel.grobidURLProperty());
         grobidURL.disableProperty().bind(grobidEnabled.selectedProperty().not());
@@ -121,7 +142,7 @@ public void initialize() {
         new ViewModelTableRowFactory<FetcherApiKey>()
                 .install(apiKeySelectorTable);
 
-        apiKeySelectorTable.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
+        apiKeySelectorTable.getSelectionModel().selectedItemProperty().addListener((_, oldValue, newValue) -> {
             if (oldValue != null) {
                 updateFetcherApiKey(oldValue);
             }
@@ -161,7 +182,7 @@ public void initialize() {
         apiKeySelectorTable.setItems(viewModel.fetcherApiKeys());
 
         // Content is set later
-        viewModel.fetcherApiKeys().addListener((InvalidationListener) change -> {
+        viewModel.fetcherApiKeys().addListener((InvalidationListener) _ -> {
             if (!apiKeySelectorTable.getItems().isEmpty()) {
                 apiKeySelectorTable.getSelectionModel().selectFirst();
             }
diff --git a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java
index e22198286b4..f5785fd2933 100644
--- a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java
+++ b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java
@@ -6,10 +6,12 @@
 import java.util.stream.Collectors;
 
 import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.IntegerProperty;
 import javafx.beans.property.ListProperty;
 import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.ReadOnlyBooleanProperty;
 import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleIntegerProperty;
 import javafx.beans.property.SimpleListProperty;
 import javafx.beans.property.SimpleObjectProperty;
 import javafx.beans.property.SimpleStringProperty;
@@ -49,6 +51,8 @@ public class WebSearchTabViewModel implements PreferenceTabViewModel {
             new SimpleListProperty<>(FXCollections.observableArrayList(PlainCitationParserChoice.values()));
     private final ObjectProperty<PlainCitationParserChoice> defaultPlainCitationParser = new SimpleObjectProperty<>();
 
+    private final IntegerProperty citationsRelationStoreTTL = new SimpleIntegerProperty();
+
     private final BooleanProperty addImportedEntries = new SimpleBooleanProperty();
     private final StringProperty addImportedEntriesGroupName = new SimpleStringProperty("");
 
@@ -137,6 +141,7 @@ public void setValues() {
         addImportedEntries.setValue(libraryPreferences.isAddImportedEntriesEnabled());
         addImportedEntriesGroupName.setValue(libraryPreferences.getAddImportedEntriesGroupName());
         defaultPlainCitationParser.setValue(importerPreferences.getDefaultPlainCitationParser());
+        citationsRelationStoreTTL.setValue(importerPreferences.getCitationsRelationsStoreTTL());
 
         useCustomDOIProperty.setValue(doiPreferences.isUseCustom());
         useCustomDOINameProperty.setValue(doiPreferences.getDefaultBaseURI());
@@ -174,6 +179,7 @@ public void storeSettings() {
             libraryPreferences.setAddImportedEntriesGroupName(addImportedEntriesGroupName.getValue());
         }
         importerPreferences.setDefaultPlainCitationParser(defaultPlainCitationParser.getValue());
+        importerPreferences.setCitationsRelationsStoreTTL(citationsRelationStoreTTL.getValue());
 
         grobidPreferences.setGrobidEnabled(grobidEnabledProperty.getValue());
         grobidPreferences.setGrobidUseAsked(grobidPreferences.isGrobidUseAsked());
@@ -260,6 +266,10 @@ public BooleanProperty getApikeyPersistProperty() {
         return apikeyPersistProperty;
     }
 
+    public IntegerProperty citationsRelationsStoreTTLProperty() {
+        return citationsRelationStoreTTL;
+    }
+
     public void checkCustomApiKey() {
         final String apiKeyName = selectedApiKeyProperty.get().getName();
 
diff --git a/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml b/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml
index 6675f474304..987561b711a 100644
--- a/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml
+++ b/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml
@@ -29,6 +29,10 @@
         <Label text="%Default plain citation parser"/>
         <ComboBox fx:id="defaultPlainCitationParser" HBox.hgrow="ALWAYS"/>
     </HBox>
+    <HBox alignment="CENTER_LEFT" spacing="10">
+        <Label text="%Citations relations local storage time-to-live (in days)"/>
+        <TextField fx:id="citationsRelationStoreTTL" prefWidth="60"/>
+    </HBox>
 
     <Label styleClass="sectionHeader" text="%Custom DOI URI"/>
     <HBox alignment="CENTER_LEFT" spacing="10.0">
diff --git a/jabgui/src/test/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsRepositoryTest.java b/jabgui/src/test/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsRepositoryTest.java
deleted file mode 100644
index 8a242caefba..00000000000
--- a/jabgui/src/test/java/org/jabref/gui/entryeditor/citationrelationtab/BibEntryRelationsRepositoryTest.java
+++ /dev/null
@@ -1,62 +0,0 @@
-package org.jabref.gui.entryeditor.citationrelationtab;
-
-import java.util.List;
-
-import org.jabref.logic.importer.FetcherException;
-import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarFetcher;
-import org.jabref.model.entry.BibEntry;
-import org.jabref.model.entry.field.StandardField;
-
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-class BibEntryRelationsRepositoryTest {
-
-    private List<BibEntry> getCitedBy(BibEntry entry) {
-        return List.of(createCitingBibEntry(entry));
-    }
-
-    private BibEntry createBibEntry(int i) {
-        return new BibEntry()
-                .withCitationKey("entry" + i)
-                .withField(StandardField.DOI, "10.1234/5678" + i);
-    }
-
-    private BibEntry createCitingBibEntry(Integer i) {
-        return new BibEntry()
-                .withCitationKey("citing_entry" + i)
-                .withField(StandardField.DOI, "10.2345/6789" + i);
-    }
-
-    private BibEntry createCitingBibEntry(BibEntry citedEntry) {
-        return createCitingBibEntry(Integer.valueOf(citedEntry.getCitationKey().get().substring(5)));
-    }
-
-    @Test
-    void getCitations() throws FetcherException {
-        SemanticScholarFetcher semanticScholarFetcher = mock(SemanticScholarFetcher.class);
-        when(semanticScholarFetcher.searchCitedBy(any(BibEntry.class))).thenAnswer(invocation -> {
-            BibEntry entry = invocation.getArgument(0);
-            return getCitedBy(entry);
-        });
-        BibEntryRelationsCache bibEntryRelationsCache = new BibEntryRelationsCache();
-
-        BibEntryRelationsRepository bibEntryRelationsRepository = new BibEntryRelationsRepository(semanticScholarFetcher, bibEntryRelationsCache);
-
-        for (int i = 0; i < 150; i++) {
-            BibEntry entry = createBibEntry(i);
-            List<BibEntry> citations = bibEntryRelationsRepository.getCitations(entry);
-            assertEquals(getCitedBy(entry), citations);
-        }
-
-        for (int i = 0; i < 150; i++) {
-            BibEntry entry = createBibEntry(i);
-            List<BibEntry> citations = bibEntryRelationsRepository.getCitations(entry);
-            assertEquals(getCitedBy(entry), citations);
-        }
-    }
-}
diff --git a/jablib/src/main/java/module-info.java b/jablib/src/main/java/module-info.java
index a792ae43f7d..ba63449bb8a 100644
--- a/jablib/src/main/java/module-info.java
+++ b/jablib/src/main/java/module-info.java
@@ -101,9 +101,11 @@
     exports org.jabref.model.study;
     exports org.jabref.logic.shared.security;
     exports org.jabref.logic.shared.event;
+    exports org.jabref.logic.citation;
     exports org.jabref.logic.crawler;
     exports org.jabref.logic.git;
     exports org.jabref.logic.pseudonymization;
+    exports org.jabref.logic.citation.repository;
 
     requires java.base;
 
diff --git a/jablib/src/main/java/org/jabref/logic/citation/SearchCitationsRelationsService.java b/jablib/src/main/java/org/jabref/logic/citation/SearchCitationsRelationsService.java
new file mode 100644
index 00000000000..95db8900c1b
--- /dev/null
+++ b/jablib/src/main/java/org/jabref/logic/citation/SearchCitationsRelationsService.java
@@ -0,0 +1,89 @@
+package org.jabref.logic.citation;
+
+import java.util.List;
+
+import org.jabref.logic.bibtex.FieldPreferences;
+import org.jabref.logic.citation.repository.BibEntryCitationsAndReferencesRepository;
+import org.jabref.logic.citation.repository.BibEntryCitationsAndReferencesRepositoryShell;
+import org.jabref.logic.importer.FetcherException;
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.logic.importer.ImporterPreferences;
+import org.jabref.logic.importer.fetcher.citation.CitationFetcher;
+import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarCitationFetcher;
+import org.jabref.logic.util.Directories;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibEntryTypesManager;
+
+import com.google.common.annotations.VisibleForTesting;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SearchCitationsRelationsService {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SearchCitationsRelationsService.class);
+
+    private final CitationFetcher citationFetcher;
+    private final BibEntryCitationsAndReferencesRepository relationsRepository;
+
+    public SearchCitationsRelationsService(ImporterPreferences importerPreferences,
+                                           ImportFormatPreferences importFormatPreferences,
+                                           FieldPreferences fieldPreferences,
+                                           BibEntryTypesManager entryTypesManager) {
+        this.citationFetcher = new SemanticScholarCitationFetcher(importerPreferences);
+        this.relationsRepository = BibEntryCitationsAndReferencesRepositoryShell.of(
+                Directories.getCitationsRelationsDirectory(),
+                importerPreferences.getCitationsRelationsStoreTTL(),
+                importFormatPreferences,
+                fieldPreferences,
+                entryTypesManager
+        );
+    }
+
+    /**
+     * @implNote Typically, this would be a Shim in JavaFX
+     */
+    @VisibleForTesting
+    public SearchCitationsRelationsService(CitationFetcher citationFetcher,
+                                           BibEntryCitationsAndReferencesRepository repository
+    ) {
+        this.citationFetcher = citationFetcher;
+        this.relationsRepository = repository;
+    }
+
+    public List<BibEntry> searchReferences(BibEntry referenced) {
+        boolean isFetchingAllowed = relationsRepository.isReferencesUpdatable(referenced)
+            || !relationsRepository.containsReferences(referenced);
+        if (isFetchingAllowed) {
+            try {
+                List<BibEntry> referencedBy = citationFetcher.searchCiting(referenced);
+                relationsRepository.insertReferences(referenced, referencedBy);
+            } catch (FetcherException e) {
+                LOGGER.error("Error while fetching references for entry {}", referenced.getTitle(), e);
+            }
+        }
+        return relationsRepository.readReferences(referenced);
+    }
+
+    /**
+     * If the store was empty and nothing was fetch in any case (empty fetch, or error) then yes => empty list
+     * If the store was not empty and nothing was fetched after a successful fetch => the store will be erased and the returned collection will be empty
+     * If the store was not empty and an error occurs while fetching => will return the content of the store
+     */
+    public List<BibEntry> searchCitations(BibEntry cited) {
+        boolean isFetchingAllowed = relationsRepository.isCitationsUpdatable(cited)
+            || !relationsRepository.containsCitations(cited);
+        if (isFetchingAllowed) {
+            try {
+                List<BibEntry> citedBy = citationFetcher.searchCitedBy(cited);
+                relationsRepository.insertCitations(cited, citedBy);
+            } catch (FetcherException e) {
+                LOGGER.error("Error while fetching citations for entry {}", cited.getTitle(), e);
+            }
+        }
+        return relationsRepository.readCitations(cited);
+    }
+
+    public void close() {
+        relationsRepository.close();
+    }
+}
diff --git a/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepository.java b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepository.java
new file mode 100644
index 00000000000..6f019ef369e
--- /dev/null
+++ b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepository.java
@@ -0,0 +1,26 @@
+package org.jabref.logic.citation.repository;
+
+import java.util.List;
+
+import org.jabref.model.entry.BibEntry;
+
+public interface BibEntryCitationsAndReferencesRepository {
+
+    void insertCitations(BibEntry entry, List<BibEntry> citations);
+
+    List<BibEntry> readCitations(BibEntry entry);
+
+    boolean containsCitations(BibEntry entry);
+
+    boolean isCitationsUpdatable(BibEntry entry);
+
+    void insertReferences(BibEntry entry, List<BibEntry> citations);
+
+    List<BibEntry> readReferences(BibEntry entry);
+
+    boolean containsReferences(BibEntry entry);
+
+    boolean isReferencesUpdatable(BibEntry entry);
+
+    void close();
+}
diff --git a/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepositoryShell.java b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepositoryShell.java
new file mode 100644
index 00000000000..5453fa3873d
--- /dev/null
+++ b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepositoryShell.java
@@ -0,0 +1,96 @@
+package org.jabref.logic.citation.repository;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Objects;
+
+import org.jabref.logic.bibtex.FieldPreferences;
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibEntryTypesManager;
+
+public class BibEntryCitationsAndReferencesRepositoryShell implements BibEntryCitationsAndReferencesRepository {
+
+    private static final String CITATIONS_STORE = "citations";
+    private static final String REFERENCES_STORE = "references";
+
+    private final BibEntryRelationRepository citationsDao;
+    private final BibEntryRelationRepository referencesDao;
+
+    public BibEntryCitationsAndReferencesRepositoryShell(
+        BibEntryRelationRepository citationsDao,
+        BibEntryRelationRepository referencesDao
+    ) {
+        this.citationsDao = citationsDao;
+        this.referencesDao = referencesDao;
+    }
+
+    @Override
+    public void insertCitations(BibEntry entry, List<BibEntry> citations) {
+        citationsDao.addRelations(
+            entry, Objects.requireNonNullElseGet(citations, List::of)
+        );
+    }
+
+    @Override
+    public List<BibEntry> readCitations(BibEntry entry) {
+        if (entry == null) {
+            return List.of();
+        }
+        return citationsDao.getRelations(entry);
+    }
+
+    @Override
+    public boolean containsCitations(BibEntry entry) {
+        return citationsDao.containsKey(entry);
+    }
+
+    @Override
+    public boolean isCitationsUpdatable(BibEntry entry) {
+        return citationsDao.shouldUpdate(entry);
+    }
+
+    @Override
+    public void insertReferences(BibEntry entry, List<BibEntry> references) {
+        referencesDao.addRelations(
+            entry, Objects.requireNonNullElseGet(references, List::of)
+        );
+    }
+
+    @Override
+    public List<BibEntry> readReferences(BibEntry entry) {
+        if (entry == null) {
+            return List.of();
+        }
+        return referencesDao.getRelations(entry);
+    }
+
+    @Override
+    public boolean containsReferences(BibEntry entry) {
+        return referencesDao.containsKey(entry);
+    }
+
+    @Override
+    public boolean isReferencesUpdatable(BibEntry entry) {
+        return referencesDao.shouldUpdate(entry);
+    }
+
+    @Override
+    public void close() {
+        this.citationsDao.close();
+        this.referencesDao.close();
+    }
+
+    public static BibEntryCitationsAndReferencesRepositoryShell of(Path citationsRelationsDirectory,
+                                                                   int storeTTL,
+                                                                   ImportFormatPreferences importFormatPreferences,
+                                                                   FieldPreferences fieldPreferences,
+                                                                   BibEntryTypesManager entryTypesManager) {
+        Path citationsPath = citationsRelationsDirectory.resolve("%s.mv".formatted(CITATIONS_STORE));
+        Path relationsPath = citationsRelationsDirectory.resolve("%s.mv".formatted(REFERENCES_STORE));
+        return new BibEntryCitationsAndReferencesRepositoryShell(
+                new MVStoreBibEntryRelationRepository(citationsPath, CITATIONS_STORE, storeTTL, entryTypesManager, importFormatPreferences, fieldPreferences),
+                new MVStoreBibEntryRelationRepository(relationsPath, REFERENCES_STORE, storeTTL, entryTypesManager, importFormatPreferences, fieldPreferences)
+        );
+    }
+}
diff --git a/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryHashSetSerializer.java b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryHashSetSerializer.java
new file mode 100644
index 00000000000..278085f9727
--- /dev/null
+++ b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryHashSetSerializer.java
@@ -0,0 +1,62 @@
+package org.jabref.logic.citation.repository;
+
+import java.nio.ByteBuffer;
+import java.util.LinkedHashSet;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import org.jabref.logic.bibtex.FieldPreferences;
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibEntryTypesManager;
+
+import org.h2.mvstore.WriteBuffer;
+import org.h2.mvstore.type.BasicDataType;
+
+class BibEntryHashSetSerializer extends BasicDataType<LinkedHashSet<BibEntry>> {
+
+    private final BasicDataType<BibEntry> bibEntryDataType;
+
+    BibEntryHashSetSerializer(BibEntryTypesManager entryTypesManager, ImportFormatPreferences importFormatPreferences, FieldPreferences fieldPreferences) {
+        this.bibEntryDataType = new BibEntrySerializer(entryTypesManager, importFormatPreferences, fieldPreferences);
+    }
+
+    BibEntryHashSetSerializer(BasicDataType<BibEntry> bibEntryDataType) {
+        this.bibEntryDataType = bibEntryDataType;
+    }
+
+    @Override
+    public int getMemory(LinkedHashSet<BibEntry> bibEntries) {
+        // Memory size is the sum of all aggregated bibEntries' memory size plus 4 bytes.
+        // Those 4 bytes are used to store the length of the collection itself.
+        return bibEntries
+                .stream()
+                .map(this.bibEntryDataType::getMemory)
+                .reduce(0, Integer::sum) + 4;
+    }
+
+    @Override
+    public void write(WriteBuffer buff, LinkedHashSet<BibEntry> bibEntries) {
+        buff.putInt(bibEntries.size());
+        bibEntries.forEach(entry -> this.bibEntryDataType.write(buff, entry));
+    }
+
+    @Override
+    public LinkedHashSet<BibEntry> read(ByteBuffer buff) {
+        return IntStream.range(0, buff.getInt())
+                        .mapToObj(it -> this.bibEntryDataType.read(buff))
+                        .filter(entry -> !entry.isEmpty())
+                        .collect(Collectors.toCollection(LinkedHashSet::new));
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public LinkedHashSet<BibEntry>[] createStorage(int size) {
+        return (LinkedHashSet<BibEntry>[]) new LinkedHashSet[size];
+    }
+
+    @Override
+    public boolean isMemoryEstimationAllowed() {
+        return false;
+    }
+}
diff --git a/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryRelationRepository.java b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryRelationRepository.java
new file mode 100644
index 00000000000..f58e495a02c
--- /dev/null
+++ b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntryRelationRepository.java
@@ -0,0 +1,26 @@
+package org.jabref.logic.citation.repository;
+
+import java.util.List;
+
+import org.jabref.model.entry.BibEntry;
+
+/**
+ * Generic interface for a repository that stores relations between BibEntries.
+ */
+public interface BibEntryRelationRepository {
+
+    List<BibEntry> getRelations(BibEntry entry);
+
+    /**
+     * Adds the given relations to the entry. Appends to existing relations.
+     */
+    void addRelations(BibEntry entry, List<BibEntry> relations);
+
+    boolean containsKey(BibEntry entry);
+
+    default boolean shouldUpdate(BibEntry entry) {
+        return true;
+    }
+
+    void close();
+}
diff --git a/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntrySerializer.java b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntrySerializer.java
new file mode 100644
index 00000000000..91230d6e9fe
--- /dev/null
+++ b/jablib/src/main/java/org/jabref/logic/citation/repository/BibEntrySerializer.java
@@ -0,0 +1,102 @@
+package org.jabref.logic.citation.repository;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import org.jabref.logic.bibtex.BibEntryWriter;
+import org.jabref.logic.bibtex.FieldPreferences;
+import org.jabref.logic.bibtex.FieldWriter;
+import org.jabref.logic.bibtex.comparator.BibEntryCompare;
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.logic.importer.ParseException;
+import org.jabref.logic.importer.fileformat.BibtexParser;
+import org.jabref.model.database.BibDatabaseMode;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibEntryTypesManager;
+
+import org.h2.mvstore.WriteBuffer;
+import org.h2.mvstore.type.BasicDataType;
+import org.jspecify.annotations.NonNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class BibEntrySerializer extends BasicDataType<BibEntry> {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(BibEntrySerializer.class);
+
+    private final BibEntryTypesManager entryTypesManager;
+    private final ImportFormatPreferences importFormatPreferences;
+    private final FieldPreferences fieldPreferences;
+
+    public BibEntrySerializer(BibEntryTypesManager entryTypesManager, ImportFormatPreferences importFormatPreferences, FieldPreferences fieldPreferences) {
+        this.entryTypesManager = entryTypesManager;
+        this.importFormatPreferences = importFormatPreferences;
+        this.fieldPreferences = fieldPreferences;
+    }
+
+    private String toString(BibEntry entry) {
+        // BibEntry is not Java serializable. Thus, we need to do the serialization manually
+        // At reading of the clipboard in JabRef, we parse the plain string in all cases, so we don't need to flag we put BibEntries here
+        // Furthermore, storing a string also enables other applications to work wih the data
+        BibEntryWriter writer = new BibEntryWriter(new FieldWriter(fieldPreferences), entryTypesManager);
+        try {
+            return writer.serializeAll(List.of(entry), BibDatabaseMode.BIBTEX);
+        } catch (IOException e) {
+            LOGGER.error("Could not write entry", e);
+            return entry.toString();
+        }
+    }
+
+    private Optional<BibEntry> fromString(String serializedString) {
+        try {
+            return BibtexParser.singleFromString(serializedString, importFormatPreferences);
+        } catch (ParseException e) {
+            LOGGER.error("An error occurred while parsing from relation MV store.", e);
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public int getMemory(BibEntry obj) {
+        return toString(obj).getBytes(StandardCharsets.UTF_8).length;
+    }
+
+    @Override
+    public void write(WriteBuffer buff, BibEntry bibEntry) {
+        byte[] asBytes = toString(bibEntry).getBytes(StandardCharsets.UTF_8);
+        buff.putInt(asBytes.length);
+        buff.put(asBytes);
+    }
+
+    @Override
+    public BibEntry read(ByteBuffer buff) {
+        int serializedEntrySize = buff.getInt();
+        byte[] serializedEntry = new byte[serializedEntrySize];
+        buff.get(serializedEntry);
+        return fromString(new String(serializedEntry, StandardCharsets.UTF_8)).orElse(new BibEntry());
+    }
+
+    @Override
+    public int compare(@NonNull BibEntry a, @NonNull BibEntry b) {
+        return switch (BibEntryCompare.compareEntries(a, b)) {
+            case SUBSET -> -1;
+            case SUPERSET -> 1;
+            case EQUAL -> 0;
+            default -> Objects.compare(a.hashCode(), b.hashCode(), Integer::compare);
+        };
+    }
+
+    @Override
+    public BibEntry[] createStorage(int size) {
+        return new BibEntry[size];
+    }
+
+    @Override
+    public boolean isMemoryEstimationAllowed() {
+        return false;
+    }
+}
diff --git a/jablib/src/main/java/org/jabref/logic/citation/repository/MVStoreBibEntryRelationRepository.java b/jablib/src/main/java/org/jabref/logic/citation/repository/MVStoreBibEntryRelationRepository.java
new file mode 100644
index 00000000000..f3c6fe55e85
--- /dev/null
+++ b/jablib/src/main/java/org/jabref/logic/citation/repository/MVStoreBibEntryRelationRepository.java
@@ -0,0 +1,144 @@
+package org.jabref.logic.citation.repository;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Clock;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+import org.jabref.logic.bibtex.FieldPreferences;
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibEntryTypesManager;
+
+import com.google.common.annotations.VisibleForTesting;
+import org.h2.mvstore.MVMap;
+import org.h2.mvstore.MVStore;
+import org.h2.mvstore.type.BasicDataType;
+import org.jspecify.annotations.NonNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class is responsible for storing and retrieving relations between BibEntry objects.
+ * It uses an MVStore to store the relations.
+ */
+public class MVStoreBibEntryRelationRepository implements BibEntryRelationRepository {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(MVStoreBibEntryRelationRepository.class);
+
+    private final static ZoneId TIME_STAMP_ZONE_ID = ZoneId.of("UTC");
+    private final static Clock CLOCK = Clock.system(TIME_STAMP_ZONE_ID);
+    private final static String MAP_SUFFIX_TIME_STAMP = "-insertion-timestamp";
+
+    private final int storeTTLInDays;
+    private final MVMap<String, LinkedHashSet<BibEntry>> relationsMap;
+    private final MVMap<String, LocalDateTime> insertionTimeStampMap;
+
+    // should only be read for closing - all other maps initialized at constructor
+    private final MVStore store;
+
+    @VisibleForTesting
+    MVStoreBibEntryRelationRepository(Path path,
+                                      String mapName,
+                                      int storeTTLInDays,
+                                      BibEntryTypesManager entryTypesManager,
+                                      ImportFormatPreferences importFormatPreferences,
+                                      FieldPreferences fieldPreferences) {
+        this(
+                path,
+                mapName,
+                storeTTLInDays,
+                new BibEntryHashSetSerializer(entryTypesManager, importFormatPreferences, fieldPreferences)
+        );
+    }
+
+    @VisibleForTesting
+    MVStoreBibEntryRelationRepository(Path path,
+                                      String mapName,
+                                      int storeTTLInDays,
+                                      BasicDataType<LinkedHashSet<BibEntry>> serializer) {
+        try {
+            Files.createDirectories(path.getParent());
+            if (!Files.exists(path)) {
+                Files.createFile(path);
+            }
+        } catch (IOException e) {
+            LOGGER.error("An error occurred while opening {} storage", mapName, e);
+        }
+
+        this.storeTTLInDays = storeTTLInDays;
+
+        MVMap.Builder<String, LinkedHashSet<BibEntry>> mapConfiguration = new MVMap.Builder<String, LinkedHashSet<BibEntry>>().valueType(serializer);
+        // We can rely on the auto commit features, because we have only one store reader
+        store = new MVStore.Builder()
+                .fileName(path.toAbsolutePath().toString())
+                .open();
+        this.relationsMap = store.openMap(mapName, mapConfiguration);
+        this.insertionTimeStampMap = store.openMap(mapName + MAP_SUFFIX_TIME_STAMP);
+    }
+
+    @Override
+    public List<BibEntry> getRelations(BibEntry entry) {
+        return entry
+                .getDOI()
+                .map(doi -> relationsMap.getOrDefault(doi.asString(), new LinkedHashSet<>()).stream().toList())
+                .orElse(List.of());
+    }
+
+    /**
+     * Allows insertion of empty list in order to keep track of insertion date for an entry.
+     */
+    @Override
+    synchronized public void addRelations(@NonNull BibEntry entry, @NonNull List<BibEntry> relations) {
+        entry.getDOI().ifPresent(doi -> {
+            if (!relations.isEmpty()) {
+                // Save the relations
+                LinkedHashSet<BibEntry> relationsAlreadyStored = relationsMap.getOrDefault(doi.asString(), new LinkedHashSet<>());
+                relationsAlreadyStored.addAll(relations);
+                relationsMap.put(doi.asString(), relationsAlreadyStored);
+            }
+
+            // Save insertion timestamp
+            LocalDateTime insertionTime = LocalDateTime.now(TIME_STAMP_ZONE_ID);
+            insertionTimeStampMap.put(doi.asString(), insertionTime);
+        });
+    }
+
+    @Override
+    synchronized public boolean containsKey(BibEntry entry) {
+        return entry
+                .getDOI()
+                .map(doi -> relationsMap.containsKey(doi.asString()))
+                .orElse(false);
+    }
+
+    @Override
+    synchronized public boolean shouldUpdate(BibEntry entry) {
+        return shouldUpdate(entry, CLOCK);
+    }
+
+    @VisibleForTesting
+    boolean shouldUpdate(final BibEntry entry, final Clock clock) {
+        LocalDateTime now = LocalDateTime.now(clock);
+        return entry.getDOI()
+                    .map(doi -> {
+                        String doiString = doi.asString();
+                        if (!insertionTimeStampMap.containsKey(doiString)) {
+                            return true;
+                        }
+                        LocalDateTime lastRun = insertionTimeStampMap.get(doiString);
+                        return lastRun.isBefore(now.minusDays(storeTTLInDays));
+                    })
+                    // No DOI existing - allow update
+                    .orElse(true);
+    }
+
+    @Override
+    public void close() {
+        this.store.close();
+    }
+}
diff --git a/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java b/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java
index 9f7a7923d6a..709b02b9005 100644
--- a/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java
+++ b/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java
@@ -7,8 +7,10 @@
 import java.util.Set;
 
 import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.IntegerProperty;
 import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleIntegerProperty;
 import javafx.beans.property.SimpleObjectProperty;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
@@ -29,6 +31,7 @@ public class ImporterPreferences {
     private final BooleanProperty persistCustomKeys;
     private final ObservableList<String> catalogs;
     private final ObjectProperty<PlainCitationParserChoice> defaultPlainCitationParser;
+    private final IntegerProperty citationsRelationsStoreTTL;
 
     public ImporterPreferences(boolean importerEnabled,
                                boolean generateNewKeyOnImport,
@@ -39,7 +42,8 @@ public ImporterPreferences(boolean importerEnabled,
                                Map<String, String> defaultApiKeys,
                                boolean persistCustomKeys,
                                List<String> catalogs,
-                               PlainCitationParserChoice defaultPlainCitationParser
+                               PlainCitationParserChoice defaultPlainCitationParser,
+                               int citationsRelationsStoreTTL
     ) {
         this.importerEnabled = new SimpleBooleanProperty(importerEnabled);
         this.generateNewKeyOnImport = new SimpleBooleanProperty(generateNewKeyOnImport);
@@ -51,6 +55,7 @@ public ImporterPreferences(boolean importerEnabled,
         this.persistCustomKeys = new SimpleBooleanProperty(persistCustomKeys);
         this.catalogs = FXCollections.observableArrayList(catalogs);
         this.defaultPlainCitationParser = new SimpleObjectProperty<>(defaultPlainCitationParser);
+        this.citationsRelationsStoreTTL = new SimpleIntegerProperty(citationsRelationsStoreTTL);
     }
 
     public boolean areImporterEnabled() {
@@ -159,4 +164,16 @@ public ObjectProperty<PlainCitationParserChoice> defaultPlainCitationParserPrope
     public void setDefaultPlainCitationParser(PlainCitationParserChoice defaultPlainCitationParser) {
         this.defaultPlainCitationParser.set(defaultPlainCitationParser);
     }
+
+    public int getCitationsRelationsStoreTTL() {
+        return this.citationsRelationsStoreTTL.get();
+    }
+
+    public IntegerProperty citationsRelationsStoreTTLProperty() {
+        return this.citationsRelationsStoreTTL;
+    }
+
+    public void setCitationsRelationsStoreTTL(int citationsRelationsStoreTTL) {
+        this.citationsRelationsStoreTTL.set(citationsRelationsStoreTTL);
+    }
 }
diff --git a/jablib/src/main/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarFetcher.java b/jablib/src/main/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarCitationFetcher.java
similarity index 82%
rename from jablib/src/main/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarFetcher.java
rename to jablib/src/main/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarCitationFetcher.java
index 4a2e1297d9a..646ae02952c 100644
--- a/jablib/src/main/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarFetcher.java
+++ b/jablib/src/main/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarCitationFetcher.java
@@ -13,15 +13,17 @@
 import org.jabref.model.entry.BibEntry;
 
 import com.google.gson.Gson;
+import org.jspecify.annotations.NonNull;
 
-public class SemanticScholarFetcher implements CitationFetcher, CustomizableKeyFetcher {
+public class SemanticScholarCitationFetcher implements CitationFetcher, CustomizableKeyFetcher {
     public static final String FETCHER_NAME = "Semantic Scholar Citations Fetcher";
-
     private static final String SEMANTIC_SCHOLAR_API = "https://api.semanticscholar.org/graph/v1/";
 
+    private static final Gson GSON = new Gson();
+
     private final ImporterPreferences importerPreferences;
 
-    public SemanticScholarFetcher(ImporterPreferences importerPreferences) {
+    public SemanticScholarCitationFetcher(ImporterPreferences importerPreferences) {
         this.importerPreferences = importerPreferences;
     }
 
@@ -47,7 +49,7 @@ public List<BibEntry> searchCitedBy(BibEntry entry) throws FetcherException {
 
         importerPreferences.getApiKey(getName()).ifPresent(apiKey -> urlDownload.addHeader("x-api-key", apiKey));
 
-        CitationsResponse citationsResponse = new Gson()
+        CitationsResponse citationsResponse = GSON
                 .fromJson(urlDownload.asString(), CitationsResponse.class);
 
         return citationsResponse.getData()
@@ -56,7 +58,7 @@ public List<BibEntry> searchCitedBy(BibEntry entry) throws FetcherException {
     }
 
     @Override
-    public List<BibEntry> searchCiting(BibEntry entry) throws FetcherException {
+    public @NonNull List<BibEntry> searchCiting(@NonNull BibEntry entry) throws FetcherException {
         if (entry.getDOI().isEmpty()) {
             return List.of();
         }
@@ -70,8 +72,11 @@ public List<BibEntry> searchCiting(BibEntry entry) throws FetcherException {
 
         URLDownload urlDownload = new URLDownload(referencesUrl);
         importerPreferences.getApiKey(getName()).ifPresent(apiKey -> urlDownload.addHeader("x-api-key", apiKey));
-        ReferencesResponse referencesResponse = new Gson()
-                .fromJson(urlDownload.asString(), ReferencesResponse.class);
+        ReferencesResponse referencesResponse = GSON.fromJson(urlDownload.asString(), ReferencesResponse.class);
+
+        if (referencesResponse.getData() == null) {
+            return List.of();
+        }
 
         return referencesResponse.getData()
                                  .stream()
diff --git a/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java b/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
index 64a4bb345a3..bd35b70f208 100644
--- a/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
+++ b/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
@@ -60,7 +60,7 @@
 import org.jabref.logic.importer.fetcher.MrDlibPreferences;
 import org.jabref.logic.importer.fetcher.ScienceDirect;
 import org.jabref.logic.importer.fetcher.SpringerFetcher;
-import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarFetcher;
+import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarCitationFetcher;
 import org.jabref.logic.importer.fileformat.CustomImporter;
 import org.jabref.logic.importer.plaincitation.PlainCitationParserChoice;
 import org.jabref.logic.importer.util.GrobidPreferences;
@@ -220,6 +220,7 @@ public class JabRefCliPreferences implements CliPreferences {
     public static final String SEARCH_WINDOW_DIVIDER_POS = "searchWindowDividerPos";
     public static final String SEARCH_CATALOGS = "searchCatalogs";
     public static final String DEFAULT_PLAIN_CITATION_PARSER = "defaultPlainCitationParser";
+    public static final String CITATIONS_RELATIONS_STORE_TTL = "citationsRelationsStoreTTL";
     public static final String IMPORTERS_ENABLED = "importersEnabled";
     public static final String GENERATE_KEY_ON_IMPORT = "generateKeyOnImport";
     public static final String GROBID_ENABLED = "grobidEnabled";
@@ -473,6 +474,7 @@ protected JabRefCliPreferences() {
         defaults.put(DEFAULT_PLAIN_CITATION_PARSER, PlainCitationParserChoice.RULE_BASED.name());
         defaults.put(IMPORTERS_ENABLED, Boolean.TRUE);
         defaults.put(GENERATE_KEY_ON_IMPORT, Boolean.TRUE);
+        defaults.put(CITATIONS_RELATIONS_STORE_TTL, 30);
 
         defaults.put(ADD_IMPORTED_ENTRIES, Boolean.FALSE);
         defaults.put(ADD_IMPORTED_ENTRIES_GROUP_NAME, Localization.lang("Imported entries"));
@@ -2043,7 +2045,8 @@ public ImporterPreferences getImporterPreferences() {
                 getDefaultFetcherKeys(),
                 getBoolean(FETCHER_CUSTOM_KEY_PERSIST),
                 getStringList(SEARCH_CATALOGS),
-                PlainCitationParserChoice.valueOf(get(DEFAULT_PLAIN_CITATION_PARSER))
+                PlainCitationParserChoice.valueOf(get(DEFAULT_PLAIN_CITATION_PARSER)),
+                getInt(CITATIONS_RELATIONS_STORE_TTL)
         );
 
         EasyBind.listen(importerPreferences.importerEnabledProperty(), (_, _, newValue) -> putBoolean(IMPORTERS_ENABLED, newValue));
@@ -2055,6 +2058,7 @@ public ImporterPreferences getImporterPreferences() {
         importerPreferences.getCustomImporters().addListener((InvalidationListener) _ -> storeCustomImportFormats(importerPreferences.getCustomImporters()));
         importerPreferences.getCatalogs().addListener((InvalidationListener) _ -> putStringList(SEARCH_CATALOGS, importerPreferences.getCatalogs()));
         EasyBind.listen(importerPreferences.defaultPlainCitationParserProperty(), (_, _, newValue) -> put(DEFAULT_PLAIN_CITATION_PARSER, newValue.name()));
+        EasyBind.listen(importerPreferences.citationsRelationsStoreTTLProperty(), (_, _, newValue) -> put(CITATIONS_RELATIONS_STORE_TTL, newValue.toString()));
 
         return importerPreferences;
     }
@@ -2138,7 +2142,7 @@ private Map<String, String> getDefaultFetcherKeys() {
         }
 
         Map<String, String> keys = new HashMap<>();
-        keys.put(SemanticScholarFetcher.FETCHER_NAME, buildInfo.semanticScholarApiKey);
+        keys.put(SemanticScholarCitationFetcher.FETCHER_NAME, buildInfo.semanticScholarApiKey);
         keys.put(AstrophysicsDataSystem.FETCHER_NAME, buildInfo.astrophysicsDataSystemAPIKey);
         keys.put(BiodiversityLibrary.FETCHER_NAME, buildInfo.biodiversityHeritageApiKey);
         keys.put(ScienceDirect.FETCHER_NAME, buildInfo.scienceDirectApiKey);
diff --git a/jablib/src/main/java/org/jabref/logic/util/BackgroundTask.java b/jablib/src/main/java/org/jabref/logic/util/BackgroundTask.java
index 1f2c91b4976..0a576c74659 100644
--- a/jablib/src/main/java/org/jabref/logic/util/BackgroundTask.java
+++ b/jablib/src/main/java/org/jabref/logic/util/BackgroundTask.java
@@ -16,6 +16,7 @@
 import javafx.beans.property.StringProperty;
 
 import com.tobiasdiez.easybind.EasyBind;
+import org.jspecify.annotations.NonNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -166,6 +167,13 @@ public BackgroundTask<V> onRunning(Runnable onRunning) {
         return this;
     }
 
+    /**
+     * Carry a consumer to a running runnable and invoke it after the task is started.
+     */
+    public @NonNull BackgroundTask<V> consumeOnRunning(@NonNull Consumer<BackgroundTask<V>> onRunningConsumer) {
+        return this.onRunning(() -> onRunningConsumer.accept(this));
+    }
+
     /**
      * Sets the {@link Consumer} that is invoked after the task is successfully finished.
      * The consumer always runs on the JavaFX thread.
diff --git a/jablib/src/main/java/org/jabref/logic/util/Directories.java b/jablib/src/main/java/org/jabref/logic/util/Directories.java
index 3e55d1e233b..6f6816d5656 100644
--- a/jablib/src/main/java/org/jabref/logic/util/Directories.java
+++ b/jablib/src/main/java/org/jabref/logic/util/Directories.java
@@ -59,4 +59,13 @@ public static Path getSslDirectory() {
                                              "ssl",
                                              OS.APP_DIR_APP_AUTHOR));
     }
+
+    public static Path getCitationsRelationsDirectory() {
+        return Path.of(
+                AppDirsFactory.getInstance()
+                              .getUserDataDir(
+                                      OS.APP_DIR_APP_NAME,
+                                      "relations",
+                                      OS.APP_DIR_APP_AUTHOR));
+    }
 }
diff --git a/jablib/src/main/java/org/jabref/model/entry/BibEntry.java b/jablib/src/main/java/org/jabref/model/entry/BibEntry.java
index 6f6fbc3012a..221747e5565 100644
--- a/jablib/src/main/java/org/jabref/model/entry/BibEntry.java
+++ b/jablib/src/main/java/org/jabref/model/entry/BibEntry.java
@@ -706,14 +706,20 @@ public Object clone() {
         return clone;
     }
 
-    /// This returns a canonical BibTeX serialization. Special characters such as "{" or "&" are NOT escaped, but written
-    /// as is. In case the JabRef "hack" for distinguishing "field = value" and "field = {value}" (in .bib files) is
-    /// used, it is output as "field = {#value#}", which may cause headaches in debugging. We nevertheless do it this way
-    /// to a) enable debugging the internal representation and b) save time at this method.
-    ///
     /// Serializes all fields, even the JabRef internal ones. Does NOT serialize "KEY_FIELD" as field, but as key.
     ///
+    /// We do it this way to
+    ///   a) enable debugging the internal representation and
+    ///   b) save time at this method.
+    ///
+    ///
+    /// This returns canonical BibTeX serialization. Special characters such as "{" or "&" are NOT escaped, but written
+    /// as is. In case the JabRef "hack" for distinguishing "field = value" and "field = {value}" (in .bib files) is
+    /// used, it is output as "field = {#value#}", which may cause headaches in debugging.
+    ///
     /// Alternative for some more readable output: [#getAuthorTitleYear(int)]
+    ///
+    /// @return A user-readable string NOT A VALID BibTeX string
     @Override
     public String toString() {
         return CanonicalBibEntry.getCanonicalRepresentation(this);
diff --git a/jablib/src/main/resources/l10n/JabRef_de.properties b/jablib/src/main/resources/l10n/JabRef_de.properties
index 7419005cc30..36e6de7a920 100644
--- a/jablib/src/main/resources/l10n/JabRef_de.properties
+++ b/jablib/src/main/resources/l10n/JabRef_de.properties
@@ -2795,6 +2795,7 @@ No\ entry\ was\ copied\ to\ %0=Kein Eintrag wurde nach %0 kopiert
 
 Ask\ whether\ to\ include\ cross-references\ when\ copying\ to\ another\ library=Fragen Sie, ob Querverweise beim Kopieren in eine andere Bibliothek einbezogen werden sollen
 
+Citations\ relations\ local\ storage\ time-to-live\ (in\ days)=Speicherdauer für lokale Zitationsbeziehungen (in Tagen)
 
 
 
diff --git a/jablib/src/main/resources/l10n/JabRef_en.properties b/jablib/src/main/resources/l10n/JabRef_en.properties
index 1c8fa89a7db..433be54d054 100644
--- a/jablib/src/main/resources/l10n/JabRef_en.properties
+++ b/jablib/src/main/resources/l10n/JabRef_en.properties
@@ -2887,6 +2887,8 @@ Show\ preview\ in\ entry\ table\ tooltip=Show preview in entry table tooltip
 Citation\ information=Citation information
 Total\ Citations\:\ %0\nSupporting\:\ %1\nContradicting\:\ %2\nMentioning\:\ %3\nUnclassified\:\ %4\nCiting\ Publications\:\ %5=Total Citations: %0\nSupporting: %1\nContradicting: %2\nMentioning: %3\nUnclassified: %4\nCiting Publications: %5
 
+Citations\ relations\ local\ storage\ time-to-live\ (in\ days)=Citations relations local storage time-to-live (in days)
+
 # NewEntry*
 Add\ entry=Add entry
 An\ unknown\ error\ has\ occurred.\nEntries\ may\ need\ to\ be\ added\ manually.=An unknown error has occurred.\nEntries may need to be added manually.
diff --git a/jablib/src/test/java/org/jabref/logic/citation/SearchCitationsRelationsServiceTest.java b/jablib/src/test/java/org/jabref/logic/citation/SearchCitationsRelationsServiceTest.java
new file mode 100644
index 00000000000..f2ee7bc476b
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/citation/SearchCitationsRelationsServiceTest.java
@@ -0,0 +1,220 @@
+package org.jabref.logic.citation;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.jabref.logic.citation.repository.BibEntryCitationsAndReferencesRepository;
+import org.jabref.logic.citation.repository.BibEntryRelationsRepositoryTestHelpers;
+import org.jabref.logic.importer.fetcher.citation.CitationFetcher;
+import org.jabref.logic.importer.fetcher.citation.CitationFetcherHelpersForTest;
+import org.jabref.model.entry.BibEntry;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SearchCitationsRelationsServiceTest {
+
+    /**
+     * Creates a mock CitationFetcher that returns specific results for citations and references
+     */
+    private CitationFetcher createMockFetcher(BibEntry targetEntry, List<BibEntry> citationsToReturn, List<BibEntry> referencesToReturn) {
+        return CitationFetcherHelpersForTest.Mocks.from(
+                entry -> {
+                    if (entry == targetEntry) {
+                        return citationsToReturn != null ? citationsToReturn : List.of();
+                    }
+                    return List.of();
+                },
+                entry -> {
+                    if (entry == targetEntry) {
+                        return referencesToReturn != null ? referencesToReturn : List.of();
+                    }
+                    return List.of();
+                }
+        );
+    }
+
+    /**
+     * Creates a mock CitationFetcher that returns empty lists for all entries
+     */
+    private CitationFetcher createEmptyMockFetcher() {
+        return CitationFetcherHelpersForTest.Mocks.from(
+                _ -> List.of(),
+                _ -> List.of()
+        );
+    }
+
+    @Nested
+    class CitationsTests {
+        @Test
+        void serviceShouldSearchForCitations() {
+            // GIVEN
+            BibEntry cited = new BibEntry();
+            List<BibEntry> citationsToReturn = List.of(new BibEntry());
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(
+                    _ -> citationsToReturn, null, null, null, _ -> false, _ -> false
+            );
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(null, repository);
+
+            // WHEN
+            List<BibEntry> citations = searchService.searchCitations(cited);
+
+            // THEN
+            assertEquals(citationsToReturn, citations);
+        }
+
+        @Test
+        void serviceShouldCallTheFetcherForCitationsWhenRepositoryIsUpdatable() {
+            // GiVEN
+            BibEntry cited = new BibEntry();
+            BibEntry newCitations = new BibEntry();
+            List<BibEntry> citationsToReturn = List.of(newCitations);
+            Map<BibEntry, List<BibEntry>> citationsDatabase = HashMap.newHashMap(300);
+            CitationFetcher fetcher = createMockFetcher(cited, citationsToReturn, null);
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(
+                    _ -> citationsToReturn,
+                    citationsDatabase::put,
+                    List::of,
+                    (_, _) -> { },
+                    _ -> true,
+                    _ -> false
+            );
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(fetcher, repository);
+
+            // WHEN
+            List<BibEntry> citations = searchService.searchCitations(cited);
+
+            // THEN
+            assertTrue(citationsDatabase.containsKey(cited));
+            assertEquals(citationsToReturn, citationsDatabase.get(cited));
+            assertEquals(citationsToReturn, citations);
+        }
+
+        @Test
+        void serviceShouldFetchCitationsIfRepositoryIsEmpty() {
+            BibEntry cited = new BibEntry();
+            BibEntry newCitations = new BibEntry();
+            List<BibEntry> citationsToReturn = List.of(newCitations);
+            Map<BibEntry, List<BibEntry>> citationsDatabase = HashMap.newHashMap(300);
+            CitationFetcher fetcher = createMockFetcher(cited, citationsToReturn, null);
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(citationsDatabase, null);
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(fetcher, repository);
+
+            // WHEN
+            List<BibEntry> citations = searchService.searchCitations(cited);
+
+            // THEN
+            assertTrue(citationsDatabase.containsKey(cited));
+            assertEquals(citationsToReturn, citationsDatabase.get(cited));
+            assertEquals(citationsToReturn, citations);
+        }
+
+        @Test
+        void insertingAnEmptyCitationsShouldBePossible() {
+            BibEntry cited = new BibEntry();
+            Map<BibEntry, List<BibEntry>> citationsDatabase = new HashMap<>();
+            CitationFetcher fetcher = createEmptyMockFetcher();
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(citationsDatabase, null);
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(fetcher, repository);
+
+            // WHEN
+            List<BibEntry> citations = searchService.searchCitations(cited);
+
+            // THEN
+            assertTrue(citations.isEmpty());
+            assertTrue(citationsDatabase.containsKey(cited));
+            assertTrue(citationsDatabase.get(cited).isEmpty());
+        }
+    }
+
+    @Nested
+    class ReferencesTests {
+        @Test
+        void serviceShouldSearchForReferences() {
+            // GIVEN
+            BibEntry referencer = new BibEntry();
+            List<BibEntry> referencesToReturn = List.of(new BibEntry());
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(
+                    null, null, _ -> referencesToReturn, null, _ -> false, _ -> false
+            );
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(null, repository);
+
+            // WHEN
+            List<BibEntry> references = searchService.searchReferences(referencer);
+
+            // THEN
+            assertEquals(referencesToReturn, references);
+        }
+
+        @Test
+        void serviceShouldCallTheFetcherForReferencesWhenRepositoryIsUpdatable() {
+            // GIVEN
+            BibEntry referencer = new BibEntry();
+            BibEntry newReference = new BibEntry();
+            List<BibEntry> referencesToReturn = List.of(newReference);
+            Map<BibEntry, List<BibEntry>> referencesDatabase = new HashMap<>();
+            CitationFetcher fetcher = createMockFetcher(referencer, null, referencesToReturn);
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(
+                    List::of,
+                    (_, _) -> { },
+                    _ -> referencesToReturn,
+                    referencesDatabase::put,
+                    _ -> false,
+                    _ -> true
+            );
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(fetcher, repository);
+
+            // WHEN
+            List<BibEntry> references = searchService.searchReferences(referencer);
+
+            // THEN
+            assertTrue(referencesDatabase.containsKey(referencer));
+            assertEquals(referencesToReturn, referencesDatabase.get(referencer));
+            assertEquals(referencesToReturn, references);
+        }
+
+        @Test
+        void serviceShouldFetchReferencesIfRepositoryIsEmpty() {
+            BibEntry reference = new BibEntry();
+            BibEntry newCitations = new BibEntry();
+            List<BibEntry> referencesToReturn = List.of(newCitations);
+            Map<BibEntry, List<BibEntry>> referencesDatabase = new HashMap<>();
+            CitationFetcher fetcher = createMockFetcher(reference, null, referencesToReturn);
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(
+                    null, referencesDatabase
+            );
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(fetcher, repository);
+
+            // WHEN
+            List<BibEntry> references = searchService.searchReferences(reference);
+
+            // THEN
+            assertTrue(referencesDatabase.containsKey(reference));
+            assertEquals(referencesToReturn, referencesDatabase.get(reference));
+            assertEquals(referencesToReturn, references);
+        }
+
+        @Test
+        void insertingAnEmptyReferencesShouldBePossible() {
+            BibEntry referencer = new BibEntry();
+            Map<BibEntry, List<BibEntry>> referenceDatabase = new HashMap<>();
+            CitationFetcher fetcher = createEmptyMockFetcher();
+            BibEntryCitationsAndReferencesRepository repository = BibEntryRelationsRepositoryTestHelpers.Mocks.from(
+                    null, referenceDatabase
+            );
+            SearchCitationsRelationsService searchService = new SearchCitationsRelationsService(fetcher, repository);
+
+            // WHEN
+            List<BibEntry> citations = searchService.searchReferences(referencer);
+
+            // THEN
+            assertTrue(citations.isEmpty());
+            assertTrue(referenceDatabase.containsKey(referencer));
+            assertTrue(referenceDatabase.get(referencer).isEmpty());
+        }
+    }
+}
diff --git a/jablib/src/test/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepositoryShellTest.java b/jablib/src/test/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepositoryShellTest.java
new file mode 100644
index 00000000000..a20ef003112
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/citation/repository/BibEntryCitationsAndReferencesRepositoryShellTest.java
@@ -0,0 +1,103 @@
+package org.jabref.logic.citation.repository;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.random.RandomGenerator;
+
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.StandardField;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class BibEntryCitationsAndReferencesRepositoryShellTest {
+
+    private static BibEntry createBibEntry() {
+        int i = RandomGenerator.getDefault().nextInt();
+        return new BibEntry()
+            .withCitationKey(String.valueOf(i))
+            .withField(StandardField.DOI, "10.1234/5678" + i);
+    }
+
+    private static List<BibEntry> createRelations(BibEntry entry) {
+        return entry
+            .getCitationKey()
+            .map(key -> RandomGenerator
+                .StreamableGenerator.of("L128X256MixRandom").ints(150)
+                .mapToObj(i -> new BibEntry()
+                    .withCitationKey("%s relation %s".formatted(key, i))
+                    .withField(StandardField.DOI, "10.2345/6789" + i)
+                )
+            )
+            .orElseThrow()
+            .toList();
+    }
+
+    private static class BibEntryRelationRepositoryMock implements BibEntryRelationRepository {
+
+        private final HashMap<BibEntry, List<BibEntry>> relations = new HashMap<>();
+
+        @Override
+        public List<BibEntry> getRelations(BibEntry entry) {
+            return new ArrayList<>(this.relations.get(entry));
+        }
+
+        @Override
+        public void addRelations(BibEntry entry, List<BibEntry> relations) {
+            this.relations.put(entry, relations);
+        }
+
+        @Override
+        public boolean containsKey(BibEntry entry) {
+            return this.relations.containsKey(entry);
+        }
+
+        @Override
+        public void close() {
+            // do nothing
+        }
+    }
+
+    @Test
+    void repositoryShouldWriteAndReadCitationsToAndFromExpectedDAO() {
+        // GIVEN
+        BibEntry bibEntry = createBibEntry();
+        List<BibEntry> citations = createRelations(bibEntry);
+        BibEntryRelationRepositoryMock citationsDAO = new BibEntryRelationRepositoryMock();
+        BibEntryCitationsAndReferencesRepositoryShell bibEntryRelationsRepository = new BibEntryCitationsAndReferencesRepositoryShell(
+            citationsDAO,
+            new BibEntryRelationRepositoryMock()
+        );
+        Assertions.assertFalse(bibEntryRelationsRepository.containsCitations(bibEntry));
+        Assertions.assertFalse(citations.isEmpty());
+
+        // WHEN
+        bibEntryRelationsRepository.insertCitations(bibEntry, citations);
+
+        // THEN
+        Assertions.assertTrue(bibEntryRelationsRepository.containsCitations(bibEntry));
+        Assertions.assertEquals(citations, bibEntryRelationsRepository.readCitations(bibEntry));
+    }
+
+    @Test
+    void repositoryShouldWriteAndReadReferencesToAndFromExpectedDAO() {
+        // GIVEN
+        BibEntry bibEntry = createBibEntry();
+        List<BibEntry> references = createRelations(bibEntry);
+        BibEntryRelationRepositoryMock referencesDAO = new BibEntryRelationRepositoryMock();
+        BibEntryCitationsAndReferencesRepositoryShell bibEntryRelationsRepository = new BibEntryCitationsAndReferencesRepositoryShell(
+                new BibEntryRelationRepositoryMock(),
+                referencesDAO
+        );
+        Assertions.assertFalse(bibEntryRelationsRepository.containsCitations(bibEntry));
+        Assertions.assertFalse(references.isEmpty());
+
+        // WHEN
+        bibEntryRelationsRepository.insertCitations(bibEntry, references);
+
+        // THEN
+        Assertions.assertTrue(bibEntryRelationsRepository.containsCitations(bibEntry));
+        Assertions.assertEquals(references, bibEntryRelationsRepository.readCitations(bibEntry));
+    }
+}
diff --git a/jablib/src/test/java/org/jabref/logic/citation/repository/BibEntryRelationsRepositoryTestHelpers.java b/jablib/src/test/java/org/jabref/logic/citation/repository/BibEntryRelationsRepositoryTestHelpers.java
new file mode 100644
index 00000000000..3be2ce09010
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/citation/repository/BibEntryRelationsRepositoryTestHelpers.java
@@ -0,0 +1,129 @@
+package org.jabref.logic.citation.repository;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import org.jabref.model.entry.BibEntry;
+
+/**
+ * Provide helpers methods and classes for tests to manage {@link BibEntryCitationsAndReferencesRepository} mocks.
+ */
+public class BibEntryRelationsRepositoryTestHelpers {
+
+    /**
+     * Provide mocks factories for {@link BibEntryCitationsAndReferencesRepository} mocks.
+     * <br>
+     * Those implementations should help to test the values passed to an injected repository instance
+     * when it is called from {@link org.jabref.logic.citation.SearchCitationsRelationsService}.
+     */
+    public static class Mocks {
+        public static BibEntryCitationsAndReferencesRepository from(
+            Function<BibEntry, List<BibEntry>> retrieveCitations,
+            BiConsumer<BibEntry, List<BibEntry>> insertCitations,
+            Function<BibEntry, List<BibEntry>> retrieveReferences,
+            BiConsumer<BibEntry, List<BibEntry>> insertReferences,
+            Function<BibEntry, Boolean> isCitationsUpdatable,
+            Function<BibEntry, Boolean> isReferencesUpdatable
+        ) {
+            return new BibEntryCitationsAndReferencesRepository() {
+                @Override
+                public void insertCitations(BibEntry entry, List<BibEntry> citations) {
+                    insertCitations.accept(entry, citations);
+                }
+
+                @Override
+                public List<BibEntry> readCitations(BibEntry entry) {
+                    return retrieveCitations.apply(entry);
+                }
+
+                @Override
+                public boolean containsCitations(BibEntry entry) {
+                    return true;
+                }
+
+                @Override
+                public boolean isCitationsUpdatable(BibEntry entry) {
+                    return isCitationsUpdatable.apply(entry);
+                }
+
+                @Override
+                public void insertReferences(BibEntry entry, List<BibEntry> citations) {
+                    insertReferences.accept(entry, citations);
+                }
+
+                @Override
+                public List<BibEntry> readReferences(BibEntry entry) {
+                    return retrieveReferences.apply(entry);
+                }
+
+                @Override
+                public boolean containsReferences(BibEntry entry) {
+                    return true;
+                }
+
+                @Override
+                public boolean isReferencesUpdatable(BibEntry entry) {
+                    return isReferencesUpdatable.apply(entry);
+                }
+
+                @Override
+                public void close() {
+                    // Nothing to do
+                }
+            };
+        }
+
+        public static BibEntryCitationsAndReferencesRepository from(
+            Map<BibEntry, List<BibEntry>> citationsDB, Map<BibEntry, List<BibEntry>> referencesDB
+        ) {
+            return new BibEntryCitationsAndReferencesRepository() {
+                @Override
+                public void insertCitations(BibEntry entry, List<BibEntry> citations) {
+                    citationsDB.put(entry, citations);
+                }
+
+                @Override
+                public List<BibEntry> readCitations(BibEntry entry) {
+                    return citationsDB.getOrDefault(entry, List.of());
+                }
+
+                @Override
+                public boolean containsCitations(BibEntry entry) {
+                    return citationsDB.containsKey(entry);
+                }
+
+                @Override
+                public boolean isCitationsUpdatable(BibEntry entry) {
+                    return true;
+                }
+
+                @Override
+                public void insertReferences(BibEntry entry, List<BibEntry> citations) {
+                    referencesDB.put(entry, citations);
+                }
+
+                @Override
+                public List<BibEntry> readReferences(BibEntry entry) {
+                    return referencesDB.getOrDefault(entry, List.of());
+                }
+
+                @Override
+                public boolean containsReferences(BibEntry entry) {
+                    return referencesDB.containsKey(entry);
+                }
+
+                @Override
+                public boolean isReferencesUpdatable(BibEntry entry) {
+                    return true;
+                }
+
+                @Override
+                public void close() {
+                    // Nothing to do
+                }
+            };
+        }
+    }
+}
diff --git a/jablib/src/test/java/org/jabref/logic/citation/repository/MVStoreBibEntryRelationRepositoryTest.java b/jablib/src/test/java/org/jabref/logic/citation/repository/MVStoreBibEntryRelationRepositoryTest.java
new file mode 100644
index 00000000000..d7f057b97d9
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/citation/repository/MVStoreBibEntryRelationRepositoryTest.java
@@ -0,0 +1,244 @@
+package org.jabref.logic.citation.repository;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Clock;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.List;
+import java.util.random.RandomGenerator;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import org.jabref.logic.bibtex.FieldPreferences;
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.logic.importer.fetcher.citation.semanticscholar.PaperDetails;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibEntryTypesManager;
+import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.identifier.DOI;
+import org.jabref.model.entry.types.StandardEntryType;
+import org.jabref.support.DisabledOnCIServer;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.Answers;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+@DisabledOnCIServer("Strange out of memory exceptions, works with manual testing")
+class MVStoreBibEntryRelationRepositoryTest {
+
+    private final static String MV_STORE_NAME = "test-relations.mv";
+    private final static String MAP_NAME = "test-relations";
+
+    @TempDir
+    Path temporaryFolder;
+
+    private MVStoreBibEntryRelationRepository dao;
+
+    @BeforeEach
+    void initStore() throws Exception {
+        Path file = Files.createFile(temporaryFolder.resolve(MV_STORE_NAME));
+
+        this.dao = new MVStoreBibEntryRelationRepository(
+                file.toAbsolutePath(),
+                MAP_NAME,
+                7,
+                new BibEntryTypesManager(),
+                mock(ImportFormatPreferences.class, Answers.RETURNS_DEEP_STUBS),
+                mock(FieldPreferences.class, Answers.RETURNS_DEEP_STUBS));
+    }
+
+    @AfterEach
+    void closeStore() {
+        this.dao.close();
+        // On the CI, we sometimes get "OutOfMemoryException"s. This tries to prevent that.
+        System.gc();
+    }
+
+    private static Stream<BibEntry> createBibEntries() {
+        return IntStream
+            .range(0, 150)
+            .mapToObj(MVStoreBibEntryRelationRepositoryTest::createBibEntry);
+    }
+
+    private static BibEntry createBibEntry(int i) {
+        return new BibEntry()
+            .withCitationKey(String.valueOf(i))
+            .withField(StandardField.DOI, "10.1234/5678" + i);
+    }
+
+    /**
+     * Create a fake list of relations for a bibEntry based on the {@link PaperDetails#toBibEntry()} logic
+     * that corresponds to this use case: we want to make sure that relations coming from SemanticScholar
+     * and mapped as BibEntry will be serializable by the MVStore.
+     *
+     * @param entry should not be null
+     * @return never empty
+     */
+    private List<BibEntry> createRelations(BibEntry entry) {
+        return entry
+            .getCitationKey()
+            .map(key -> RandomGenerator.StreamableGenerator
+                .of("L128X256MixRandom").ints(150)
+                .mapToObj(i -> new BibEntry(StandardEntryType.Book)
+                    .withField(StandardField.TITLE, "A title: " + i)
+                    .withField(StandardField.YEAR, String.valueOf(2024))
+                    .withField(StandardField.AUTHOR, "{A list of authors: " + i + "}")
+                    .withField(StandardField.DOI, entry.getDOI().map(DOI::asString).orElse("") + ":" + i)
+                    .withField(StandardField.ABSTRACT, "The Universe is expanding: " + i)
+                )
+            )
+            .orElseThrow()
+            .toList();
+    }
+
+    @ParameterizedTest
+    @MethodSource("createBibEntries")
+    void DAOShouldMergeRelationsWhenInserting(BibEntry bibEntry) {
+        // GIVEN
+        assertFalse(dao.containsKey(bibEntry));
+        List<BibEntry> firstRelations = createRelations(bibEntry);
+        List<BibEntry> secondRelations = createRelations(bibEntry);
+
+        // WHEN
+        dao.addRelations(bibEntry, firstRelations);
+        dao.addRelations(bibEntry, secondRelations);
+        List<BibEntry> relationFromCache = dao
+                .getRelations(bibEntry)
+                .stream()
+                .toList();
+
+        // THEN
+        List<BibEntry> uniqueRelations = Stream
+            .concat(firstRelations.stream(), secondRelations.stream())
+            .distinct()
+            .toList();
+        assertFalse(uniqueRelations.isEmpty());
+        assertNotSame(uniqueRelations, relationFromCache);
+        assertEquals(uniqueRelations, relationFromCache);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createBibEntries")
+    void containsKeyShouldReturnFalseIfNothingWasInserted(BibEntry entry) {
+        assertFalse(dao.containsKey(entry));
+    }
+
+    @ParameterizedTest
+    @MethodSource("createBibEntries")
+    void containsKeyShouldReturnTrueIfRelationsWereInserted(BibEntry entry) {
+        // GIVEN
+        List<BibEntry> relations = createRelations(entry);
+
+        // WHEN
+        dao.addRelations(entry, relations);
+
+        // THEN
+        assertTrue(dao.containsKey(entry));
+    }
+
+    @ParameterizedTest
+    @MethodSource("createBibEntries")
+    void shouldUpdateShouldReturnTrueBeforeInsertionsAndFalseAfterInsertions(BibEntry entry) {
+        // GIVEN
+        List<BibEntry> relations = createRelations(entry);
+        assertTrue(dao.shouldUpdate(entry));
+
+        // WHEN
+        dao.addRelations(entry, relations);
+
+        // THEN
+        assertFalse(dao.shouldUpdate(entry));
+    }
+
+    @ParameterizedTest
+    @MethodSource("createBibEntries")
+    void shouldUpdateShouldReturnTrueAfterOneWeek(BibEntry entry) {
+        // GIVEN
+        List<BibEntry> relations = createRelations(entry);
+        Clock clock = Clock.fixed(Instant.now(), ZoneId.of("UTC"));
+        assertTrue(dao.shouldUpdate(entry, clock));
+
+        // WHEN
+        dao.addRelations(entry, relations);
+
+        // THEN
+        assertFalse(dao.shouldUpdate(entry, clock));
+        Clock clockOneWeekAfter = Clock.fixed(
+            LocalDateTime.now(ZoneId.of("UTC")).plusWeeks(1).plusSeconds(1).toInstant(ZoneOffset.UTC),
+            ZoneId.of("UTC")
+        );
+        assertTrue(dao.shouldUpdate(entry, clockOneWeekAfter));
+    }
+
+    @ParameterizedTest
+    @MethodSource("createBibEntries")
+    void shouldUpdateShouldReturnFalseAfterOneWeekWhenTTLisSetTo30(BibEntry entry) throws IOException {
+        // GIVEN
+        List<BibEntry> relations = createRelations(entry);
+        Clock clock = Clock.fixed(Instant.now(), ZoneId.of("UTC"));
+        Path file = Files.createFile(temporaryFolder.resolve("update_test" + MV_STORE_NAME));
+        MVStoreBibEntryRelationRepository daoUnderTest = new MVStoreBibEntryRelationRepository(
+                file.toAbsolutePath(),
+                MAP_NAME,
+                30,
+                mock(BibEntryTypesManager.class, Answers.RETURNS_DEEP_STUBS),
+                mock(ImportFormatPreferences.class, Answers.RETURNS_DEEP_STUBS),
+                mock(FieldPreferences.class, Answers.RETURNS_DEEP_STUBS));
+        assertTrue(daoUnderTest.shouldUpdate(entry, clock));
+
+        // WHEN
+        daoUnderTest.addRelations(entry, relations);
+
+        // THEN
+        assertFalse(daoUnderTest.shouldUpdate(entry, clock));
+        Clock clockOneWeekAfter = Clock.fixed(
+                LocalDateTime.now(ZoneId.of("UTC")).plusWeeks(1).toInstant(ZoneOffset.UTC),
+                ZoneId.of("UTC")
+        );
+        assertFalse(daoUnderTest.shouldUpdate(entry, clockOneWeekAfter));
+    }
+
+    @ParameterizedTest
+    @MethodSource("createBibEntries")
+    void deserializerErrorShouldReturnEmptyList(BibEntry entry) throws IOException {
+        // GIVEN
+        BibEntryHashSetSerializer serializer = new BibEntryHashSetSerializer(
+                new BibEntrySerializer(
+                        new BibEntryTypesManager(),
+                        mock(ImportFormatPreferences.class, Answers.RETURNS_DEEP_STUBS),
+                        mock(FieldPreferences.class, Answers.RETURNS_DEEP_STUBS)) {
+                    @Override
+                    public BibEntry read(ByteBuffer buffer) {
+                        // Fake the return after an exception
+                        return new BibEntry();
+                    }
+                }
+        );
+        Path file = Files.createFile(temporaryFolder.resolve("serialization_error_" + MV_STORE_NAME));
+        MVStoreBibEntryRelationRepository daoUnderTest = new MVStoreBibEntryRelationRepository(file.toAbsolutePath(), MAP_NAME, 7, serializer);
+        List<BibEntry> relations = createRelations(entry);
+
+        // WHEN
+        daoUnderTest.addRelations(entry, relations);
+        daoUnderTest.close();
+        daoUnderTest = new MVStoreBibEntryRelationRepository(file.toAbsolutePath(), MAP_NAME, 7, serializer);
+        List<BibEntry> deserializedRelations = daoUnderTest.getRelations(entry);
+
+        // THEN
+        assertTrue(deserializedRelations.isEmpty());
+    }
+}
diff --git a/jablib/src/test/java/org/jabref/logic/importer/fetcher/CompositeSearchBasedFetcherTest.java b/jablib/src/test/java/org/jabref/logic/importer/fetcher/CompositeSearchBasedFetcherTest.java
index b12749b9485..32d037fb146 100644
--- a/jablib/src/test/java/org/jabref/logic/importer/fetcher/CompositeSearchBasedFetcherTest.java
+++ b/jablib/src/test/java/org/jabref/logic/importer/fetcher/CompositeSearchBasedFetcherTest.java
@@ -17,7 +17,7 @@
 import org.jabref.logic.importer.ImporterPreferences;
 import org.jabref.logic.importer.SearchBasedFetcher;
 import org.jabref.logic.importer.WebFetcher;
-import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarFetcher;
+import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarCitationFetcher;
 import org.jabref.logic.util.BuildInfo;
 import org.jabref.model.database.BibDatabaseMode;
 import org.jabref.model.entry.BibEntry;
@@ -77,7 +77,7 @@ void performSearchOnEmptyQuery(Set<SearchBasedFetcher> fetchers) throws FetcherE
             "Fetchers: {arguments}")
     @MethodSource("performSearchParameters")
     void performSearchOnNonEmptyQuery(Set<SearchBasedFetcher> fetchers) throws FetcherException {
-        List fetcherNames = fetchers.stream().map(WebFetcher::getName).toList();
+        List<String> fetcherNames = fetchers.stream().map(WebFetcher::getName).toList();
         ObservableList<String> observableList = FXCollections.observableArrayList(fetcherNames);
         when(importerPreferences.getCatalogs()).thenReturn(observableList);
         CompositeSearchBasedFetcher compositeFetcher = new CompositeSearchBasedFetcher(fetchers, importerPreferences, Integer.MAX_VALUE);
@@ -113,7 +113,7 @@ static Stream<Arguments> performSearchParameters() {
         BuildInfo buildInfo = new BuildInfo();
         when(importerPreferences.getApiKeys()).thenReturn(FXCollections.emptyObservableSet());
         when(importerPreferences.getApiKey(eq(AstrophysicsDataSystem.FETCHER_NAME))).thenReturn(Optional.of(buildInfo.astrophysicsDataSystemAPIKey));
-        when(importerPreferences.getApiKey(eq(SemanticScholarFetcher.FETCHER_NAME))).thenReturn(Optional.of(buildInfo.semanticScholarApiKey));
+        when(importerPreferences.getApiKey(eq(SemanticScholarCitationFetcher.FETCHER_NAME))).thenReturn(Optional.of(buildInfo.semanticScholarApiKey));
         when(importerPreferences.getApiKey(eq(BiodiversityLibrary.FETCHER_NAME))).thenReturn(Optional.of(buildInfo.biodiversityHeritageApiKey));
         when(importerPreferences.getApiKey(eq(ScienceDirect.FETCHER_NAME))).thenReturn(Optional.of(buildInfo.scienceDirectApiKey));
         when(importerPreferences.getApiKey(eq(SpringerFetcher.FETCHER_NAME))).thenReturn(Optional.of(buildInfo.springerNatureAPIKey));
diff --git a/jablib/src/test/java/org/jabref/logic/importer/fetcher/SemanticScholarTest.java b/jablib/src/test/java/org/jabref/logic/importer/fetcher/SemanticScholarTest.java
index 6220f64bcb6..bfb5d19748f 100644
--- a/jablib/src/test/java/org/jabref/logic/importer/fetcher/SemanticScholarTest.java
+++ b/jablib/src/test/java/org/jabref/logic/importer/fetcher/SemanticScholarTest.java
@@ -11,7 +11,7 @@
 import org.jabref.logic.importer.FetcherException;
 import org.jabref.logic.importer.ImporterPreferences;
 import org.jabref.logic.importer.PagedSearchBasedFetcher;
-import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarFetcher;
+import org.jabref.logic.importer.fetcher.citation.semanticscholar.SemanticScholarCitationFetcher;
 import org.jabref.logic.util.BuildInfo;
 import org.jabref.model.entry.BibEntry;
 import org.jabref.model.entry.field.StandardField;
@@ -50,7 +50,7 @@ public class SemanticScholarTest implements PagedSearchFetcherTest {
 
     @BeforeEach
     void setUp() {
-        when(importerPreferences.getApiKey(SemanticScholarFetcher.FETCHER_NAME)).thenReturn(apiKey);
+        when(importerPreferences.getApiKey(SemanticScholarCitationFetcher.FETCHER_NAME)).thenReturn(apiKey);
         fetcher = new SemanticScholar(importerPreferences);
     }
 
diff --git a/jablib/src/test/java/org/jabref/logic/importer/fetcher/citation/CitationFetcherHelpersForTest.java b/jablib/src/test/java/org/jabref/logic/importer/fetcher/citation/CitationFetcherHelpersForTest.java
new file mode 100644
index 00000000000..b84e767e186
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/importer/fetcher/citation/CitationFetcherHelpersForTest.java
@@ -0,0 +1,32 @@
+package org.jabref.logic.importer.fetcher.citation;
+
+import java.util.List;
+import java.util.function.Function;
+
+import org.jabref.model.entry.BibEntry;
+
+public class CitationFetcherHelpersForTest {
+    public static class Mocks {
+        public static CitationFetcher from(
+            Function<BibEntry, List<BibEntry>> retrieveCitedBy,
+            Function<BibEntry, List<BibEntry>> retrieveCiting
+        ) {
+            return new CitationFetcher() {
+                @Override
+                public List<BibEntry> searchCitedBy(BibEntry entry) {
+                    return retrieveCitedBy.apply(entry);
+                }
+
+                @Override
+                public List<BibEntry> searchCiting(BibEntry entry) {
+                    return retrieveCiting.apply(entry);
+                }
+
+                @Override
+                public String getName() {
+                    return "Test citation fetcher";
+                }
+            };
+        }
+    }
+}
diff --git a/jablib/src/test/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarCitationFetcherTest.java b/jablib/src/test/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarCitationFetcherTest.java
new file mode 100644
index 00000000000..c6f1e1e4e15
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/importer/fetcher/citation/semanticscholar/SemanticScholarCitationFetcherTest.java
@@ -0,0 +1,48 @@
+package org.jabref.logic.importer.fetcher.citation.semanticscholar;
+
+import java.util.List;
+
+import org.jabref.logic.importer.FetcherException;
+import org.jabref.logic.importer.ImporterPreferences;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.types.StandardEntryType;
+import org.jabref.testutils.category.FetcherTest;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Answers;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.mockito.Mockito.mock;
+
+@FetcherTest
+class SemanticScholarCitationFetcherTest {
+
+    SemanticScholarCitationFetcher fetcher;
+
+    @BeforeEach
+    void setUp() {
+        fetcher = new SemanticScholarCitationFetcher(mock(ImporterPreferences.class, Answers.RETURNS_DEEP_STUBS));
+    }
+
+    @Test
+    void smoke() throws FetcherException {
+        BibEntry entry = new BibEntry(StandardEntryType.Article)
+                .withCitationKey("Macht_2007")
+                .withField(StandardField.AUTHOR, "Macht, Michael and Mueller, Jochen")
+                .withField(StandardField.TITLE, "Immediate effects of chocolate on experimentally induced mood states")
+                .withField(StandardField.JOURNALTITLE, "Appetite")
+                .withField(StandardField.DATE, "2007-11")
+                .withField(StandardField.VOLUME, "49")
+                .withField(StandardField.NUMBER, "3")
+                .withField(StandardField.PAGES, "667--674")
+                .withField(StandardField.DOI, "10.1016/j.appet.2007.05.004")
+                .withField(StandardField.ISSN, "0195-6663")
+                .withField(StandardField.PUBLISHER, "Elsevier BV");
+
+        List<BibEntry> result = fetcher.searchCiting(entry);
+        // Paper has more than 400 cites, but server returns "null" as data
+        assertNotEquals(null, result);
+    }
+}