diff --git a/src/main/java/org/jabref/gui/entryeditor/AiChatTab.java b/src/main/java/org/jabref/gui/entryeditor/AiChatTab.java
index 623349e45f7..6c7408bcca4 100644
--- a/src/main/java/org/jabref/gui/entryeditor/AiChatTab.java
+++ b/src/main/java/org/jabref/gui/entryeditor/AiChatTab.java
@@ -88,7 +88,7 @@ protected void handleFocus() {
     protected void bindToEntry(BibEntry entry) {
         if (!aiService.getPreferences().getEnableAi()) {
             showPrivacyNotice(entry);
-        } else if (aiService.getPreferences().getApiToken().isEmpty()) {
+        } else if (aiService.getPreferences().getSelectedApiToken().isEmpty()) {
             showApiKeyMissing();
         } else if (entry.getFiles().isEmpty()) {
             showErrorNoFiles();
diff --git a/src/main/java/org/jabref/gui/entryeditor/AiSummaryTab.java b/src/main/java/org/jabref/gui/entryeditor/AiSummaryTab.java
index 490c1b4e220..aee1581f818 100644
--- a/src/main/java/org/jabref/gui/entryeditor/AiSummaryTab.java
+++ b/src/main/java/org/jabref/gui/entryeditor/AiSummaryTab.java
@@ -82,7 +82,7 @@ protected void handleFocus() {
     protected void bindToEntry(BibEntry entry) {
         if (!aiService.getPreferences().getEnableAi()) {
             showPrivacyNotice(entry);
-        } else if (aiService.getPreferences().getApiToken().isEmpty()) {
+        } else if (aiService.getPreferences().getSelectedApiToken().isEmpty()) {
             showApiKeyMissing();
         } else if (bibDatabaseContext.getDatabasePath().isEmpty()) {
             showErrorNoDatabasePath();
diff --git a/src/main/java/org/jabref/gui/preferences/ai/AiTab.fxml b/src/main/java/org/jabref/gui/preferences/ai/AiTab.fxml
index 058ba9e0af8..92ed6658388 100644
--- a/src/main/java/org/jabref/gui/preferences/ai/AiTab.fxml
+++ b/src/main/java/org/jabref/gui/preferences/ai/AiTab.fxml
@@ -7,6 +7,7 @@
 <?import org.controlsfx.control.textfield.*?>
 
 <?import org.jabref.gui.icon.JabRefIconView?>
+<?import javafx.geometry.Insets?>
 <fx:root spacing="10.0" type="VBox" xmlns="http://javafx.com/javafx/17.0.2-ea" xmlns:fx="http://javafx.com/fxml/1" fx:controller="org.jabref.gui.preferences.ai.AiTab">
     <children>
         <Label styleClass="titleHeader" text="%AI" />
@@ -35,6 +36,9 @@
                 <ComboBox fx:id="chatModelComboBox" editable="true" maxWidth="1.7976931348623157E308" HBox.hgrow="ALWAYS" />
                 <Button fx:id="chatModelHelp" prefWidth="20.0" />
             </children>
+            <padding>
+                <Insets left="20.0"/>
+            </padding>
         </HBox>
 
         <HBox alignment="CENTER_LEFT" spacing="10.0">
@@ -43,6 +47,9 @@
                 <CustomPasswordField fx:id="apiKeyTextField" HBox.hgrow="ALWAYS" />
                 <Button fx:id="apiTokenHelp" prefWidth="20.0" />
             </children>
+            <padding>
+                <Insets left="20.0"/>
+            </padding>
         </HBox>
 
         <Label styleClass="sectionHeader" text="%Expert settings" />
diff --git a/src/main/java/org/jabref/gui/preferences/ai/AiTabViewModel.java b/src/main/java/org/jabref/gui/preferences/ai/AiTabViewModel.java
index 44672656cb9..dda4a572702 100644
--- a/src/main/java/org/jabref/gui/preferences/ai/AiTabViewModel.java
+++ b/src/main/java/org/jabref/gui/preferences/ai/AiTabViewModel.java
@@ -39,9 +39,18 @@ public class AiTabViewModel implements PreferenceTabViewModel {
 
     private final ListProperty<String> chatModelsList =
             new SimpleListProperty<>(FXCollections.observableArrayList());
-    private final StringProperty selectedChatModel = new SimpleStringProperty();
 
-    private final StringProperty apiToken = new SimpleStringProperty();
+    private final StringProperty currentChatModel = new SimpleStringProperty();
+
+    private final StringProperty openAiChatModel = new SimpleStringProperty();
+    private final StringProperty mistralAiChatModel = new SimpleStringProperty();
+    private final StringProperty huggingFaceChatModel = new SimpleStringProperty();
+
+    private final StringProperty currentApiToken = new SimpleStringProperty();
+
+    private final StringProperty openAiApiToken = new SimpleStringProperty();
+    private final StringProperty mistralAiApiToken = new SimpleStringProperty();
+    private final StringProperty huggingFaceApiToken = new SimpleStringProperty();
 
     private final BooleanProperty customizeExpertSettings = new SimpleBooleanProperty();
 
@@ -49,9 +58,13 @@ public class AiTabViewModel implements PreferenceTabViewModel {
             new SimpleListProperty<>(FXCollections.observableArrayList(AiPreferences.EmbeddingModel.values()));
     private final ObjectProperty<AiPreferences.EmbeddingModel> selectedEmbeddingModel = new SimpleObjectProperty<>();
 
-    private final StringProperty apiBaseUrl = new SimpleStringProperty();
+    private final StringProperty currentApiBaseUrl = new SimpleStringProperty();
     private final BooleanProperty disableApiBaseUrl = new SimpleBooleanProperty(true); // {@link HuggingFaceChatModel} doesn't support setting API base URL
 
+    private final StringProperty openAiApiBaseUrl = new SimpleStringProperty();
+    private final StringProperty mistralAiApiBaseUrl = new SimpleStringProperty();
+    private final StringProperty huggingFaceApiBaseUrl = new SimpleStringProperty();
+
     private final StringProperty instruction = new SimpleStringProperty();
     private final DoubleProperty temperature = new SimpleDoubleProperty();
     private final IntegerProperty contextWindowSize = new SimpleIntegerProperty();
@@ -89,17 +102,65 @@ public AiTabViewModel(PreferencesService preferencesService) {
         );
 
         this.selectedAiProvider.addListener((observable, oldValue, newValue) -> {
-            List<String> models = AiDefaultPreferences.CHAT_MODELS.get(newValue);
+            List<String> models = AiDefaultPreferences.AVAILABLE_CHAT_MODELS.get(newValue);
+
+            // When we setAll on Hugging Face, models are empty, and currentChatModel become null.
+            // It becomes null beause currentChatModel is binded to combobox, and this combobox becomes empty.
+            // For some reason, custom edited value in the combobox will be erased, so we need to store the old value.
+            String oldChatModel = currentChatModel.get();
             chatModelsList.setAll(models);
-            if (!models.isEmpty()) {
-                selectedChatModel.setValue(chatModelsList.getFirst());
+
+            disableApiBaseUrl.set(newValue == AiPreferences.AiProvider.HUGGING_FACE);
+
+            if (oldValue != null) {
+                switch (oldValue) {
+                    case OPEN_AI -> {
+                        openAiChatModel.set(oldChatModel);
+                        openAiApiToken.set(currentApiToken.get());
+                        openAiApiBaseUrl.set(currentApiBaseUrl.get());
+                    }
+
+                    case MISTRAL_AI -> {
+                        mistralAiChatModel.set(oldChatModel);
+                        mistralAiApiToken.set(currentApiToken.get());
+                        mistralAiApiBaseUrl.set(currentApiBaseUrl.get()); }
+
+                    case HUGGING_FACE -> {
+                        huggingFaceChatModel.set(oldChatModel);
+                        huggingFaceApiToken.set(currentApiToken.get());
+                        huggingFaceApiBaseUrl.set(currentApiBaseUrl.get());
+                    }
+                }
             }
 
-            apiBaseUrl.set(AiDefaultPreferences.PROVIDERS_API_URLS.get(newValue));
-            apiToken.set("");
+            switch (newValue) {
+                case OPEN_AI -> {
+                    currentChatModel.set(openAiChatModel.get());
+                    currentApiToken.set(openAiApiToken.get());
+                    currentApiBaseUrl.set(openAiApiBaseUrl.get());
+                }
+
+                case MISTRAL_AI -> {
+                    currentChatModel.set(mistralAiChatModel.get());
+                    currentApiToken.set(mistralAiApiToken.get());
+                    currentApiBaseUrl.set(mistralAiApiBaseUrl.get());
+                }
+
+                case HUGGING_FACE -> {
+                    currentChatModel.set(huggingFaceChatModel.get());
+                    currentApiToken.set(huggingFaceApiToken.get());
+                    currentApiBaseUrl.set(huggingFaceApiBaseUrl.get());
+                }
+            }
         });
 
-        this.selectedChatModel.addListener((observable, oldValue, newValue) -> {
+        this.currentChatModel.addListener((observable, oldValue, newValue) -> {
+            switch (selectedAiProvider.get()) {
+                case OPEN_AI -> openAiChatModel.set(newValue);
+                case MISTRAL_AI -> mistralAiChatModel.set(newValue);
+                case HUGGING_FACE -> huggingFaceChatModel.set(newValue);
+            }
+
             Map<String, Integer> modelContextWindows = AiDefaultPreferences.CONTEXT_WINDOW_SIZES.get(selectedAiProvider.get());
 
             if (modelContextWindows == null) {
@@ -107,27 +168,37 @@ public AiTabViewModel(PreferencesService preferencesService) {
                 return;
             }
 
-            Integer value = modelContextWindows.get(newValue);
+            contextWindowSize.set(modelContextWindows.getOrDefault(newValue, AiDefaultPreferences.CONTEXT_WINDOW_SIZE));
+        });
 
-            contextWindowSize.set(value == null ? AiDefaultPreferences.CONTEXT_WINDOW_SIZE : value);
+        this.currentApiToken.addListener((observable, oldValue, newValue) -> {
+            switch (selectedAiProvider.get()) {
+                case OPEN_AI -> openAiApiToken.set(newValue);
+                case MISTRAL_AI -> mistralAiApiToken.set(newValue);
+                case HUGGING_FACE -> huggingFaceApiToken.set(newValue);
+            }
         });
 
-        this.selectedAiProvider.addListener((observable, oldValue, newValue) ->
-            disableApiBaseUrl.set(newValue == AiPreferences.AiProvider.HUGGING_FACE)
-        );
+        this.currentApiBaseUrl.addListener((observable, oldValue, newValue) -> {
+            switch (selectedAiProvider.get()) {
+                case OPEN_AI -> openAiApiBaseUrl.set(newValue);
+                case MISTRAL_AI -> mistralAiApiBaseUrl.set(newValue);
+                case HUGGING_FACE -> huggingFaceApiBaseUrl.set(newValue);
+            }
+        });
 
         this.apiTokenValidator = new FunctionBasedValidator<>(
-                apiToken,
+                currentApiToken,
                 token -> !StringUtil.isBlank(token),
                 ValidationMessage.error(Localization.lang("An OpenAI token has to be provided")));
 
         this.chatModelValidator = new FunctionBasedValidator<>(
-                selectedChatModel,
+                currentChatModel,
                 chatModel -> !StringUtil.isBlank(chatModel),
                 ValidationMessage.error(Localization.lang("Chat model has to be provided")));
 
         this.apiBaseUrlValidator = new FunctionBasedValidator<>(
-                apiBaseUrl,
+                currentApiBaseUrl,
                 token -> !StringUtil.isBlank(token),
                 ValidationMessage.error(Localization.lang("API base URL has to be provided")));
 
@@ -172,14 +243,22 @@ public AiTabViewModel(PreferencesService preferencesService) {
     public void setValues() {
         enableAi.setValue(aiPreferences.getEnableAi());
 
-        selectedAiProvider.setValue(aiPreferences.getAiProvider());
-        selectedChatModel.setValue(aiPreferences.getChatModel());
-        apiToken.setValue(aiPreferences.getApiToken());
+        openAiChatModel.setValue(aiPreferences.getOpenAiChatModel());
+        mistralAiChatModel.setValue(aiPreferences.getMistralAiChatModel());
+        huggingFaceChatModel.setValue(aiPreferences.getHuggingFaceChatModel());
+
+        openAiApiToken.setValue(aiPreferences.getOpenAiApiToken());
+        mistralAiApiToken.setValue(aiPreferences.getMistralAiApiToken());
+        huggingFaceApiToken.setValue(aiPreferences.getHuggingFaceApiToken());
 
         customizeExpertSettings.setValue(aiPreferences.getCustomizeExpertSettings());
 
         selectedEmbeddingModel.setValue(aiPreferences.getEmbeddingModel());
-        apiBaseUrl.setValue(aiPreferences.getApiBaseUrl());
+
+        openAiApiBaseUrl.setValue(aiPreferences.getOpenAiApiBaseUrl());
+        mistralAiApiBaseUrl.setValue(aiPreferences.getMistralAiApiBaseUrl());
+        huggingFaceApiBaseUrl.setValue(aiPreferences.getHuggingFaceApiBaseUrl());
+
         instruction.setValue(aiPreferences.getInstruction());
         temperature.setValue(aiPreferences.getTemperature());
         contextWindowSize.setValue(aiPreferences.getContextWindowSize());
@@ -187,6 +266,8 @@ public void setValues() {
         documentSplitterOverlapSize.setValue(aiPreferences.getDocumentSplitterOverlapSize());
         ragMaxResultsCount.setValue(aiPreferences.getRagMaxResultsCount());
         ragMinScore.setValue(aiPreferences.getRagMinScore());
+
+        selectedAiProvider.setValue(aiPreferences.getAiProvider());
     }
 
     @Override
@@ -194,13 +275,23 @@ public void storeSettings() {
         aiPreferences.setEnableAi(enableAi.get());
 
         aiPreferences.setAiProvider(selectedAiProvider.get());
-        aiPreferences.setChatModel(selectedChatModel.get());
-        aiPreferences.setApiToken(apiToken.get());
+
+        aiPreferences.setOpenAiChatModel(openAiChatModel.get());
+        aiPreferences.setMistralAiChatModel(mistralAiChatModel.get());
+        aiPreferences.setHuggingFaceChatModel(huggingFaceChatModel.get());
+
+        aiPreferences.setOpenAiApiToken(openAiApiToken.get());
+        aiPreferences.setMistralAiApiToken(mistralAiApiToken.get());
+        aiPreferences.setHuggingFaceApiToken(huggingFaceApiToken.get());
 
         aiPreferences.setCustomizeExpertSettings(customizeExpertSettings.get());
 
         aiPreferences.setEmbeddingModel(selectedEmbeddingModel.get());
-        aiPreferences.setApiBaseUrl(apiBaseUrl.get());
+
+        aiPreferences.setOpenAiApiBaseUrl(openAiApiBaseUrl.get());
+        aiPreferences.setMistralAiApiBaseUrl(mistralAiApiBaseUrl.get());
+        aiPreferences.setHuggingFaceApiBaseUrl(huggingFaceApiBaseUrl.get());
+
         aiPreferences.setInstruction(instruction.get());
         aiPreferences.setTemperature(temperature.get());
         aiPreferences.setContextWindowSize(contextWindowSize.get());
@@ -212,29 +303,17 @@ public void storeSettings() {
 
     public void resetExpertSettings() {
         String resetApiBaseUrl = AiDefaultPreferences.PROVIDERS_API_URLS.get(selectedAiProvider.get());
-        aiPreferences.setApiBaseUrl(resetApiBaseUrl);
-        apiBaseUrl.setValue(resetApiBaseUrl);
+        currentApiBaseUrl.set(resetApiBaseUrl);
 
-        aiPreferences.setInstruction(AiDefaultPreferences.SYSTEM_MESSAGE);
         instruction.set(AiDefaultPreferences.SYSTEM_MESSAGE);
 
-        int resetContextWindowSize = AiDefaultPreferences.CONTEXT_WINDOW_SIZES.getOrDefault(selectedAiProvider.get(), Map.of()).getOrDefault(selectedChatModel.get(), 0);
-        aiPreferences.setContextWindowSize(resetContextWindowSize);
+        int resetContextWindowSize = AiDefaultPreferences.CONTEXT_WINDOW_SIZES.getOrDefault(selectedAiProvider.get(), Map.of()).getOrDefault(currentChatModel.get(), 0);
         contextWindowSize.set(resetContextWindowSize);
 
-        aiPreferences.setTemperature(AiDefaultPreferences.TEMPERATURE);
         temperature.set(AiDefaultPreferences.TEMPERATURE);
-
-        aiPreferences.setDocumentSplitterChunkSize(AiDefaultPreferences.DOCUMENT_SPLITTER_CHUNK_SIZE);
         documentSplitterChunkSize.set(AiDefaultPreferences.DOCUMENT_SPLITTER_CHUNK_SIZE);
-
-        aiPreferences.setDocumentSplitterOverlapSize(AiDefaultPreferences.DOCUMENT_SPLITTER_OVERLAP);
         documentSplitterOverlapSize.set(AiDefaultPreferences.DOCUMENT_SPLITTER_OVERLAP);
-
-        aiPreferences.setRagMaxResultsCount(AiDefaultPreferences.RAG_MAX_RESULTS_COUNT);
         ragMaxResultsCount.set(AiDefaultPreferences.RAG_MAX_RESULTS_COUNT);
-
-        aiPreferences.setRagMinScore(AiDefaultPreferences.RAG_MIN_SCORE);
         ragMinScore.set(AiDefaultPreferences.RAG_MIN_SCORE);
     }
 
@@ -296,11 +375,11 @@ public ReadOnlyListProperty<String> chatModelsProperty() {
     }
 
     public StringProperty selectedChatModelProperty() {
-        return selectedChatModel;
+        return currentChatModel;
     }
 
     public StringProperty apiTokenProperty() {
-        return apiToken;
+        return currentApiToken;
     }
 
     public BooleanProperty customizeExpertSettingsProperty() {
@@ -316,7 +395,7 @@ public ObjectProperty<AiPreferences.EmbeddingModel> selectedEmbeddingModelProper
     }
 
     public StringProperty apiBaseUrlProperty() {
-        return apiBaseUrl;
+        return currentApiBaseUrl;
     }
 
     public BooleanProperty disableApiBaseUrlProperty() {
diff --git a/src/main/java/org/jabref/logic/ai/AiDefaultPreferences.java b/src/main/java/org/jabref/logic/ai/AiDefaultPreferences.java
index 1bd5506c8c4..6858075ac9d 100644
--- a/src/main/java/org/jabref/logic/ai/AiDefaultPreferences.java
+++ b/src/main/java/org/jabref/logic/ai/AiDefaultPreferences.java
@@ -6,33 +6,19 @@
 import org.jabref.preferences.AiPreferences;
 
 public class AiDefaultPreferences {
-    public static final boolean ENABLE_CHAT = false;
-
-    public static final AiPreferences.AiProvider PROVIDER = AiPreferences.AiProvider.OPEN_AI;
-    public static final Map<AiPreferences.AiProvider, List<String>> CHAT_MODELS = Map.of(
+    public static final Map<AiPreferences.AiProvider, List<String>> AVAILABLE_CHAT_MODELS = Map.of(
             AiPreferences.AiProvider.OPEN_AI, List.of("gpt-4o-mini", "gpt-4o", "gpt-4", "gpt-4-turbo", "gpt-3.5-turbo"),
             // "mistral" and "mixtral" are not language mistakes.
             AiPreferences.AiProvider.MISTRAL_AI, List.of("open-mistral-nemo", "open-mistral-7b", "open-mixtral-8x7b", "open-mixtral-8x22b", "mistral-large-latest"),
             AiPreferences.AiProvider.HUGGING_FACE, List.of()
     );
-    public static final String CHAT_MODEL = CHAT_MODELS.get(PROVIDER).getFirst();
-
-    public static final boolean CUSTOMIZE_SETTINGS = false;
 
-    public static final AiPreferences.EmbeddingModel EMBEDDING_MODEL = AiPreferences.EmbeddingModel.ALL_MINILM_L6_V2;
-    public static final String SYSTEM_MESSAGE = "You are an AI assistant that analyses research papers.";
-    public static final double TEMPERATURE = 0.7;
-    public static final int DOCUMENT_SPLITTER_CHUNK_SIZE = 300;
-    public static final int DOCUMENT_SPLITTER_OVERLAP = 100;
-    public static final int RAG_MAX_RESULTS_COUNT = 10;
-    public static final double RAG_MIN_SCORE = 0.3;
-
-    public static final int CONTEXT_WINDOW_SIZE = 8196;
     public static final Map<AiPreferences.AiProvider, String> PROVIDERS_API_URLS = Map.of(
             AiPreferences.AiProvider.OPEN_AI, "https://api.openai.com/v1",
             AiPreferences.AiProvider.MISTRAL_AI, "https://api.mistral.ai/v1",
             AiPreferences.AiProvider.HUGGING_FACE, "https://huggingface.co/api"
     );
+
     public static final Map<AiPreferences.AiProvider, Map<String, Integer>> CONTEXT_WINDOW_SIZES = Map.of(
             AiPreferences.AiProvider.OPEN_AI, Map.of(
                     "gpt-4o-mini", 128000,
@@ -49,4 +35,30 @@ public class AiDefaultPreferences {
                     "open-mixtral-8x22b", 64000
             )
     );
+
+    public static final boolean ENABLE_CHAT = false;
+
+    public static final AiPreferences.AiProvider PROVIDER = AiPreferences.AiProvider.OPEN_AI;
+
+    public static final Map<AiPreferences.AiProvider, String> CHAT_MODELS = Map.of(
+            AiPreferences.AiProvider.OPEN_AI, "gpt-4o-mini",
+            AiPreferences.AiProvider.MISTRAL_AI, "open-mixtral-8x22b",
+            AiPreferences.AiProvider.HUGGING_FACE, ""
+    );
+
+    public static final boolean CUSTOMIZE_SETTINGS = false;
+
+    public static final AiPreferences.EmbeddingModel EMBEDDING_MODEL = AiPreferences.EmbeddingModel.ALL_MINILM_L6_V2;
+    public static final String SYSTEM_MESSAGE = "You are an AI assistant that analyses research papers.";
+    public static final double TEMPERATURE = 0.7;
+    public static final int DOCUMENT_SPLITTER_CHUNK_SIZE = 300;
+    public static final int DOCUMENT_SPLITTER_OVERLAP = 100;
+    public static final int RAG_MAX_RESULTS_COUNT = 10;
+    public static final double RAG_MIN_SCORE = 0.3;
+
+    public static final int CONTEXT_WINDOW_SIZE = 8196;
+
+    public static int getContextWindowSize(AiPreferences.AiProvider aiProvider, String model) {
+        return CONTEXT_WINDOW_SIZES.getOrDefault(aiProvider, Map.of()).getOrDefault(model, 0);
+    }
 }
diff --git a/src/main/java/org/jabref/logic/ai/models/JabRefChatLanguageModel.java b/src/main/java/org/jabref/logic/ai/models/JabRefChatLanguageModel.java
index 5e4f865bc92..1affcaf6270 100644
--- a/src/main/java/org/jabref/logic/ai/models/JabRefChatLanguageModel.java
+++ b/src/main/java/org/jabref/logic/ai/models/JabRefChatLanguageModel.java
@@ -56,7 +56,7 @@ public JabRefChatLanguageModel(AiPreferences aiPreferences) {
      * and using {@link org.jabref.logic.ai.chathistory.BibDatabaseChatHistoryManager}, where messages are stored in {@link MVStore}.
      */
     private void rebuild() {
-        if (!aiPreferences.getEnableAi() || aiPreferences.getApiToken().isEmpty()) {
+        if (!aiPreferences.getEnableAi() || aiPreferences.getSelectedApiToken().isEmpty()) {
             langchainChatModel = Optional.empty();
             return;
         }
@@ -69,10 +69,10 @@ private void rebuild() {
             case MISTRAL_AI -> {
                 langchainChatModel = Optional.of(MistralAiChatModel
                         .builder()
-                        .apiKey(aiPreferences.getApiToken())
-                        .modelName(aiPreferences.getChatModel())
+                        .apiKey(aiPreferences.getSelectedApiToken())
+                        .modelName(aiPreferences.getSelectedChatModel())
                         .temperature(aiPreferences.getTemperature())
-                        .baseUrl(aiPreferences.getApiBaseUrl())
+                        .baseUrl(aiPreferences.getSelectedApiBaseUrl())
                         .logRequests(true)
                         .logResponses(true)
                         .build()
@@ -83,8 +83,8 @@ private void rebuild() {
                 // NOTE: {@link HuggingFaceChatModel} doesn't support API base url :(
                 langchainChatModel = Optional.of(HuggingFaceChatModel
                         .builder()
-                        .accessToken(aiPreferences.getApiToken())
-                        .modelId(aiPreferences.getChatModel())
+                        .accessToken(aiPreferences.getSelectedApiToken())
+                        .modelId(aiPreferences.getSelectedChatModel())
                         .temperature(aiPreferences.getTemperature())
                         .timeout(Duration.ofMinutes(2))
                         .build()
@@ -96,9 +96,10 @@ private void rebuild() {
     private void setupListeningToPreferencesChanges() {
         aiPreferences.enableAiProperty().addListener(obs -> rebuild());
         aiPreferences.aiProviderProperty().addListener(obs -> rebuild());
-        aiPreferences.chatModelProperty().addListener(obs -> rebuild());
-        aiPreferences.apiTokenProperty().addListener(obs -> rebuild());
-        aiPreferences.apiBaseUrlProperty().addListener(obs -> rebuild());
+        aiPreferences.listenToChatModels(this::rebuild);
+        aiPreferences.listenToApiTokens(this::rebuild);
+        aiPreferences.listenToApiBaseUrls(this::rebuild);
+        aiPreferences.listenToChatModels(this::rebuild);
         aiPreferences.temperatureProperty().addListener(obs -> rebuild());
     }
 
@@ -115,7 +116,7 @@ public Response<AiMessage> generate(List<ChatMessage> list) {
         if (langchainChatModel.isEmpty()) {
             if (!aiPreferences.getEnableAi()) {
                 throw new RuntimeException(Localization.lang("In order to use AI chat, you need to enable chatting with attached PDF files in JabRef preferences (AI tab)."));
-            } else if (aiPreferences.getApiToken().isEmpty()) {
+            } else if (aiPreferences.getSelectedApiToken().isEmpty()) {
                 throw new RuntimeException(Localization.lang("In order to use AI chat, set OpenAI API key inside JabRef preferences (AI tab)."));
             } else {
                 throw new RuntimeException(Localization.lang("Unable to chat with AI."));
diff --git a/src/main/java/org/jabref/logic/ai/models/JvmOpenAiChatLanguageModel.java b/src/main/java/org/jabref/logic/ai/models/JvmOpenAiChatLanguageModel.java
index e851627aa7a..223f9206814 100644
--- a/src/main/java/org/jabref/logic/ai/models/JvmOpenAiChatLanguageModel.java
+++ b/src/main/java/org/jabref/logic/ai/models/JvmOpenAiChatLanguageModel.java
@@ -29,9 +29,9 @@ public JvmOpenAiChatLanguageModel(AiPreferences aiPreferences, HttpClient httpCl
         this.aiPreferences = aiPreferences;
 
         OpenAI openAI = OpenAI
-                .newBuilder(aiPreferences.getApiToken())
+                .newBuilder(aiPreferences.getSelectedApiToken())
                 .httpClient(httpClient)
-                .baseUrl(aiPreferences.getApiBaseUrl())
+                .baseUrl(aiPreferences.getSelectedApiBaseUrl())
                 .build();
 
         this.chatClient = openAI.chatClient();
@@ -50,7 +50,7 @@ public Response<AiMessage> generate(List<ChatMessage> list) {
 
         CreateChatCompletionRequest request = CreateChatCompletionRequest
                 .newBuilder()
-                .model(aiPreferences.getChatModel())
+                .model(aiPreferences.getSelectedChatModel())
                 .temperature(aiPreferences.getTemperature())
                 .n(1)
                 .messages(messages)
diff --git a/src/main/java/org/jabref/preferences/AiPreferences.java b/src/main/java/org/jabref/preferences/AiPreferences.java
index 781e9e107ae..7e2f184dc7f 100644
--- a/src/main/java/org/jabref/preferences/AiPreferences.java
+++ b/src/main/java/org/jabref/preferences/AiPreferences.java
@@ -1,6 +1,5 @@
 package org.jabref.preferences;
 
-import java.util.Map;
 import java.util.Objects;
 
 import javafx.beans.property.BooleanProperty;
@@ -58,12 +57,21 @@ public String toString() {
     private final BooleanProperty enableAi;
 
     private final ObjectProperty<AiProvider> aiProvider;
-    private final StringProperty chatModel;
-    private final StringProperty apiToken;
+
+    private final StringProperty openAiChatModel;
+    private final StringProperty mistralAiChatModel;
+    private final StringProperty huggingFaceChatModel;
+
+    private final StringProperty openAiApiToken;
+    private final StringProperty mistralAiApiToken;
+    private final StringProperty huggingFaceApiToken;
 
     private final BooleanProperty customizeExpertSettings;
 
-    private final StringProperty apiBaseUrl;
+    private final StringProperty openAiApiBaseUrl;
+    private final StringProperty mistralAiApiBaseUrl;
+    private final StringProperty huggingFaceApiBaseUrl;
+
     private final ObjectProperty<EmbeddingModel> embeddingModel;
     private final StringProperty instruction;
     private final DoubleProperty temperature;
@@ -75,10 +83,16 @@ public String toString() {
 
     public AiPreferences(boolean enableAi,
                          AiProvider aiProvider,
-                         String chatModel,
-                         String apiToken,
+                         String openAiChatModel,
+                         String mistralAiChatModel,
+                         String huggingFaceChatModel,
+                         String openAiApiToken,
+                         String mistralAiApiToken,
+                         String huggingFaceApiToken,
                          boolean customizeExpertSettings,
-                         String apiBaseUrl,
+                         String openAiApiBaseUrl,
+                         String mistralAiApiBaseUrl,
+                         String huggingFaceApiBaseUrl,
                          EmbeddingModel embeddingModel,
                          String instruction,
                          double temperature,
@@ -91,12 +105,21 @@ public AiPreferences(boolean enableAi,
         this.enableAi = new SimpleBooleanProperty(enableAi);
 
         this.aiProvider = new SimpleObjectProperty<>(aiProvider);
-        this.chatModel = new SimpleStringProperty(chatModel);
-        this.apiToken = new SimpleStringProperty(apiToken);
+
+        this.openAiChatModel = new SimpleStringProperty(openAiChatModel);
+        this.mistralAiChatModel = new SimpleStringProperty(mistralAiChatModel);
+        this.huggingFaceChatModel = new SimpleStringProperty(huggingFaceChatModel);
+
+        this.openAiApiToken = new SimpleStringProperty(openAiApiToken);
+        this.mistralAiApiToken = new SimpleStringProperty(mistralAiApiToken);
+        this.huggingFaceApiToken = new SimpleStringProperty(huggingFaceApiToken);
 
         this.customizeExpertSettings = new SimpleBooleanProperty(customizeExpertSettings);
 
-        this.apiBaseUrl = new SimpleStringProperty(apiBaseUrl);
+        this.openAiApiBaseUrl = new SimpleStringProperty(openAiApiBaseUrl);
+        this.mistralAiApiBaseUrl = new SimpleStringProperty(mistralAiApiBaseUrl);
+        this.huggingFaceApiBaseUrl = new SimpleStringProperty(huggingFaceApiBaseUrl);
+
         this.embeddingModel = new SimpleObjectProperty<>(embeddingModel);
         this.instruction = new SimpleStringProperty(instruction);
         this.temperature = new SimpleDoubleProperty(temperature);
@@ -131,28 +154,76 @@ public void setAiProvider(AiProvider aiProvider) {
         this.aiProvider.set(aiProvider);
     }
 
-    public StringProperty chatModelProperty() {
-        return chatModel;
+    public StringProperty openAiChatModelProperty() {
+        return openAiChatModel;
+    }
+
+    public String getOpenAiChatModel() {
+        return openAiChatModel.get();
+    }
+
+    public void setOpenAiChatModel(String openAiChatModel) {
+        this.openAiChatModel.set(openAiChatModel);
+    }
+
+    public StringProperty mistralAiChatModelProperty() {
+        return mistralAiChatModel;
     }
 
-    public String getChatModel() {
-        return chatModel.get();
+    public String getMistralAiChatModel() {
+        return mistralAiChatModel.get();
     }
 
-    public void setChatModel(String chatModel) {
-        this.chatModel.set(chatModel);
+    public void setMistralAiChatModel(String mistralAiChatModel) {
+        this.mistralAiChatModel.set(mistralAiChatModel);
     }
 
-    public StringProperty apiTokenProperty() {
-        return apiToken;
+    public StringProperty huggingFaceChatModelProperty() {
+        return huggingFaceChatModel;
     }
 
-    public String getApiToken() {
-        return apiToken.get();
+    public String getHuggingFaceChatModel() {
+        return huggingFaceChatModel.get();
     }
 
-    public void setApiToken(String apiToken) {
-        this.apiToken.set(apiToken);
+    public void setHuggingFaceChatModel(String huggingFaceChatModel) {
+        this.huggingFaceChatModel.set(huggingFaceChatModel);
+    }
+
+    public StringProperty openAiApiTokenProperty() {
+        return openAiApiToken;
+    }
+
+    public String getOpenAiApiToken() {
+        return openAiApiToken.get();
+    }
+
+    public void setOpenAiApiToken(String openAiApiToken) {
+        this.openAiApiToken.set(openAiApiToken);
+    }
+
+    public StringProperty mistralAiApiTokenProperty() {
+        return mistralAiApiToken;
+    }
+
+    public String getMistralAiApiToken() {
+        return mistralAiApiToken.get();
+    }
+
+    public void setMistralAiApiToken(String mistralAiApiToken) {
+        this.mistralAiApiToken.set(mistralAiApiToken);
+    }
+
+    public StringProperty huggingFaceApiTokenProperty() {
+        return huggingFaceApiToken;
+    }
+
+    public String getHuggingFaceApiToken() {
+        return huggingFaceApiToken.get();
+    }
+
+    public void setHuggingFaceApiToken(String huggingFaceAiApiToken) {
+        this.huggingFaceApiToken.set(huggingFaceAiApiToken);
     }
 
     public BooleanProperty customizeExpertSettingsProperty() {
@@ -179,24 +250,44 @@ public EmbeddingModel getEmbeddingModel() {
         }
     }
 
-    public void setApiBaseUrl(String apiBaseUrl) {
-        this.apiBaseUrl.set(apiBaseUrl);
+    public void setEmbeddingModel(EmbeddingModel embeddingModel) {
+        this.embeddingModel.set(embeddingModel);
     }
 
-    public StringProperty apiBaseUrlProperty() {
-        return apiBaseUrl;
+    public StringProperty openAiApiBaseUrlProperty() {
+        return openAiApiBaseUrl;
     }
 
-    public String getApiBaseUrl() {
-        if (getCustomizeExpertSettings()) {
-            return apiBaseUrl.get();
-        } else {
-            return AiDefaultPreferences.PROVIDERS_API_URLS.get(getAiProvider());
-        }
+    public String getOpenAiApiBaseUrl() {
+        return openAiApiBaseUrl.get();
     }
 
-    public void setEmbeddingModel(EmbeddingModel embeddingModel) {
-        this.embeddingModel.set(embeddingModel);
+    public void setOpenAiApiBaseUrl(String openAiApiBaseUrl) {
+        this.openAiApiBaseUrl.set(openAiApiBaseUrl);
+    }
+
+    public StringProperty mistralAiApiBaseUrlProperty() {
+        return mistralAiApiBaseUrl;
+    }
+
+    public String getMistralAiApiBaseUrl() {
+        return mistralAiApiBaseUrl.get();
+    }
+
+    public void setMistralAiApiBaseUrl(String mistralAiApiBaseUrl) {
+        this.mistralAiApiBaseUrl.set(mistralAiApiBaseUrl);
+    }
+
+    public StringProperty huggingFaceApiBaseUrlProperty() {
+        return huggingFaceApiBaseUrl;
+    }
+
+    public String getHuggingFaceApiBaseUrl() {
+        return huggingFaceApiBaseUrl.get();
+    }
+
+    public void setHuggingFaceApiBaseUrl(String huggingFaceApiBaseUrl) {
+        this.huggingFaceApiBaseUrl.set(huggingFaceApiBaseUrl);
     }
 
     public StringProperty instructionProperty() {
@@ -239,7 +330,11 @@ public int getContextWindowSize() {
         if (getCustomizeExpertSettings()) {
             return contextWindowSize.get();
         } else {
-            return AiDefaultPreferences.CONTEXT_WINDOW_SIZES.getOrDefault(getAiProvider(), Map.of()).getOrDefault(getChatModel(), AiDefaultPreferences.CONTEXT_WINDOW_SIZE);
+            return switch (aiProvider.get()) {
+                case OPEN_AI -> AiDefaultPreferences.getContextWindowSize(AiProvider.OPEN_AI, openAiChatModel.get());
+                case MISTRAL_AI -> AiDefaultPreferences.getContextWindowSize(AiProvider.MISTRAL_AI, mistralAiChatModel.get());
+                case HUGGING_FACE -> AiDefaultPreferences.getContextWindowSize(AiProvider.HUGGING_FACE, huggingFaceChatModel.get());
+            };
         }
     }
 
@@ -335,4 +430,97 @@ public void onEmbeddingsParametersChange(Runnable runnable) {
             }
         });
     }
+
+    public void listenToChatModels(Runnable runnable) {
+        openAiChatModel.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+
+        mistralAiChatModel.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+
+        huggingFaceChatModel.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+    }
+
+    public void listenToApiTokens(Runnable runnable) {
+        openAiApiToken.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+
+        mistralAiApiToken.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+
+        huggingFaceApiToken.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+    }
+
+    public void listenToApiBaseUrls(Runnable runnable) {
+        openAiApiBaseUrl.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+
+        mistralAiApiBaseUrl.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+
+        huggingFaceApiBaseUrl.addListener((observableValue, oldValue, newValue) -> {
+            if (!newValue.equals(oldValue)) {
+                runnable.run();
+            }
+        });
+    }
+
+    public String getSelectedChatModel() {
+        return switch (aiProvider.get()) {
+            case OPEN_AI ->
+                    openAiChatModel.get();
+            case MISTRAL_AI ->
+                    mistralAiChatModel.get();
+            case HUGGING_FACE ->
+                    huggingFaceChatModel.get();
+        };
+    }
+
+    public String getSelectedApiToken() {
+        return switch (aiProvider.get()) {
+            case OPEN_AI ->
+                    openAiApiToken.get();
+            case MISTRAL_AI ->
+                    mistralAiApiToken.get();
+            case HUGGING_FACE ->
+                    huggingFaceApiToken.get();
+        };
+    }
+
+    public String getSelectedApiBaseUrl() {
+        return switch (aiProvider.get()) {
+            case OPEN_AI ->
+                    openAiApiBaseUrl.get();
+            case MISTRAL_AI ->
+                    mistralAiApiBaseUrl.get();
+            case HUGGING_FACE ->
+                    huggingFaceApiBaseUrl.get();
+        };
+    }
 }
diff --git a/src/main/java/org/jabref/preferences/JabRefPreferences.java b/src/main/java/org/jabref/preferences/JabRefPreferences.java
index 1165c6f9211..e67ec432dee 100644
--- a/src/main/java/org/jabref/preferences/JabRefPreferences.java
+++ b/src/main/java/org/jabref/preferences/JabRefPreferences.java
@@ -467,10 +467,14 @@ public class JabRefPreferences implements PreferencesService {
 
     private static final String AI_ENABLED = "aiEnabled";
     private static final String AI_PROVIDER = "aiProvider";
-    private static final String AI_CHAT_MODEL = "aiChatModel";
+    private static final String AI_OPEN_AI_CHAT_MODEL = "aiOpenAiChatModel";
+    private static final String AI_MISTRAL_AI_CHAT_MODEL = "aiMistralAiChatModel";
+    private static final String AI_HUGGING_FACE_CHAT_MODEL = "aiHuggingFaceChatModel";
     private static final String AI_CUSTOMIZE_SETTINGS = "aiCustomizeSettings";
     private static final String AI_EMBEDDING_MODEL = "aiEmbeddingModel";
-    private static final String AI_API_BASE_URL = "aiApiBaseUrl";
+    private static final String AI_OPEN_AI_API_BASE_URL = "aiOpenAiApiBaseUrl";
+    private static final String AI_MISTRAL_AI_API_BASE_URL = "aiMistralAiApiBaseUrl";
+    private static final String AI_HUGGING_FACE_API_BASE_URL = "aiHuggingFaceApiBaseUrl";
     private static final String AI_SYSTEM_MESSAGE = "aiSystemMessage";
     private static final String AI_TEMPERATURE = "aiTemperature";
     private static final String AI_CONTEXT_WINDOW_SIZE = "aiMessageWindowSize";
@@ -887,13 +891,17 @@ private JabRefPreferences() {
         // region:AI
         defaults.put(AI_ENABLED, AiDefaultPreferences.ENABLE_CHAT);
         defaults.put(AI_PROVIDER, AiDefaultPreferences.PROVIDER.name());
-        defaults.put(AI_CHAT_MODEL, AiDefaultPreferences.CHAT_MODEL);
+        defaults.put(AI_OPEN_AI_CHAT_MODEL, AiDefaultPreferences.CHAT_MODELS.get(AiPreferences.AiProvider.OPEN_AI));
+        defaults.put(AI_MISTRAL_AI_CHAT_MODEL, AiDefaultPreferences.CHAT_MODELS.get(AiPreferences.AiProvider.MISTRAL_AI));
+        defaults.put(AI_HUGGING_FACE_CHAT_MODEL, AiDefaultPreferences.CHAT_MODELS.get(AiPreferences.AiProvider.HUGGING_FACE));
         defaults.put(AI_CUSTOMIZE_SETTINGS, AiDefaultPreferences.CUSTOMIZE_SETTINGS);
         defaults.put(AI_EMBEDDING_MODEL, AiDefaultPreferences.EMBEDDING_MODEL.name());
-        defaults.put(AI_API_BASE_URL, AiDefaultPreferences.PROVIDERS_API_URLS.get(AiDefaultPreferences.PROVIDER));
+        defaults.put(AI_OPEN_AI_API_BASE_URL, AiDefaultPreferences.PROVIDERS_API_URLS.get(AiPreferences.AiProvider.OPEN_AI));
+        defaults.put(AI_MISTRAL_AI_API_BASE_URL, AiDefaultPreferences.PROVIDERS_API_URLS.get(AiPreferences.AiProvider.MISTRAL_AI));
+        defaults.put(AI_HUGGING_FACE_API_BASE_URL, AiDefaultPreferences.PROVIDERS_API_URLS.get(AiPreferences.AiProvider.HUGGING_FACE));
         defaults.put(AI_SYSTEM_MESSAGE, AiDefaultPreferences.SYSTEM_MESSAGE);
         defaults.put(AI_TEMPERATURE, AiDefaultPreferences.TEMPERATURE);
-        defaults.put(AI_CONTEXT_WINDOW_SIZE, AiDefaultPreferences.CONTEXT_WINDOW_SIZES.get(AiDefaultPreferences.PROVIDER).get(AiDefaultPreferences.CHAT_MODEL));
+        defaults.put(AI_CONTEXT_WINDOW_SIZE, AiDefaultPreferences.CONTEXT_WINDOW_SIZES.get(AiDefaultPreferences.PROVIDER).get(AiDefaultPreferences.CHAT_MODELS.get(AiDefaultPreferences.PROVIDER)));
         defaults.put(AI_DOCUMENT_SPLITTER_CHUNK_SIZE, AiDefaultPreferences.DOCUMENT_SPLITTER_CHUNK_SIZE);
         defaults.put(AI_DOCUMENT_SPLITTER_OVERLAP_SIZE, AiDefaultPreferences.DOCUMENT_SPLITTER_OVERLAP);
         defaults.put(AI_RAG_MAX_RESULTS_COUNT, AiDefaultPreferences.RAG_MAX_RESULTS_COUNT);
@@ -2779,10 +2787,16 @@ public AiPreferences getAiPreferences() {
         aiPreferences = new AiPreferences(
                 getBoolean(AI_ENABLED),
                 AiPreferences.AiProvider.valueOf(get(AI_PROVIDER)),
-                get(AI_CHAT_MODEL),
-                getAiApiTokenFromKeyring().orElse(""),
+                get(AI_OPEN_AI_CHAT_MODEL),
+                get(AI_MISTRAL_AI_CHAT_MODEL),
+                get(AI_HUGGING_FACE_CHAT_MODEL),
+                getApiKeyForAiProvider(AiPreferences.AiProvider.OPEN_AI).orElse(""),
+                getApiKeyForAiProvider(AiPreferences.AiProvider.MISTRAL_AI).orElse(""),
+                getApiKeyForAiProvider(AiPreferences.AiProvider.HUGGING_FACE).orElse(""),
                 getBoolean(AI_CUSTOMIZE_SETTINGS),
-                get(AI_API_BASE_URL),
+                get(AI_OPEN_AI_API_BASE_URL),
+                get(AI_MISTRAL_AI_API_BASE_URL),
+                get(AI_HUGGING_FACE_API_BASE_URL),
                 AiPreferences.EmbeddingModel.valueOf(get(AI_EMBEDDING_MODEL)),
                 get(AI_SYSTEM_MESSAGE),
                 getDouble(AI_TEMPERATURE),
@@ -2795,12 +2809,21 @@ public AiPreferences getAiPreferences() {
         EasyBind.listen(aiPreferences.enableAiProperty(), (obs, oldValue, newValue) -> putBoolean(AI_ENABLED, newValue));
 
         EasyBind.listen(aiPreferences.aiProviderProperty(), (obs, oldValue, newValue) -> put(AI_PROVIDER, newValue.name()));
-        EasyBind.listen(aiPreferences.chatModelProperty(), (obs, oldValue, newValue) -> put(AI_CHAT_MODEL, newValue));
-        EasyBind.listen(aiPreferences.apiTokenProperty(), (obs, oldValue, newValue) -> storeAiApiTokenInKeyring(newValue));
+
+        EasyBind.listen(aiPreferences.openAiChatModelProperty(), (obs, oldValue, newValue) -> put(AI_OPEN_AI_CHAT_MODEL, newValue));
+        EasyBind.listen(aiPreferences.mistralAiChatModelProperty(), (obs, oldValue, newValue) -> put(AI_MISTRAL_AI_CHAT_MODEL, newValue));
+        EasyBind.listen(aiPreferences.huggingFaceChatModelProperty(), (obs, oldValue, newValue) -> put(AI_HUGGING_FACE_CHAT_MODEL, newValue));
+
+        EasyBind.listen(aiPreferences.openAiApiTokenProperty(), (obs, oldValue, newValue) -> storeAiApiTokenInKeyring(AiPreferences.AiProvider.OPEN_AI, newValue));
+        EasyBind.listen(aiPreferences.mistralAiApiTokenProperty(), (obs, oldValue, newValue) -> storeAiApiTokenInKeyring(AiPreferences.AiProvider.MISTRAL_AI, newValue));
+        EasyBind.listen(aiPreferences.huggingFaceApiTokenProperty(), (obs, oldValue, newValue) -> storeAiApiTokenInKeyring(AiPreferences.AiProvider.HUGGING_FACE, newValue));
 
         EasyBind.listen(aiPreferences.customizeExpertSettingsProperty(), (obs, oldValue, newValue) -> putBoolean(AI_CUSTOMIZE_SETTINGS, newValue));
 
-        EasyBind.listen(aiPreferences.apiBaseUrlProperty(), (obs, oldValue, newValue) -> put(AI_API_BASE_URL, newValue));
+        EasyBind.listen(aiPreferences.openAiApiBaseUrlProperty(), (obs, oldValue, newValue) -> put(AI_OPEN_AI_API_BASE_URL, newValue));
+        EasyBind.listen(aiPreferences.mistralAiApiBaseUrlProperty(), (obs, oldValue, newValue) -> put(AI_MISTRAL_AI_API_BASE_URL, newValue));
+        EasyBind.listen(aiPreferences.huggingFaceApiBaseUrlProperty(), (obs, oldValue, newValue) -> put(AI_HUGGING_FACE_API_BASE_URL, newValue));
+
         EasyBind.listen(aiPreferences.embeddingModelProperty(), (obs, oldValue, newValue) -> put(AI_EMBEDDING_MODEL, newValue.name()));
         EasyBind.listen(aiPreferences.instructionProperty(), (obs, oldValue, newValue) -> put(AI_SYSTEM_MESSAGE, newValue));
         EasyBind.listen(aiPreferences.temperatureProperty(), (obs, oldValue, newValue) -> putDouble(AI_TEMPERATURE, (double) newValue));
@@ -2813,9 +2836,25 @@ public AiPreferences getAiPreferences() {
         return aiPreferences;
     }
 
-    private Optional<String> getAiApiTokenFromKeyring() {
+    private String determineSelectedChatModel(AiPreferences aiPreferences) {
+        return switch (aiPreferences.getAiProvider()) {
+            case OPEN_AI -> AI_OPEN_AI_CHAT_MODEL;
+            case MISTRAL_AI -> AI_MISTRAL_AI_CHAT_MODEL;
+            case HUGGING_FACE -> AI_HUGGING_FACE_CHAT_MODEL;
+        };
+    }
+
+    private String determineSelectedApiBaseUrl(AiPreferences aiPreferences) {
+        return switch (aiPreferences.getAiProvider()) {
+            case OPEN_AI -> AI_OPEN_AI_API_BASE_URL;
+            case MISTRAL_AI -> AI_MISTRAL_AI_API_BASE_URL;
+            case HUGGING_FACE -> AI_HUGGING_FACE_API_BASE_URL;
+        };
+    }
+
+    public Optional<String> getApiKeyForAiProvider(AiPreferences.AiProvider aiProvider) {
         try (final Keyring keyring = Keyring.create()) {
-            String rawPassword = keyring.getPassword(KEYRING_AI_SERVICE, KEYRING_AI_SERVICE_ACCOUNT);
+            String rawPassword = keyring.getPassword(KEYRING_AI_SERVICE, KEYRING_AI_SERVICE_ACCOUNT + "-" + aiProvider.name());
             Password password = new Password(rawPassword, getInternalPreferences().getUserAndHost());
             return Optional.of(password.decrypt());
         } catch (Exception e) {
@@ -2824,11 +2863,11 @@ private Optional<String> getAiApiTokenFromKeyring() {
         }
     }
 
-    private void storeAiApiTokenInKeyring(String newToken) {
+    private void storeAiApiTokenInKeyring(AiPreferences.AiProvider aiProvider, String newToken) {
         try (final Keyring keyring = Keyring.create()) {
             Password password = new Password(newToken, getInternalPreferences().getUserAndHost());
             String rawPassword = password.encrypt();
-            keyring.setPassword(KEYRING_AI_SERVICE, KEYRING_AI_SERVICE_ACCOUNT, rawPassword);
+            keyring.setPassword(KEYRING_AI_SERVICE, KEYRING_AI_SERVICE_ACCOUNT + "-" + aiProvider.name(), rawPassword);
         } catch (Exception e) {
             LOGGER.warn("JabRef could not open keyring for retrieving OpenAI API token", e);
         }
diff --git a/src/main/java/org/jabref/preferences/PreferencesService.java b/src/main/java/org/jabref/preferences/PreferencesService.java
index 44c449d010d..408c6298499 100644
--- a/src/main/java/org/jabref/preferences/PreferencesService.java
+++ b/src/main/java/org/jabref/preferences/PreferencesService.java
@@ -2,6 +2,7 @@
 
 import java.nio.file.Path;
 import java.util.Map;
+import java.util.Optional;
 import java.util.prefs.BackingStoreException;
 
 import org.jabref.gui.autocompleter.AutoCompletePreferences;
@@ -151,4 +152,6 @@ public interface PreferencesService {
     UnlinkedFilesDialogPreferences getUnlinkedFilesDialogPreferences();
 
     AiPreferences getAiPreferences();
+
+    Optional<String> getApiKeyForAiProvider(AiPreferences.AiProvider provider);
 }