repo: organize sources, headers, and deps into subdirectories (#2917)

Signed-off-by: Jared Van Bortel <jared@nomic.ai>

gpt4all-chat/src/CMakeLists.txt

@@ -0,0 +1,72 @@
+set_source_files_properties("${GGML_METALLIB}" PROPERTIES GENERATED ON)
+
+qt_add_executable(chat
+    main.cpp
+    chat.cpp chat.h
+    chatapi.cpp chatapi.h
+    chatlistmodel.cpp chatlistmodel.h
+    chatllm.cpp chatllm.h
+    chatmodel.h
+    chatviewtextprocessor.cpp chatviewtextprocessor.h
+    database.cpp database.h
+    download.cpp download.h
+    embllm.cpp embllm.h
+    llm.cpp llm.h
+    localdocs.cpp localdocs.h
+    localdocsmodel.cpp localdocsmodel.h
+    logger.cpp logger.h
+    modellist.cpp modellist.h
+    mysettings.cpp mysettings.h
+    network.cpp network.h
+    server.cpp server.h
+)
+
+qt_add_qml_module(chat
+    URI gpt4all
+    VERSION 1.0
+    NO_CACHEGEN
+    QML_FILES
+      main.qml
+      qml/AddCollectionView.qml
+      qml/AddModelView.qml
+      qml/ApplicationSettings.qml
+      qml/ChatDrawer.qml
+      qml/ChatView.qml
+      qml/CollectionsDrawer.qml
+      qml/HomeView.qml
+      qml/LocalDocsSettings.qml
+      qml/LocalDocsView.qml
+      qml/ModelSettings.qml
+      qml/ModelsView.qml
+      qml/NetworkDialog.qml
+      qml/NewVersionDialog.qml
+      qml/PopupDialog.qml
+      qml/SettingsView.qml
+      qml/StartupDialog.qml
+      qml/SwitchModelDialog.qml
+      qml/Theme.qml
+      qml/ThumbsDownDialog.qml
+      qml/Toast.qml
+      qml/ToastManager.qml
+      qml/MyBusyIndicator.qml
+      qml/MyButton.qml
+      qml/MyCheckBox.qml
+      qml/MyComboBox.qml
+      qml/MyDialog.qml
+      qml/MyDirectoryField.qml
+      qml/MyFancyLink.qml
+      qml/MyMenu.qml
+      qml/MyMenuItem.qml
+      qml/MyMiniButton.qml
+      qml/MySettingsButton.qml
+      qml/MySettingsDestructiveButton.qml
+      qml/MySettingsLabel.qml
+      qml/MySettingsStack.qml
+      qml/MySettingsTab.qml
+      qml/MySlug.qml
+      qml/MyTextArea.qml
+      qml/MyTextButton.qml
+      qml/MyTextField.qml
+      qml/MyToolButton.qml
+      qml/MyWelcomeButton.qml
+)

gpt4all-chat/src/chat.cpp

@@ -0,0 +1,476 @@
+#include "chat.h"
+
+#include "chatlistmodel.h"
+#include "mysettings.h"
+#include "network.h"
+#include "server.h"
+
+#include <QDataStream>
+#include <QDateTime>
+#include <QDebug>
+#include <QLatin1String>
+#include <QMap>
+#include <QString>
+#include <QStringList>
+#include <QTextStream>
+#include <Qt>
+#include <QtGlobal>
+#include <QtLogging>
+
+#include <utility>
+
+Chat::Chat(QObject *parent)
+    : QObject(parent)
+    , m_id(Network::globalInstance()->generateUniqueId())
+    , m_name(tr("New Chat"))
+    , m_chatModel(new ChatModel(this))
+    , m_responseState(Chat::ResponseStopped)
+    , m_creationDate(QDateTime::currentSecsSinceEpoch())
+    , m_llmodel(new ChatLLM(this))
+    , m_collectionModel(new LocalDocsCollectionsModel(this))
+{
+    connectLLM();
+}
+
+Chat::Chat(bool isServer, QObject *parent)
+    : QObject(parent)
+    , m_id(Network::globalInstance()->generateUniqueId())
+    , m_name(tr("Server Chat"))
+    , m_chatModel(new ChatModel(this))
+    , m_responseState(Chat::ResponseStopped)
+    , m_creationDate(QDateTime::currentSecsSinceEpoch())
+    , m_llmodel(new Server(this))
+    , m_isServer(true)
+    , m_collectionModel(new LocalDocsCollectionsModel(this))
+{
+    connectLLM();
+}
+
+Chat::~Chat()
+{
+    delete m_llmodel;
+    m_llmodel = nullptr;
+}
+
+void Chat::connectLLM()
+{
+    // Should be in different threads
+    connect(m_llmodel, &ChatLLM::modelLoadingPercentageChanged, this, &Chat::handleModelLoadingPercentageChanged, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::responseChanged, this, &Chat::handleResponseChanged, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::promptProcessing, this, &Chat::promptProcessing, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::generatingQuestions, this, &Chat::generatingQuestions, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::responseStopped, this, &Chat::responseStopped, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::modelLoadingError, this, &Chat::handleModelLoadingError, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::modelLoadingWarning, this, &Chat::modelLoadingWarning, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::restoringFromTextChanged, this, &Chat::handleRestoringFromText, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::generatedNameChanged, this, &Chat::generatedNameChanged, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::generatedQuestionFinished, this, &Chat::generatedQuestionFinished, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::reportSpeed, this, &Chat::handleTokenSpeedChanged, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::loadedModelInfoChanged, this, &Chat::loadedModelInfoChanged, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::databaseResultsChanged, this, &Chat::handleDatabaseResultsChanged, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::modelInfoChanged, this, &Chat::handleModelInfoChanged, Qt::QueuedConnection);
+    connect(m_llmodel, &ChatLLM::trySwitchContextOfLoadedModelCompleted, this, &Chat::handleTrySwitchContextOfLoadedModelCompleted, Qt::QueuedConnection);
+
+    connect(this, &Chat::promptRequested, m_llmodel, &ChatLLM::prompt, Qt::QueuedConnection);
+    connect(this, &Chat::modelChangeRequested, m_llmodel, &ChatLLM::modelChangeRequested, Qt::QueuedConnection);
+    connect(this, &Chat::loadDefaultModelRequested, m_llmodel, &ChatLLM::loadDefaultModel, Qt::QueuedConnection);
+    connect(this, &Chat::loadModelRequested, m_llmodel, &ChatLLM::loadModel, Qt::QueuedConnection);
+    connect(this, &Chat::generateNameRequested, m_llmodel, &ChatLLM::generateName, Qt::QueuedConnection);
+    connect(this, &Chat::regenerateResponseRequested, m_llmodel, &ChatLLM::regenerateResponse, Qt::QueuedConnection);
+    connect(this, &Chat::resetResponseRequested, m_llmodel, &ChatLLM::resetResponse, Qt::QueuedConnection);
+    connect(this, &Chat::resetContextRequested, m_llmodel, &ChatLLM::resetContext, Qt::QueuedConnection);
+    connect(this, &Chat::processSystemPromptRequested, m_llmodel, &ChatLLM::processSystemPrompt, Qt::QueuedConnection);
+
+    connect(this, &Chat::collectionListChanged, m_collectionModel, &LocalDocsCollectionsModel::setCollections);
+}
+
+void Chat::reset()
+{
+    stopGenerating();
+    // Erase our current on disk representation as we're completely resetting the chat along with id
+    ChatListModel::globalInstance()->removeChatFile(this);
+    emit resetContextRequested();
+    m_id = Network::globalInstance()->generateUniqueId();
+    emit idChanged(m_id);
+    // NOTE: We deliberately do no reset the name or creation date to indicate that this was originally
+    // an older chat that was reset for another purpose. Resetting this data will lead to the chat
+    // name label changing back to 'New Chat' and showing up in the chat model list as a 'New Chat'
+    // further down in the list. This might surprise the user. In the future, we might get rid of
+    // the "reset context" button in the UI. Right now, by changing the model in the combobox dropdown
+    // we effectively do a reset context. We *have* to do this right now when switching between different
+    // types of models. The only way to get rid of that would be a very long recalculate where we rebuild
+    // the context if we switch between different types of models. Probably the right way to fix this
+    // is to allow switching models but throwing up a dialog warning users if we switch between types
+    // of models that a long recalculation will ensue.
+    m_chatModel->clear();
+}
+
+void Chat::processSystemPrompt()
+{
+    emit processSystemPromptRequested();
+}
+
+void Chat::resetResponseState()
+{
+    if (m_responseInProgress && m_responseState == Chat::LocalDocsRetrieval)
+        return;
+
+    m_generatedQuestions = QList<QString>();
+    emit generatedQuestionsChanged();
+    m_tokenSpeed = QString();
+    emit tokenSpeedChanged();
+    m_responseInProgress = true;
+    m_responseState = m_collections.empty() ? Chat::PromptProcessing : Chat::LocalDocsRetrieval;
+    emit responseInProgressChanged();
+    emit responseStateChanged();
+}
+
+void Chat::prompt(const QString &prompt)
+{
+    resetResponseState();
+    emit promptRequested(m_collections, prompt);
+}
+
+void Chat::regenerateResponse()
+{
+    const int index = m_chatModel->count() - 1;
+    m_chatModel->updateSources(index, QList<ResultInfo>());
+    emit regenerateResponseRequested();
+}
+
+void Chat::stopGenerating()
+{
+    m_llmodel->stopGenerating();
+}
+
+QString Chat::response() const
+{
+    return m_response;
+}
+
+Chat::ResponseState Chat::responseState() const
+{
+    return m_responseState;
+}
+
+void Chat::handleResponseChanged(const QString &response)
+{
+    if (m_responseState != Chat::ResponseGeneration) {
+        m_responseState = Chat::ResponseGeneration;
+        emit responseStateChanged();
+    }
+
+    m_response = response;
+    const int index = m_chatModel->count() - 1;
+    m_chatModel->updateValue(index, this->response());
+    emit responseChanged();
+}
+
+void Chat::handleModelLoadingPercentageChanged(float loadingPercentage)
+{
+    if (m_shouldDeleteLater)
+        deleteLater();
+
+    if (loadingPercentage == m_modelLoadingPercentage)
+        return;
+
+    bool wasLoading = isCurrentlyLoading();
+    bool wasLoaded = isModelLoaded();
+
+    m_modelLoadingPercentage = loadingPercentage;
+    emit modelLoadingPercentageChanged();
+
+    if (isCurrentlyLoading() != wasLoading)
+        emit isCurrentlyLoadingChanged();
+
+    if (isModelLoaded() != wasLoaded)
+        emit isModelLoadedChanged();
+}
+
+void Chat::promptProcessing()
+{
+    m_responseState = !databaseResults().isEmpty() ? Chat::LocalDocsProcessing : Chat::PromptProcessing;
+     emit responseStateChanged();
+}
+
+void Chat::generatingQuestions()
+{
+    m_responseState = Chat::GeneratingQuestions;
+    emit responseStateChanged();
+}
+
+void Chat::responseStopped(qint64 promptResponseMs)
+{
+    m_tokenSpeed = QString();
+    emit tokenSpeedChanged();
+    emit responseChanged();
+
+    m_responseInProgress = false;
+    m_responseState = Chat::ResponseStopped;
+    emit responseInProgressChanged();
+    emit responseStateChanged();
+    if (m_generatedName.isEmpty())
+        emit generateNameRequested();
+
+    Network::globalInstance()->trackChatEvent("response_complete", {
+        {"first", m_firstResponse},
+        {"message_count", chatModel()->count()},
+        {"$duration", promptResponseMs / 1000.},
+    });
+    m_firstResponse = false;
+}
+
+ModelInfo Chat::modelInfo() const
+{
+    return m_modelInfo;
+}
+
+void Chat::setModelInfo(const ModelInfo &modelInfo)
+{
+    if (m_modelInfo == modelInfo && isModelLoaded())
+        return;
+
+    m_modelInfo = modelInfo;
+    emit modelInfoChanged();
+    emit modelChangeRequested(modelInfo);
+}
+
+void Chat::newPromptResponsePair(const QString &prompt)
+{
+    resetResponseState();
+    m_chatModel->updateCurrentResponse(m_chatModel->count() - 1, false);
+    m_chatModel->appendPrompt("Prompt: ", prompt);
+    m_chatModel->appendResponse("Response: ", prompt);
+    emit resetResponseRequested();
+}
+
+void Chat::serverNewPromptResponsePair(const QString &prompt)
+{
+    resetResponseState();
+    m_chatModel->updateCurrentResponse(m_chatModel->count() - 1, false);
+    m_chatModel->appendPrompt("Prompt: ", prompt);
+    m_chatModel->appendResponse("Response: ", prompt);
+}
+
+bool Chat::restoringFromText() const
+{
+    return m_llmodel->restoringFromText();
+}
+
+void Chat::unloadAndDeleteLater()
+{
+    if (!isModelLoaded()) {
+        deleteLater();
+        return;
+    }
+
+    m_shouldDeleteLater = true;
+    unloadModel();
+}
+
+void Chat::markForDeletion()
+{
+    m_llmodel->setMarkedForDeletion(true);
+}
+
+void Chat::unloadModel()
+{
+    stopGenerating();
+    m_llmodel->setShouldBeLoaded(false);
+}
+
+void Chat::reloadModel()
+{
+    m_llmodel->setShouldBeLoaded(true);
+}
+
+void Chat::forceUnloadModel()
+{
+    stopGenerating();
+    m_llmodel->setForceUnloadModel(true);
+    m_llmodel->setShouldBeLoaded(false);
+}
+
+void Chat::forceReloadModel()
+{
+    m_llmodel->setForceUnloadModel(true);
+    m_llmodel->setShouldBeLoaded(true);
+}
+
+void Chat::trySwitchContextOfLoadedModel()
+{
+    m_trySwitchContextInProgress = 1;
+    emit trySwitchContextInProgressChanged();
+    m_llmodel->requestTrySwitchContext();
+}
+
+void Chat::generatedNameChanged(const QString &name)
+{
+    // Only use the first three words maximum and remove newlines and extra spaces
+    m_generatedName = name.simplified();
+    QStringList words = m_generatedName.split(' ', Qt::SkipEmptyParts);
+    int wordCount = qMin(7, words.size());
+    m_name = words.mid(0, wordCount).join(' ');
+    emit nameChanged();
+}
+
+void Chat::generatedQuestionFinished(const QString &question)
+{
+    m_generatedQuestions << question;
+    emit generatedQuestionsChanged();
+}
+
+void Chat::handleRestoringFromText()
+{
+    Network::globalInstance()->trackChatEvent("recalc_context", { {"length", m_chatModel->count()} });
+    emit restoringFromTextChanged();
+}
+
+void Chat::handleModelLoadingError(const QString &error)
+{
+    if (!error.isEmpty()) {
+        auto stream = qWarning().noquote() << "ERROR:" << error << "id";
+        stream.quote() << id();
+    }
+    m_modelLoadingError = error;
+    emit modelLoadingErrorChanged();
+}
+
+void Chat::handleTokenSpeedChanged(const QString &tokenSpeed)
+{
+    m_tokenSpeed = tokenSpeed;
+    emit tokenSpeedChanged();
+}
+
+QString Chat::deviceBackend() const
+{
+    return m_llmodel->deviceBackend();
+}
+
+QString Chat::device() const
+{
+    return m_llmodel->device();
+}
+
+QString Chat::fallbackReason() const
+{
+    return m_llmodel->fallbackReason();
+}
+
+void Chat::handleDatabaseResultsChanged(const QList<ResultInfo> &results)
+{
+    m_databaseResults = results;
+    const int index = m_chatModel->count() - 1;
+    m_chatModel->updateSources(index, m_databaseResults);
+}
+
+void Chat::handleModelInfoChanged(const ModelInfo &modelInfo)
+{
+    if (m_modelInfo == modelInfo)
+        return;
+
+    m_modelInfo = modelInfo;
+    emit modelInfoChanged();
+}
+
+void Chat::handleTrySwitchContextOfLoadedModelCompleted(int value)
+{
+    m_trySwitchContextInProgress = value;
+    emit trySwitchContextInProgressChanged();
+}
+
+bool Chat::serialize(QDataStream &stream, int version) const
+{
+    stream << m_creationDate;
+    stream << m_id;
+    stream << m_name;
+    stream << m_userName;
+    if (version > 4)
+        stream << m_modelInfo.id();
+    else
+        stream << m_modelInfo.filename();
+    if (version > 2)
+        stream << m_collections;
+
+    const bool serializeKV = MySettings::globalInstance()->saveChatsContext();
+    if (version > 5)
+        stream << serializeKV;
+    if (!m_llmodel->serialize(stream, version, serializeKV))
+        return false;
+    if (!m_chatModel->serialize(stream, version))
+        return false;
+    return stream.status() == QDataStream::Ok;
+}
+
+bool Chat::deserialize(QDataStream &stream, int version)
+{
+    stream >> m_creationDate;
+    stream >> m_id;
+    emit idChanged(m_id);
+    stream >> m_name;
+    stream >> m_userName;
+    m_generatedName = QLatin1String("nonempty");
+    emit nameChanged();
+
+    QString modelId;
+    stream >> modelId;
+    if (version > 4) {
+        if (ModelList::globalInstance()->contains(modelId))
+            m_modelInfo = ModelList::globalInstance()->modelInfo(modelId);
+    } else {
+        if (ModelList::globalInstance()->containsByFilename(modelId))
+            m_modelInfo = ModelList::globalInstance()->modelInfoByFilename(modelId);
+    }
+    if (!m_modelInfo.id().isEmpty())
+        emit modelInfoChanged();
+
+    bool discardKV = m_modelInfo.id().isEmpty();
+
+    if (version > 2) {
+        stream >> m_collections;
+        emit collectionListChanged(m_collections);
+    }
+
+    bool deserializeKV = true;
+    if (version > 5)
+        stream >> deserializeKV;
+
+    m_llmodel->setModelInfo(m_modelInfo);
+    if (!m_llmodel->deserialize(stream, version, deserializeKV, discardKV))
+        return false;
+    if (!m_chatModel->deserialize(stream, version))
+        return false;
+
+    m_llmodel->setStateFromText(m_chatModel->text());
+
+    emit chatModelChanged();
+    return stream.status() == QDataStream::Ok;
+}
+
+QList<QString> Chat::collectionList() const
+{
+    return m_collections;
+}
+
+bool Chat::hasCollection(const QString &collection) const
+{
+    return m_collections.contains(collection);
+}
+
+void Chat::addCollection(const QString &collection)
+{
+    if (hasCollection(collection))
+        return;
+
+    m_collections.append(collection);
+    emit collectionListChanged(m_collections);
+}
+
+void Chat::removeCollection(const QString &collection)
+{
+    if (!hasCollection(collection))
+        return;
+
+    m_collections.removeAll(collection);
+    emit collectionListChanged(m_collections);
+}

gpt4all-chat/src/chat.h

@@ -0,0 +1,205 @@
+#ifndef CHAT_H
+#define CHAT_H
+
+#include "chatllm.h"
+#include "chatmodel.h"
+#include "database.h" // IWYU pragma: keep
+#include "localdocsmodel.h" // IWYU pragma: keep
+#include "modellist.h"
+
+#include <QList>
+#include <QObject>
+#include <QQmlEngine>
+#include <QString>
+#include <QtGlobal>
+
+class QDataStream;
+
+class Chat : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString id READ id NOTIFY idChanged)
+    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
+    Q_PROPERTY(ChatModel *chatModel READ chatModel NOTIFY chatModelChanged)
+    Q_PROPERTY(bool isModelLoaded READ isModelLoaded NOTIFY isModelLoadedChanged)
+    Q_PROPERTY(bool isCurrentlyLoading READ isCurrentlyLoading NOTIFY isCurrentlyLoadingChanged)
+    Q_PROPERTY(float modelLoadingPercentage READ modelLoadingPercentage NOTIFY modelLoadingPercentageChanged)
+    Q_PROPERTY(QString response READ response NOTIFY responseChanged)
+    Q_PROPERTY(ModelInfo modelInfo READ modelInfo WRITE setModelInfo NOTIFY modelInfoChanged)
+    Q_PROPERTY(bool responseInProgress READ responseInProgress NOTIFY responseInProgressChanged)
+    Q_PROPERTY(bool restoringFromText READ restoringFromText NOTIFY restoringFromTextChanged)
+    Q_PROPERTY(bool isServer READ isServer NOTIFY isServerChanged)
+    Q_PROPERTY(ResponseState responseState READ responseState NOTIFY responseStateChanged)
+    Q_PROPERTY(QList<QString> collectionList READ collectionList NOTIFY collectionListChanged)
+    Q_PROPERTY(QString modelLoadingError READ modelLoadingError NOTIFY modelLoadingErrorChanged)
+    Q_PROPERTY(QString tokenSpeed READ tokenSpeed NOTIFY tokenSpeedChanged);
+    Q_PROPERTY(QString deviceBackend READ deviceBackend NOTIFY loadedModelInfoChanged)
+    Q_PROPERTY(QString device READ device NOTIFY loadedModelInfoChanged)
+    Q_PROPERTY(QString fallbackReason READ fallbackReason NOTIFY loadedModelInfoChanged)
+    Q_PROPERTY(LocalDocsCollectionsModel *collectionModel READ collectionModel NOTIFY collectionModelChanged)
+    // 0=no, 1=waiting, 2=working
+    Q_PROPERTY(int trySwitchContextInProgress READ trySwitchContextInProgress NOTIFY trySwitchContextInProgressChanged)
+    Q_PROPERTY(QList<QString> generatedQuestions READ generatedQuestions NOTIFY generatedQuestionsChanged)
+    QML_ELEMENT
+    QML_UNCREATABLE("Only creatable from c++!")
+
+public:
+    enum ResponseState {
+        ResponseStopped,
+        LocalDocsRetrieval,
+        LocalDocsProcessing,
+        PromptProcessing,
+        GeneratingQuestions,
+        ResponseGeneration
+    };
+    Q_ENUM(ResponseState)
+
+    explicit Chat(QObject *parent = nullptr);
+    explicit Chat(bool isServer, QObject *parent = nullptr);
+    virtual ~Chat();
+    void destroy() { m_llmodel->destroy(); }
+    void connectLLM();
+
+    QString id() const { return m_id; }
+    QString name() const { return m_userName.isEmpty() ? m_name : m_userName; }
+    void setName(const QString &name)
+    {
+        m_userName = name;
+        emit nameChanged();
+    }
+    ChatModel *chatModel() { return m_chatModel; }
+
+    bool isNewChat() const { return m_name == tr("New Chat") && !m_chatModel->count(); }
+
+    Q_INVOKABLE void reset();
+    Q_INVOKABLE void processSystemPrompt();
+    bool  isModelLoaded()          const { return m_modelLoadingPercentage == 1.0f; }
+    bool  isCurrentlyLoading()     const { return m_modelLoadingPercentage > 0.0f && m_modelLoadingPercentage < 1.0f; }
+    float modelLoadingPercentage() const { return m_modelLoadingPercentage; }
+    Q_INVOKABLE void prompt(const QString &prompt);
+    Q_INVOKABLE void regenerateResponse();
+    Q_INVOKABLE void stopGenerating();
+    Q_INVOKABLE void newPromptResponsePair(const QString &prompt);
+
+    QList<ResultInfo> databaseResults() const { return m_databaseResults; }
+
+    QString response() const;
+    bool responseInProgress() const { return m_responseInProgress; }
+    ResponseState responseState() const;
+    ModelInfo modelInfo() const;
+    void setModelInfo(const ModelInfo &modelInfo);
+    bool restoringFromText() const;
+
+    Q_INVOKABLE void unloadModel();
+    Q_INVOKABLE void reloadModel();
+    Q_INVOKABLE void forceUnloadModel();
+    Q_INVOKABLE void forceReloadModel();
+    Q_INVOKABLE void trySwitchContextOfLoadedModel();
+    void unloadAndDeleteLater();
+    void markForDeletion();
+
+    QDateTime creationDate() const { return QDateTime::fromSecsSinceEpoch(m_creationDate); }
+    bool serialize(QDataStream &stream, int version) const;
+    bool deserialize(QDataStream &stream, int version);
+    bool isServer() const { return m_isServer; }
+
+    QList<QString> collectionList() const;
+    LocalDocsCollectionsModel *collectionModel() const { return m_collectionModel; }
+
+    Q_INVOKABLE bool hasCollection(const QString &collection) const;
+    Q_INVOKABLE void addCollection(const QString &collection);
+    Q_INVOKABLE void removeCollection(const QString &collection);
+    void resetResponseState();
+
+    QString modelLoadingError() const { return m_modelLoadingError; }
+
+    QString tokenSpeed() const { return m_tokenSpeed; }
+    QString deviceBackend() const;
+    QString device() const;
+    // not loaded -> QString(), no fallback -> QString("")
+    QString fallbackReason() const;
+
+    int trySwitchContextInProgress() const { return m_trySwitchContextInProgress; }
+
+    QList<QString> generatedQuestions() const { return m_generatedQuestions; }
+
+public Q_SLOTS:
+    void serverNewPromptResponsePair(const QString &prompt);
+
+Q_SIGNALS:
+    void idChanged(const QString &id);
+    void nameChanged();
+    void chatModelChanged();
+    void isModelLoadedChanged();
+    void isCurrentlyLoadingChanged();
+    void modelLoadingPercentageChanged();
+    void modelLoadingWarning(const QString &warning);
+    void responseChanged();
+    void responseInProgressChanged();
+    void responseStateChanged();
+    void promptRequested(const QList<QString> &collectionList, const QString &prompt);
+    void regenerateResponseRequested();
+    void resetResponseRequested();
+    void resetContextRequested();
+    void processSystemPromptRequested();
+    void modelChangeRequested(const ModelInfo &modelInfo);
+    void modelInfoChanged();
+    void restoringFromTextChanged();
+    void loadDefaultModelRequested();
+    void loadModelRequested(const ModelInfo &modelInfo);
+    void generateNameRequested();
+    void modelLoadingErrorChanged();
+    void isServerChanged();
+    void collectionListChanged(const QList<QString> &collectionList);
+    void tokenSpeedChanged();
+    void deviceChanged();
+    void fallbackReasonChanged();
+    void collectionModelChanged();
+    void trySwitchContextInProgressChanged();
+    void loadedModelInfoChanged();
+    void generatedQuestionsChanged();
+
+private Q_SLOTS:
+    void handleResponseChanged(const QString &response);
+    void handleModelLoadingPercentageChanged(float);
+    void promptProcessing();
+    void generatingQuestions();
+    void responseStopped(qint64 promptResponseMs);
+    void generatedNameChanged(const QString &name);
+    void generatedQuestionFinished(const QString &question);
+    void handleRestoringFromText();
+    void handleModelLoadingError(const QString &error);
+    void handleTokenSpeedChanged(const QString &tokenSpeed);
+    void handleDatabaseResultsChanged(const QList<ResultInfo> &results);
+    void handleModelInfoChanged(const ModelInfo &modelInfo);
+    void handleTrySwitchContextOfLoadedModelCompleted(int value);
+
+private:
+    QString m_id;
+    QString m_name;
+    QString m_generatedName;
+    QString m_userName;
+    ModelInfo m_modelInfo;
+    QString m_modelLoadingError;
+    QString m_tokenSpeed;
+    QString m_device;
+    QString m_fallbackReason;
+    QString m_response;
+    QList<QString> m_collections;
+    QList<QString> m_generatedQuestions;
+    ChatModel *m_chatModel;
+    bool m_responseInProgress = false;
+    ResponseState m_responseState;
+    qint64 m_creationDate;
+    ChatLLM *m_llmodel;
+    QList<ResultInfo> m_databaseResults;
+    bool m_isServer = false;
+    bool m_shouldDeleteLater = false;
+    float m_modelLoadingPercentage = 0.0f;
+    LocalDocsCollectionsModel *m_collectionModel;
+    bool m_firstResponse = true;
+    int m_trySwitchContextInProgress = 0;
+    bool m_isCurrentlyLoading = false;
+};
+
+#endif // CHAT_H

gpt4all-chat/src/chatapi.cpp

@@ -0,0 +1,326 @@
+#include "chatapi.h"
+
+#include <gpt4all-backend/llmodel.h>
+
+#include <QCoreApplication>
+#include <QGuiApplication>
+#include <QDebug>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QNetworkAccessManager>
+#include <QNetworkRequest>
+#include <QThread>
+#include <QUrl>
+#include <QVariant>
+#include <Qt>
+#include <QtGlobal>
+#include <QtLogging>
+
+#include <iostream>
+
+using namespace Qt::Literals::StringLiterals;
+
+//#define DEBUG
+
+ChatAPI::ChatAPI()
+    : QObject(nullptr)
+    , m_modelName("gpt-3.5-turbo")
+    , m_requestURL("")
+    , m_responseCallback(nullptr)
+{
+}
+
+size_t ChatAPI::requiredMem(const std::string &modelPath, int n_ctx, int ngl)
+{
+    Q_UNUSED(modelPath);
+    Q_UNUSED(n_ctx);
+    Q_UNUSED(ngl);
+    return 0;
+}
+
+bool ChatAPI::loadModel(const std::string &modelPath, int n_ctx, int ngl)
+{
+    Q_UNUSED(modelPath);
+    Q_UNUSED(n_ctx);
+    Q_UNUSED(ngl);
+    return true;
+}
+
+void ChatAPI::setThreadCount(int32_t n_threads)
+{
+    Q_UNUSED(n_threads);
+    qt_noop();
+}
+
+int32_t ChatAPI::threadCount() const
+{
+    return 1;
+}
+
+ChatAPI::~ChatAPI()
+{
+}
+
+bool ChatAPI::isModelLoaded() const
+{
+    return true;
+}
+
+// All three of the state virtual functions are handled custom inside of chatllm save/restore
+size_t ChatAPI::stateSize() const
+{
+    return 0;
+}
+
+size_t ChatAPI::saveState(uint8_t *dest) const
+{
+    Q_UNUSED(dest);
+    return 0;
+}
+
+size_t ChatAPI::restoreState(const uint8_t *src)
+{
+    Q_UNUSED(src);
+    return 0;
+}
+
+void ChatAPI::prompt(const std::string &prompt,
+                     const std::string &promptTemplate,
+                     std::function<bool(int32_t)> promptCallback,
+                     std::function<bool(int32_t, const std::string&)> responseCallback,
+                     bool allowContextShift,
+                     PromptContext &promptCtx,
+                     bool special,
+                     std::string *fakeReply) {
+
+    Q_UNUSED(promptCallback);
+    Q_UNUSED(allowContextShift);
+    Q_UNUSED(special);
+
+    if (!isModelLoaded()) {
+        std::cerr << "ChatAPI ERROR: prompt won't work with an unloaded model!\n";
+        return;
+    }
+
+    if (!promptCtx.n_past) { m_queuedPrompts.clear(); }
+    Q_ASSERT(promptCtx.n_past <= m_context.size());
+    m_context.resize(promptCtx.n_past);
+
+    // FIXME(cebtenzzre): We're assuming people don't try to use %2 with ChatGPT. What would that even mean?
+    m_queuedPrompts << QString::fromStdString(promptTemplate).arg(QString::fromStdString(prompt));
+
+    if (!promptCtx.n_predict && !fakeReply) {
+        return; // response explicitly suppressed, queue prompt for later
+    }
+
+    QString formattedPrompt = m_queuedPrompts.join("");
+    m_queuedPrompts.clear();
+
+    if (fakeReply) {
+        promptCtx.n_past += 1;
+        m_context.append(formattedPrompt);
+        m_context.append(QString::fromStdString(*fakeReply));
+        return;
+    }
+
+    // FIXME: We don't set the max_tokens on purpose because in order to do so safely without encountering
+    // an error we need to be able to count the tokens in our prompt. The only way to do this is to use
+    // the OpenAI tiktokken library or to implement our own tokenization function that matches precisely
+    // the tokenization used by the OpenAI model we're calling. OpenAI has not introduced any means of
+    // using the REST API to count tokens in a prompt.
+    QJsonObject root;
+    root.insert("model", m_modelName);
+    root.insert("stream", true);
+    root.insert("temperature", promptCtx.temp);
+    root.insert("top_p", promptCtx.top_p);
+
+    // conversation history
+    QJsonArray messages;
+    for (int i = 0; i < m_context.count(); ++i) {
+        QJsonObject message;
+        message.insert("role", i % 2 == 0 ? "user" : "assistant");
+        message.insert("content", m_context.at(i));
+        messages.append(message);
+    }
+
+    QJsonObject promptObject;
+    promptObject.insert("role", "user");
+    promptObject.insert("content", formattedPrompt);
+    messages.append(promptObject);
+    root.insert("messages", messages);
+
+    QJsonDocument doc(root);
+
+#if defined(DEBUG)
+    qDebug().noquote() << "ChatAPI::prompt begin network request" << doc.toJson();
+#endif
+
+    m_responseCallback = responseCallback;
+
+    // The following code sets up a worker thread and object to perform the actual api request to
+    // chatgpt and then blocks until it is finished
+    QThread workerThread;
+    ChatAPIWorker worker(this);
+    worker.moveToThread(&workerThread);
+    connect(&worker, &ChatAPIWorker::finished, &workerThread, &QThread::quit, Qt::DirectConnection);
+    connect(this, &ChatAPI::request, &worker, &ChatAPIWorker::request, Qt::QueuedConnection);
+    workerThread.start();
+    emit request(m_apiKey, &promptCtx, doc.toJson(QJsonDocument::Compact));
+    workerThread.wait();
+
+    promptCtx.n_past += 1;
+    m_context.append(formattedPrompt);
+    m_context.append(worker.currentResponse());
+    m_responseCallback = nullptr;
+
+#if defined(DEBUG)
+    qDebug() << "ChatAPI::prompt end network request";
+#endif
+}
+
+bool ChatAPI::callResponse(int32_t token, const std::string& string)
+{
+    Q_ASSERT(m_responseCallback);
+    if (!m_responseCallback) {
+        std::cerr << "ChatAPI ERROR: no response callback!\n";
+        return false;
+    }
+    return m_responseCallback(token, string);
+}
+
+void ChatAPIWorker::request(const QString &apiKey,
+                            LLModel::PromptContext *promptCtx,
+                            const QByteArray &array)
+{
+    m_ctx = promptCtx;
+
+    QUrl apiUrl(m_chat->url());
+    const QString authorization = u"Bearer %1"_s.arg(apiKey).trimmed();
+    QNetworkRequest request(apiUrl);
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+    request.setRawHeader("Authorization", authorization.toUtf8());
+#if defined(DEBUG)
+    qDebug() << "ChatAPI::request"
+             << "API URL: " << apiUrl.toString()
+             << "Authorization: " << authorization.toUtf8();
+#endif
+    m_networkManager = new QNetworkAccessManager(this);
+    QNetworkReply *reply = m_networkManager->post(request, array);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, reply, &QNetworkReply::abort);
+    connect(reply, &QNetworkReply::finished, this, &ChatAPIWorker::handleFinished);
+    connect(reply, &QNetworkReply::readyRead, this, &ChatAPIWorker::handleReadyRead);
+    connect(reply, &QNetworkReply::errorOccurred, this, &ChatAPIWorker::handleErrorOccurred);
+}
+
+void ChatAPIWorker::handleFinished()
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply) {
+        emit finished();
+        return;
+    }
+
+    QVariant response = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+
+    if (!response.isValid()) {
+        m_chat->callResponse(
+            -1,
+            tr("ERROR: Network error occurred while connecting to the API server")
+                .toStdString()
+        );
+        return;
+    }
+
+    bool ok;
+    int code = response.toInt(&ok);
+    if (!ok || code != 200) {
+        bool isReplyEmpty(reply->readAll().isEmpty());
+        if (isReplyEmpty)
+            m_chat->callResponse(
+                -1,
+                tr("ChatAPIWorker::handleFinished got HTTP Error %1 %2")
+                    .arg(code)
+                    .arg(reply->errorString())
+                    .toStdString()
+            );
+        qWarning().noquote() << "ERROR: ChatAPIWorker::handleFinished got HTTP Error" << code << "response:"
+                             << reply->errorString();
+    }
+    reply->deleteLater();
+    emit finished();
+}
+
+void ChatAPIWorker::handleReadyRead()
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply) {
+        emit finished();
+        return;
+    }
+
+    QVariant response = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+
+    if (!response.isValid())
+        return;
+
+    bool ok;
+    int code = response.toInt(&ok);
+    if (!ok || code != 200) {
+        m_chat->callResponse(
+            -1,
+            u"ERROR: ChatAPIWorker::handleReadyRead got HTTP Error %1 %2: %3"_s
+                .arg(code).arg(reply->errorString(), reply->readAll()).toStdString()
+        );
+        emit finished();
+        return;
+    }
+
+    while (reply->canReadLine()) {
+        QString jsonData = reply->readLine().trimmed();
+        if (jsonData.startsWith("data:"))
+            jsonData.remove(0, 5);
+        jsonData = jsonData.trimmed();
+        if (jsonData.isEmpty())
+            continue;
+        if (jsonData == "[DONE]")
+            continue;
+#if defined(DEBUG)
+        qDebug().noquote() << "line" << jsonData;
+#endif
+        QJsonParseError err;
+        const QJsonDocument document = QJsonDocument::fromJson(jsonData.toUtf8(), &err);
+        if (err.error != QJsonParseError::NoError) {
+            m_chat->callResponse(-1, u"ERROR: ChatAPI responded with invalid json \"%1\""_s
+                                         .arg(err.errorString()).toStdString());
+            continue;
+        }
+
+        const QJsonObject root = document.object();
+        const QJsonArray choices = root.value("choices").toArray();
+        const QJsonObject choice = choices.first().toObject();
+        const QJsonObject delta = choice.value("delta").toObject();
+        const QString content = delta.value("content").toString();
+        Q_ASSERT(m_ctx);
+        m_currentResponse += content;
+        if (!m_chat->callResponse(0, content.toStdString())) {
+            reply->abort();
+            emit finished();
+            return;
+        }
+    }
+}
+
+void ChatAPIWorker::handleErrorOccurred(QNetworkReply::NetworkError code)
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply || reply->error() == QNetworkReply::OperationCanceledError /*when we call abort on purpose*/) {
+        emit finished();
+        return;
+    }
+
+    qWarning().noquote() << "ERROR: ChatAPIWorker::handleErrorOccurred got HTTP Error" << code << "response:"
+                         << reply->errorString();
+    emit finished();
+}

gpt4all-chat/src/chatapi.h

@@ -0,0 +1,163 @@
+#ifndef CHATAPI_H
+#define CHATAPI_H
+
+#include <gpt4all-backend/llmodel.h>
+
+#include <QByteArray>
+#include <QNetworkReply>
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QList>
+
+#include <cstddef>
+#include <cstdint>
+#include <stdexcept>
+#include <functional>
+#include <string>
+#include <vector>
+
+class QNetworkAccessManager;
+
+class ChatAPI;
+class ChatAPIWorker : public QObject {
+    Q_OBJECT
+public:
+    ChatAPIWorker(ChatAPI *chatAPI)
+        : QObject(nullptr)
+        , m_ctx(nullptr)
+        , m_networkManager(nullptr)
+        , m_chat(chatAPI) {}
+    virtual ~ChatAPIWorker() {}
+
+    QString currentResponse() const { return m_currentResponse; }
+
+    void request(const QString &apiKey,
+                 LLModel::PromptContext *promptCtx,
+                 const QByteArray &array);
+
+Q_SIGNALS:
+    void finished();
+
+private Q_SLOTS:
+    void handleFinished();
+    void handleReadyRead();
+    void handleErrorOccurred(QNetworkReply::NetworkError code);
+
+private:
+    ChatAPI *m_chat;
+    LLModel::PromptContext *m_ctx;
+    QNetworkAccessManager *m_networkManager;
+    QString m_currentResponse;
+};
+
+class ChatAPI : public QObject, public LLModel {
+    Q_OBJECT
+public:
+    ChatAPI();
+    virtual ~ChatAPI();
+
+    bool supportsEmbedding() const override { return false; }
+    bool supportsCompletion() const override { return true; }
+    bool loadModel(const std::string &modelPath, int n_ctx, int ngl) override;
+    bool isModelLoaded() const override;
+    size_t requiredMem(const std::string &modelPath, int n_ctx, int ngl) override;
+    size_t stateSize() const override;
+    size_t saveState(uint8_t *dest) const override;
+    size_t restoreState(const uint8_t *src) override;
+    void prompt(const std::string &prompt,
+                const std::string &promptTemplate,
+                std::function<bool(int32_t)> promptCallback,
+                std::function<bool(int32_t, const std::string&)> responseCallback,
+                bool allowContextShift,
+                PromptContext &ctx,
+                bool special,
+                std::string *fakeReply) override;
+
+    void setThreadCount(int32_t n_threads) override;
+    int32_t threadCount() const override;
+
+    void setModelName(const QString &modelName) { m_modelName = modelName; }
+    void setAPIKey(const QString &apiKey) { m_apiKey = apiKey; }
+    void setRequestURL(const QString &requestURL) { m_requestURL = requestURL; }
+    QString url() const { return m_requestURL; }
+
+    QList<QString> context() const { return m_context; }
+    void setContext(const QList<QString> &context) { m_context = context; }
+
+    bool callResponse(int32_t token, const std::string &string);
+
+Q_SIGNALS:
+    void request(const QString &apiKey,
+                 LLModel::PromptContext *ctx,
+                 const QByteArray &array);
+
+protected:
+    // We have to implement these as they are pure virtual in base class, but we don't actually use
+    // them as they are only called from the default implementation of 'prompt' which we override and
+    // completely replace
+
+    std::vector<Token> tokenize(PromptContext &ctx, const std::string &str, bool special) override
+    {
+        (void)ctx;
+        (void)str;
+        (void)special;
+        throw std::logic_error("not implemented");
+    }
+
+    bool isSpecialToken(Token id) const override
+    {
+        (void)id;
+        throw std::logic_error("not implemented");
+    }
+
+    std::string tokenToString(Token id) const override
+    {
+        (void)id;
+        throw std::logic_error("not implemented");
+    }
+
+    Token sampleToken(PromptContext &ctx) const override
+    {
+        (void)ctx;
+        throw std::logic_error("not implemented");
+    }
+
+    bool evalTokens(PromptContext &ctx, const std::vector<int32_t> &tokens) const override
+    {
+        (void)ctx;
+        (void)tokens;
+        throw std::logic_error("not implemented");
+    }
+
+    void shiftContext(PromptContext &promptCtx) override
+    {
+        (void)promptCtx;
+        throw std::logic_error("not implemented");
+    }
+
+    int32_t contextLength() const override
+    {
+        throw std::logic_error("not implemented");
+    }
+
+    const std::vector<Token> &endTokens() const override
+    {
+        throw std::logic_error("not implemented");
+    }
+
+    bool shouldAddBOS() const override
+    {
+        throw std::logic_error("not implemented");
+    }
+
+private:
+    std::function<bool(int32_t, const std::string&)> m_responseCallback;
+    QString m_modelName;
+    QString m_apiKey;
+    QString m_requestURL;
+    QList<QString> m_context;
+    QStringList m_queuedPrompts;
+};
+
+#endif // CHATAPI_H

gpt4all-chat/src/chatlistmodel.cpp

@@ -0,0 +1,287 @@
+#include "chatlistmodel.h"
+
+#include "database.h" // IWYU pragma: keep
+#include "mysettings.h"
+
+#include <QDataStream>
+#include <QDir>
+#include <QElapsedTimer>
+#include <QFile>
+#include <QFileInfo>
+#include <QGlobalStatic>
+#include <QGuiApplication>
+#include <QIODevice>
+#include <QSettings>
+#include <QString>
+#include <QStringList>
+#include <Qt>
+
+#include <algorithm>
+
+#define CHAT_FORMAT_MAGIC 0xF5D553CC
+#define CHAT_FORMAT_VERSION 9
+
+class MyChatListModel: public ChatListModel { };
+Q_GLOBAL_STATIC(MyChatListModel, chatListModelInstance)
+ChatListModel *ChatListModel::globalInstance()
+{
+    return chatListModelInstance();
+}
+
+ChatListModel::ChatListModel()
+    : QAbstractListModel(nullptr) {
+
+        QCoreApplication::instance()->installEventFilter(this);
+}
+
+bool ChatListModel::eventFilter(QObject *obj, QEvent *ev)
+{
+    if (obj == QCoreApplication::instance() && ev->type() == QEvent::LanguageChange)
+        emit dataChanged(index(0, 0), index(m_chats.size() - 1, 0));
+    return false;
+}
+
+void ChatListModel::loadChats()
+{
+    addChat();
+
+    ChatsRestoreThread *thread = new ChatsRestoreThread;
+    connect(thread, &ChatsRestoreThread::chatRestored, this, &ChatListModel::restoreChat, Qt::QueuedConnection);
+    connect(thread, &ChatsRestoreThread::finished, this, &ChatListModel::chatsRestoredFinished, Qt::QueuedConnection);
+    connect(thread, &ChatsRestoreThread::finished, thread, &QObject::deleteLater);
+    thread->start();
+
+    connect(MySettings::globalInstance(), &MySettings::serverChatChanged, this, &ChatListModel::handleServerEnabledChanged);
+}
+
+void ChatListModel::removeChatFile(Chat *chat) const
+{
+    Q_ASSERT(chat != m_serverChat);
+    const QString savePath = MySettings::globalInstance()->modelPath();
+    QFile file(savePath + "/gpt4all-" + chat->id() + ".chat");
+    if (!file.exists())
+        return;
+    bool success = file.remove();
+    if (!success)
+        qWarning() << "ERROR: Couldn't remove chat file:" << file.fileName();
+}
+
+ChatSaver::ChatSaver()
+    : QObject(nullptr)
+{
+    moveToThread(&m_thread);
+    m_thread.start();
+}
+
+void ChatListModel::saveChats()
+{
+    QVector<Chat*> toSave;
+    for (Chat *chat : m_chats) {
+        if (chat == m_serverChat)
+            continue;
+        if (chat->isNewChat())
+            continue;
+        toSave.append(chat);
+    }
+    if (toSave.isEmpty()) {
+        emit saveChatsFinished();
+        return;
+    }
+
+    ChatSaver *saver = new ChatSaver;
+    connect(this, &ChatListModel::requestSaveChats, saver, &ChatSaver::saveChats, Qt::QueuedConnection);
+    connect(saver, &ChatSaver::saveChatsFinished, this, &ChatListModel::saveChatsFinished, Qt::QueuedConnection);
+    emit requestSaveChats(toSave);
+}
+
+void ChatSaver::saveChats(const QVector<Chat *> &chats)
+{
+    QElapsedTimer timer;
+    timer.start();
+    const QString savePath = MySettings::globalInstance()->modelPath();
+    for (Chat *chat : chats) {
+        QString fileName = "gpt4all-" + chat->id() + ".chat";
+        QString filePath = savePath + "/" + fileName;
+        QFile originalFile(filePath);
+        QFile tempFile(filePath + ".tmp"); // Temporary file
+
+        bool success = tempFile.open(QIODevice::WriteOnly);
+        if (!success) {
+            qWarning() << "ERROR: Couldn't save chat to temporary file:" << tempFile.fileName();
+            continue;
+        }
+        QDataStream out(&tempFile);
+
+        out << (quint32)CHAT_FORMAT_MAGIC;
+        out << (qint32)CHAT_FORMAT_VERSION;
+        out.setVersion(QDataStream::Qt_6_2);
+
+        qDebug() << "serializing chat" << fileName;
+        if (!chat->serialize(out, CHAT_FORMAT_VERSION)) {
+            qWarning() << "ERROR: Couldn't serialize chat to file:" << tempFile.fileName();
+            tempFile.remove();
+            continue;
+        }
+
+        if (originalFile.exists())
+            originalFile.remove();
+        tempFile.rename(filePath);
+    }
+
+    qint64 elapsedTime = timer.elapsed();
+    qDebug() << "serializing chats took:" << elapsedTime << "ms";
+    emit saveChatsFinished();
+}
+
+void ChatsRestoreThread::run()
+{
+    QElapsedTimer timer;
+    timer.start();
+    struct FileInfo {
+        bool oldFile;
+        qint64 creationDate;
+        QString file;
+    };
+    QList<FileInfo> files;
+    {
+        // Look for any files in the original spot which was the settings config directory
+        QSettings settings;
+        QFileInfo settingsInfo(settings.fileName());
+        QString settingsPath = settingsInfo.absolutePath();
+        QDir dir(settingsPath);
+        dir.setNameFilters(QStringList() << "gpt4all-*.chat");
+        QStringList fileNames = dir.entryList();
+        for (const QString &f : fileNames) {
+            QString filePath = settingsPath + "/" + f;
+            QFile file(filePath);
+            bool success = file.open(QIODevice::ReadOnly);
+            if (!success) {
+                qWarning() << "ERROR: Couldn't restore chat from file:" << file.fileName();
+                continue;
+            }
+            QDataStream in(&file);
+            FileInfo info;
+            info.oldFile = true;
+            info.file = filePath;
+            in >> info.creationDate;
+            files.append(info);
+            file.close();
+        }
+    }
+    {
+        const QString savePath = MySettings::globalInstance()->modelPath();
+        QDir dir(savePath);
+        dir.setNameFilters(QStringList() << "gpt4all-*.chat");
+        QStringList fileNames = dir.entryList();
+        for (const QString &f : fileNames) {
+            QString filePath = savePath + "/" + f;
+            QFile file(filePath);
+            bool success = file.open(QIODevice::ReadOnly);
+            if (!success) {
+                qWarning() << "ERROR: Couldn't restore chat from file:" << file.fileName();
+                continue;
+            }
+            QDataStream in(&file);
+            // Read and check the header
+            quint32 magic;
+            in >> magic;
+            if (magic != CHAT_FORMAT_MAGIC) {
+                qWarning() << "ERROR: Chat file has bad magic:" << file.fileName();
+                continue;
+            }
+
+            // Read the version
+            qint32 version;
+            in >> version;
+            if (version < 1) {
+                qWarning() << "ERROR: Chat file has non supported version:" << file.fileName();
+                continue;
+            }
+
+            if (version <= 1)
+                in.setVersion(QDataStream::Qt_6_2);
+
+            FileInfo info;
+            info.oldFile = false;
+            info.file = filePath;
+            in >> info.creationDate;
+            files.append(info);
+            file.close();
+        }
+    }
+    std::sort(files.begin(), files.end(), [](const FileInfo &a, const FileInfo &b) {
+        return a.creationDate > b.creationDate;
+    });
+
+    for (FileInfo &f : files) {
+        QFile file(f.file);
+        bool success = file.open(QIODevice::ReadOnly);
+        if (!success) {
+            qWarning() << "ERROR: Couldn't restore chat from file:" << file.fileName();
+            continue;
+        }
+        QDataStream in(&file);
+
+        qint32 version = 0;
+        if (!f.oldFile) {
+            // Read and check the header
+            quint32 magic;
+            in >> magic;
+            if (magic != CHAT_FORMAT_MAGIC) {
+                qWarning() << "ERROR: Chat file has bad magic:" << file.fileName();
+                continue;
+            }
+
+            // Read the version
+            in >> version;
+            if (version < 1) {
+                qWarning() << "ERROR: Chat file has non supported version:" << file.fileName();
+                continue;
+            }
+
+            if (version <= 1)
+                in.setVersion(QDataStream::Qt_6_2);
+        }
+
+        qDebug() << "deserializing chat" << f.file;
+
+        Chat *chat = new Chat;
+        chat->moveToThread(qGuiApp->thread());
+        if (!chat->deserialize(in, version)) {
+            qWarning() << "ERROR: Couldn't deserialize chat from file:" << file.fileName();
+        } else {
+            emit chatRestored(chat);
+        }
+        if (f.oldFile)
+           file.remove(); // No longer storing in this directory
+        file.close();
+    }
+
+    qint64 elapsedTime = timer.elapsed();
+    qDebug() << "deserializing chats took:" << elapsedTime << "ms";
+}
+
+void ChatListModel::restoreChat(Chat *chat)
+{
+    chat->setParent(this);
+    connect(chat, &Chat::nameChanged, this, &ChatListModel::nameChanged);
+
+    beginInsertRows(QModelIndex(), m_chats.size(), m_chats.size());
+    m_chats.append(chat);
+    endInsertRows();
+}
+
+void ChatListModel::chatsRestoredFinished()
+{
+    addServerChat();
+}
+
+void ChatListModel::handleServerEnabledChanged()
+{
+    if (MySettings::globalInstance()->serverChat() || m_serverChat != m_currentChat)
+        return;
+
+    Chat *nextChat = get(0);
+    Q_ASSERT(nextChat && nextChat != m_serverChat);
+    setCurrentChat(nextChat);
+}

gpt4all-chat/src/chatlistmodel.h

@@ -0,0 +1,291 @@
+#ifndef CHATLISTMODEL_H
+#define CHATLISTMODEL_H
+
+#include "chat.h"
+#include "chatllm.h"
+#include "chatmodel.h"
+
+#include <QAbstractListModel>
+#include <QByteArray>
+#include <QDebug>
+#include <QHash>
+#include <QList>
+#include <QObject>
+#include <QThread>
+#include <QVariant>
+#include <QVector>
+#include <Qt>
+#include <QtGlobal>
+#include <QtLogging>
+
+class ChatsRestoreThread : public QThread
+{
+    Q_OBJECT
+public:
+    void run() override;
+
+Q_SIGNALS:
+    void chatRestored(Chat *chat);
+};
+
+class ChatSaver : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ChatSaver();
+    void stop();
+
+Q_SIGNALS:
+    void saveChatsFinished();
+
+public Q_SLOTS:
+    void saveChats(const QVector<Chat*> &chats);
+
+private:
+    QThread m_thread;
+};
+
+class ChatListModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(Chat *currentChat READ currentChat WRITE setCurrentChat NOTIFY currentChatChanged)
+
+public:
+    static ChatListModel *globalInstance();
+
+    enum Roles {
+        IdRole = Qt::UserRole + 1,
+        NameRole,
+        SectionRole
+    };
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override
+    {
+        Q_UNUSED(parent)
+        return m_chats.size();
+    }
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override
+    {
+        if (!index.isValid() || index.row() < 0 || index.row() >= m_chats.size())
+            return QVariant();
+
+        const Chat *item = m_chats.at(index.row());
+        switch (role) {
+            case IdRole:
+                return item->id();
+            case NameRole:
+                return item->name();
+            case SectionRole: {
+                if (item == m_serverChat)
+                    return QString();
+                const QDate date = QDate::currentDate();
+                const QDate itemDate = item->creationDate().date();
+                if (date == itemDate)
+                    return tr("TODAY");
+                else if (itemDate >= date.addDays(-7))
+                    return tr("THIS WEEK");
+                else if (itemDate >= date.addMonths(-1))
+                    return tr("THIS MONTH");
+                else if (itemDate >= date.addMonths(-6))
+                    return tr("LAST SIX MONTHS");
+                else if (itemDate.year() == date.year())
+                    return tr("THIS YEAR");
+                else if (itemDate.year() == date.year() - 1)
+                    return tr("LAST YEAR");
+                else
+                    return QString::number(itemDate.year());
+            }
+        }
+
+        return QVariant();
+    }
+
+    QHash<int, QByteArray> roleNames() const override
+    {
+        QHash<int, QByteArray> roles;
+        roles[IdRole] = "id";
+        roles[NameRole] = "name";
+        roles[SectionRole] = "section";
+        return roles;
+    }
+
+    bool shouldSaveChats() const;
+    void setShouldSaveChats(bool b);
+
+    bool shouldSaveChatGPTChats() const;
+    void setShouldSaveChatGPTChats(bool b);
+
+    Q_INVOKABLE void loadChats();
+
+    Q_INVOKABLE void addChat()
+    {
+        // Select the existing new chat if we already have one
+        if (m_newChat) {
+            setCurrentChat(m_newChat);
+            return;
+        }
+
+        // Create a new chat pointer and connect it to determine when it is populated
+        m_newChat = new Chat(this);
+        connect(m_newChat->chatModel(), &ChatModel::countChanged,
+            this, &ChatListModel::newChatCountChanged);
+        connect(m_newChat, &Chat::nameChanged,
+            this, &ChatListModel::nameChanged);
+
+        beginInsertRows(QModelIndex(), 0, 0);
+        m_chats.prepend(m_newChat);
+        endInsertRows();
+        emit countChanged();
+        setCurrentChat(m_newChat);
+    }
+
+    Q_INVOKABLE void addServerChat()
+    {
+        // Create a new dummy chat pointer and don't connect it
+        if (m_serverChat)
+            return;
+
+        m_serverChat = new Chat(true /*isServer*/, this);
+        beginInsertRows(QModelIndex(), m_chats.size(), m_chats.size());
+        m_chats.append(m_serverChat);
+        endInsertRows();
+        emit countChanged();
+    }
+
+    Q_INVOKABLE void removeChat(Chat* chat)
+    {
+        Q_ASSERT(chat != m_serverChat);
+        if (!m_chats.contains(chat)) {
+            qWarning() << "WARNING: Removing chat failed with id" << chat->id();
+            return;
+        }
+
+        removeChatFile(chat);
+
+        if (chat == m_newChat) {
+            m_newChat->disconnect(this);
+            m_newChat = nullptr;
+        }
+
+        chat->markForDeletion();
+
+        const int index = m_chats.indexOf(chat);
+        if (m_chats.count() < 3 /*m_serverChat included*/) {
+            addChat();
+        } else {
+            int nextIndex;
+            if (index == m_chats.count() - 2 /*m_serverChat is last*/)
+                nextIndex = index - 1;
+            else
+                nextIndex = index + 1;
+            Chat *nextChat = get(nextIndex);
+            Q_ASSERT(nextChat);
+            setCurrentChat(nextChat);
+        }
+
+        const int newIndex = m_chats.indexOf(chat);
+        beginRemoveRows(QModelIndex(), newIndex, newIndex);
+        m_chats.removeAll(chat);
+        endRemoveRows();
+        chat->unloadAndDeleteLater();
+    }
+
+    Chat *currentChat() const
+    {
+        return m_currentChat;
+    }
+
+    void setCurrentChat(Chat *chat)
+    {
+        if (!m_chats.contains(chat)) {
+            qWarning() << "ERROR: Setting current chat failed with id" << chat->id();
+            return;
+        }
+
+        if (m_currentChat && m_currentChat != m_serverChat)
+            m_currentChat->unloadModel();
+        m_currentChat = chat;
+        emit currentChatChanged();
+        if (!m_currentChat->isModelLoaded() && m_currentChat != m_serverChat)
+            m_currentChat->trySwitchContextOfLoadedModel();
+    }
+
+    Q_INVOKABLE Chat* get(int index)
+    {
+        if (index < 0 || index >= m_chats.size()) return nullptr;
+        return m_chats.at(index);
+    }
+
+    int count() const { return m_chats.size(); }
+
+    // stop ChatLLM threads for clean shutdown
+    void destroyChats()
+    {
+        for (auto *chat: m_chats) { chat->destroy(); }
+        ChatLLM::destroyStore();
+    }
+
+    void removeChatFile(Chat *chat) const;
+    Q_INVOKABLE void saveChats();
+    void restoreChat(Chat *chat);
+    void chatsRestoredFinished();
+
+public Q_SLOTS:
+    void handleServerEnabledChanged();
+
+Q_SIGNALS:
+    void countChanged();
+    void currentChatChanged();
+    void chatsSavedFinished();
+    void requestSaveChats(const QVector<Chat*> &);
+    void saveChatsFinished();
+
+protected:
+    bool eventFilter(QObject *obj, QEvent *ev) override;
+
+private Q_SLOTS:
+    void newChatCountChanged()
+    {
+        Q_ASSERT(m_newChat && m_newChat->chatModel()->count());
+        m_newChat->chatModel()->disconnect(this);
+        m_newChat = nullptr;
+    }
+
+    void nameChanged()
+    {
+        Chat *chat = qobject_cast<Chat *>(sender());
+        if (!chat)
+            return;
+
+        int row = m_chats.indexOf(chat);
+        if (row < 0 || row >= m_chats.size())
+            return;
+
+        QModelIndex index = createIndex(row, 0);
+        emit dataChanged(index, index, {NameRole});
+    }
+
+    void printChats()
+    {
+        for (auto c : m_chats) {
+            qDebug() << c->name()
+                << (c == m_currentChat ? "currentChat: true" : "currentChat: false")
+                << (c == m_newChat ? "newChat: true" : "newChat: false");
+        }
+    }
+
+private:
+    Chat* m_newChat = nullptr;
+    Chat* m_serverChat = nullptr;
+    Chat* m_currentChat = nullptr;
+    QList<Chat*> m_chats;
+
+private:
+    explicit ChatListModel();
+    ~ChatListModel() {}
+    friend class MyChatListModel;
+};
+
+#endif // CHATITEMMODEL_H

gpt4all-chat/src/chatllm.h

@@ -0,0 +1,249 @@
+#ifndef CHATLLM_H
+#define CHATLLM_H
+
+#include "database.h" // IWYU pragma: keep
+#include "modellist.h"
+
+#include <gpt4all-backend/llmodel.h>
+
+#include <QByteArray>
+#include <QElapsedTimer>
+#include <QFileInfo>
+#include <QList>
+#include <QObject>
+#include <QPair>
+#include <QString>
+#include <QThread>
+#include <QVariantMap>
+#include <QVector>
+#include <QtGlobal>
+
+#include <atomic>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+
+using namespace Qt::Literals::StringLiterals;
+
+class QDataStream;
+
+// NOTE: values serialized to disk, do not change or reuse
+enum LLModelType {
+    GPTJ_  = 0, // no longer used
+    LLAMA_ = 1,
+    API_   = 2,
+    BERT_  = 3, // no longer used
+};
+
+class ChatLLM;
+
+struct LLModelInfo {
+    std::unique_ptr<LLModel> model;
+    QFileInfo fileInfo;
+    std::optional<QString> fallbackReason;
+
+    // NOTE: This does not store the model type or name on purpose as this is left for ChatLLM which
+    // must be able to serialize the information even if it is in the unloaded state
+
+    void resetModel(ChatLLM *cllm, LLModel *model = nullptr);
+};
+
+class TokenTimer : public QObject {
+    Q_OBJECT
+public:
+    explicit TokenTimer(QObject *parent)
+        : QObject(parent)
+        , m_elapsed(0) {}
+
+    static int rollingAverage(int oldAvg, int newNumber, int n)
+    {
+        // i.e. to calculate the new average after then nth number,
+        // you multiply the old average by n−1, add the new number, and divide the total by n.
+        return qRound(((float(oldAvg) * (n - 1)) + newNumber) / float(n));
+    }
+
+    void start() { m_tokens = 0; m_elapsed = 0; m_time.invalidate(); }
+    void stop() { handleTimeout(); }
+    void inc() {
+        if (!m_time.isValid())
+            m_time.start();
+        ++m_tokens;
+        if (m_time.elapsed() > 999)
+            handleTimeout();
+    }
+
+Q_SIGNALS:
+    void report(const QString &speed);
+
+private Q_SLOTS:
+    void handleTimeout()
+    {
+        m_elapsed += m_time.restart();
+        emit report(u"%1 tokens/sec"_s.arg(m_tokens / float(m_elapsed / 1000.0f), 0, 'g', 2));
+    }
+
+private:
+    QElapsedTimer m_time;
+    qint64 m_elapsed;
+    quint32 m_tokens;
+};
+
+class Chat;
+class ChatLLM : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool restoringFromText READ restoringFromText NOTIFY restoringFromTextChanged)
+    Q_PROPERTY(QString deviceBackend READ deviceBackend NOTIFY loadedModelInfoChanged)
+    Q_PROPERTY(QString device READ device NOTIFY loadedModelInfoChanged)
+    Q_PROPERTY(QString fallbackReason READ fallbackReason NOTIFY loadedModelInfoChanged)
+public:
+    ChatLLM(Chat *parent, bool isServer = false);
+    virtual ~ChatLLM();
+
+    void destroy();
+    static void destroyStore();
+    bool isModelLoaded() const;
+    void regenerateResponse();
+    void resetResponse();
+    void resetContext();
+
+    void stopGenerating() { m_stopGenerating = true; }
+
+    bool shouldBeLoaded() const { return m_shouldBeLoaded; }
+    void setShouldBeLoaded(bool b);
+    void requestTrySwitchContext();
+    void setForceUnloadModel(bool b) { m_forceUnloadModel = b; }
+    void setMarkedForDeletion(bool b) { m_markedForDeletion = b; }
+
+    QString response() const;
+
+    ModelInfo modelInfo() const;
+    void setModelInfo(const ModelInfo &info);
+
+    bool restoringFromText() const { return m_restoringFromText; }
+
+    void acquireModel();
+    void resetModel();
+
+    QString deviceBackend() const
+    {
+        if (!isModelLoaded()) return QString();
+        std::string name = LLModel::GPUDevice::backendIdToName(m_llModelInfo.model->backendName());
+        return QString::fromStdString(name);
+    }
+
+    QString device() const
+    {
+        if (!isModelLoaded()) return QString();
+        const char *name = m_llModelInfo.model->gpuDeviceName();
+        return name ? QString(name) : u"CPU"_s;
+    }
+
+    // not loaded -> QString(), no fallback -> QString("")
+    QString fallbackReason() const
+    {
+        if (!isModelLoaded()) return QString();
+        return m_llModelInfo.fallbackReason.value_or(u""_s);
+    }
+
+    QString generatedName() const { return QString::fromStdString(m_nameResponse); }
+
+    bool serialize(QDataStream &stream, int version, bool serializeKV);
+    bool deserialize(QDataStream &stream, int version, bool deserializeKV, bool discardKV);
+    void setStateFromText(const QVector<QPair<QString, QString>> &stateFromText) { m_stateFromText = stateFromText; }
+
+public Q_SLOTS:
+    bool prompt(const QList<QString> &collectionList, const QString &prompt);
+    bool loadDefaultModel();
+    void trySwitchContextOfLoadedModel(const ModelInfo &modelInfo);
+    bool loadModel(const ModelInfo &modelInfo);
+    void modelChangeRequested(const ModelInfo &modelInfo);
+    void unloadModel();
+    void reloadModel();
+    void generateName();
+    void generateQuestions(qint64 elapsed);
+    void handleChatIdChanged(const QString &id);
+    void handleShouldBeLoadedChanged();
+    void handleThreadStarted();
+    void handleForceMetalChanged(bool forceMetal);
+    void handleDeviceChanged();
+    void processSystemPrompt();
+    void processRestoreStateFromText();
+
+Q_SIGNALS:
+    void restoringFromTextChanged();
+    void loadedModelInfoChanged();
+    void modelLoadingPercentageChanged(float);
+    void modelLoadingError(const QString &error);
+    void modelLoadingWarning(const QString &warning);
+    void responseChanged(const QString &response);
+    void promptProcessing();
+    void generatingQuestions();
+    void responseStopped(qint64 promptResponseMs);
+    void generatedNameChanged(const QString &name);
+    void generatedQuestionFinished(const QString &generatedQuestion);
+    void stateChanged();
+    void threadStarted();
+    void shouldBeLoadedChanged();
+    void trySwitchContextRequested(const ModelInfo &modelInfo);
+    void trySwitchContextOfLoadedModelCompleted(int value);
+    void requestRetrieveFromDB(const QList<QString> &collections, const QString &text, int retrievalSize, QList<ResultInfo> *results);
+    void reportSpeed(const QString &speed);
+    void reportDevice(const QString &device);
+    void reportFallbackReason(const QString &fallbackReason);
+    void databaseResultsChanged(const QList<ResultInfo>&);
+    void modelInfoChanged(const ModelInfo &modelInfo);
+
+protected:
+    bool promptInternal(const QList<QString> &collectionList, const QString &prompt, const QString &promptTemplate,
+        int32_t n_predict, int32_t top_k, float top_p, float min_p, float temp, int32_t n_batch, float repeat_penalty,
+        int32_t repeat_penalty_tokens);
+    bool handlePrompt(int32_t token);
+    bool handleResponse(int32_t token, const std::string &response);
+    bool handleNamePrompt(int32_t token);
+    bool handleNameResponse(int32_t token, const std::string &response);
+    bool handleSystemPrompt(int32_t token);
+    bool handleSystemResponse(int32_t token, const std::string &response);
+    bool handleRestoreStateFromTextPrompt(int32_t token);
+    bool handleRestoreStateFromTextResponse(int32_t token, const std::string &response);
+    bool handleQuestionPrompt(int32_t token);
+    bool handleQuestionResponse(int32_t token, const std::string &response);
+    void saveState();
+    void restoreState();
+
+protected:
+    LLModel::PromptContext m_ctx;
+    quint32 m_promptTokens;
+    quint32 m_promptResponseTokens;
+
+private:
+    bool loadNewModel(const ModelInfo &modelInfo, QVariantMap &modelLoadProps);
+
+    std::string m_response;
+    std::string m_nameResponse;
+    QString m_questionResponse;
+    LLModelInfo m_llModelInfo;
+    LLModelType m_llModelType;
+    ModelInfo m_modelInfo;
+    TokenTimer *m_timer;
+    QByteArray m_state;
+    QThread m_llmThread;
+    std::atomic<bool> m_stopGenerating;
+    std::atomic<bool> m_shouldBeLoaded;
+    std::atomic<bool> m_restoringFromText; // status indication
+    std::atomic<bool> m_forceUnloadModel;
+    std::atomic<bool> m_markedForDeletion;
+    bool m_isServer;
+    bool m_forceMetal;
+    bool m_reloadingToChangeVariant;
+    bool m_processedSystemPrompt;
+    bool m_restoreStateFromText;
+    // m_pristineLoadedState is set if saveSate is unnecessary, either because:
+    // - an unload was queued during LLModel::restoreState()
+    // - the chat will be restored from text and hasn't been interacted with yet
+    bool m_pristineLoadedState = false;
+    QVector<QPair<QString, QString>> m_stateFromText;
+};
+
+#endif // CHATLLM_H

gpt4all-chat/src/chatmodel.h

@@ -0,0 +1,474 @@
+#ifndef CHATMODEL_H
+#define CHATMODEL_H
+
+#include "database.h"
+
+#include <QAbstractListModel>
+#include <QByteArray>
+#include <QDataStream>
+#include <QHash>
+#include <QList>
+#include <QObject>
+#include <QPair>
+#include <QString>
+#include <QVariant>
+#include <QVector>
+#include <Qt>
+#include <QtGlobal>
+
+struct ChatItem
+{
+    Q_GADGET
+    Q_PROPERTY(int id MEMBER id)
+    Q_PROPERTY(QString name MEMBER name)
+    Q_PROPERTY(QString value MEMBER value)
+    Q_PROPERTY(QString prompt MEMBER prompt)
+    Q_PROPERTY(QString newResponse MEMBER newResponse)
+    Q_PROPERTY(bool currentResponse MEMBER currentResponse)
+    Q_PROPERTY(bool stopped MEMBER stopped)
+    Q_PROPERTY(bool thumbsUpState MEMBER thumbsUpState)
+    Q_PROPERTY(bool thumbsDownState MEMBER thumbsDownState)
+    Q_PROPERTY(QList<ResultInfo> sources MEMBER sources)
+    Q_PROPERTY(QList<ResultInfo> consolidatedSources MEMBER consolidatedSources)
+
+public:
+    // TODO: Maybe we should include the model name here as well as timestamp?
+    int id = 0;
+    QString name;
+    QString value;
+    QString prompt;
+    QString newResponse;
+    QList<ResultInfo> sources;
+    QList<ResultInfo> consolidatedSources;
+    bool currentResponse = false;
+    bool stopped = false;
+    bool thumbsUpState = false;
+    bool thumbsDownState = false;
+};
+Q_DECLARE_METATYPE(ChatItem)
+
+class ChatModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+
+public:
+    explicit ChatModel(QObject *parent = nullptr) : QAbstractListModel(parent) {}
+
+    enum Roles {
+        IdRole = Qt::UserRole + 1,
+        NameRole,
+        ValueRole,
+        PromptRole,
+        NewResponseRole,
+        CurrentResponseRole,
+        StoppedRole,
+        ThumbsUpStateRole,
+        ThumbsDownStateRole,
+        SourcesRole,
+        ConsolidatedSourcesRole
+    };
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override
+    {
+        Q_UNUSED(parent)
+        return m_chatItems.size();
+    }
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override
+    {
+        if (!index.isValid() || index.row() < 0 || index.row() >= m_chatItems.size())
+            return QVariant();
+
+        const ChatItem &item = m_chatItems.at(index.row());
+        switch (role) {
+            case IdRole:
+                return item.id;
+            case NameRole:
+                return item.name;
+            case ValueRole:
+                return item.value;
+            case PromptRole:
+                return item.prompt;
+            case NewResponseRole:
+                return item.newResponse;
+            case CurrentResponseRole:
+                return item.currentResponse;
+            case StoppedRole:
+                return item.stopped;
+            case ThumbsUpStateRole:
+                return item.thumbsUpState;
+            case ThumbsDownStateRole:
+                return item.thumbsDownState;
+            case SourcesRole:
+                return QVariant::fromValue(item.sources);
+            case ConsolidatedSourcesRole:
+                return QVariant::fromValue(item.consolidatedSources);
+        }
+
+        return QVariant();
+    }
+
+    QHash<int, QByteArray> roleNames() const override
+    {
+        QHash<int, QByteArray> roles;
+        roles[IdRole] = "id";
+        roles[NameRole] = "name";
+        roles[ValueRole] = "value";
+        roles[PromptRole] = "prompt";
+        roles[NewResponseRole] = "newResponse";
+        roles[CurrentResponseRole] = "currentResponse";
+        roles[StoppedRole] = "stopped";
+        roles[ThumbsUpStateRole] = "thumbsUpState";
+        roles[ThumbsDownStateRole] = "thumbsDownState";
+        roles[SourcesRole] = "sources";
+        roles[ConsolidatedSourcesRole] = "consolidatedSources";
+        return roles;
+    }
+
+    void appendPrompt(const QString &name, const QString &value)
+    {
+        ChatItem item;
+        item.name = name;
+        item.value = value;
+        beginInsertRows(QModelIndex(), m_chatItems.size(), m_chatItems.size());
+        m_chatItems.append(item);
+        endInsertRows();
+        emit countChanged();
+    }
+
+    void appendResponse(const QString &name, const QString &prompt)
+    {
+        ChatItem item;
+        item.id = m_chatItems.count(); // This is only relevant for responses
+        item.name = name;
+        item.prompt = prompt;
+        item.currentResponse = true;
+        beginInsertRows(QModelIndex(), m_chatItems.size(), m_chatItems.size());
+        m_chatItems.append(item);
+        endInsertRows();
+        emit countChanged();
+    }
+
+    Q_INVOKABLE void clear()
+    {
+        if (m_chatItems.isEmpty()) return;
+
+        beginResetModel();
+        m_chatItems.clear();
+        endResetModel();
+        emit countChanged();
+    }
+
+    Q_INVOKABLE ChatItem get(int index)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return ChatItem();
+        return m_chatItems.at(index);
+    }
+
+    Q_INVOKABLE void updateCurrentResponse(int index, bool b)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return;
+
+        ChatItem &item = m_chatItems[index];
+        if (item.currentResponse != b) {
+            item.currentResponse = b;
+            emit dataChanged(createIndex(index, 0), createIndex(index, 0), {CurrentResponseRole});
+        }
+    }
+
+    Q_INVOKABLE void updateStopped(int index, bool b)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return;
+
+        ChatItem &item = m_chatItems[index];
+        if (item.stopped != b) {
+            item.stopped = b;
+            emit dataChanged(createIndex(index, 0), createIndex(index, 0), {StoppedRole});
+        }
+    }
+
+    Q_INVOKABLE void updateValue(int index, const QString &value)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return;
+
+        ChatItem &item = m_chatItems[index];
+        if (item.value != value) {
+            item.value = value;
+            emit dataChanged(createIndex(index, 0), createIndex(index, 0), {ValueRole});
+            emit valueChanged(index, value);
+        }
+    }
+
+    QList<ResultInfo> consolidateSources(const QList<ResultInfo> &sources) {
+        QMap<QString, ResultInfo> groupedData;
+        for (const ResultInfo &info : sources) {
+            if (groupedData.contains(info.file)) {
+                groupedData[info.file].text += "\n---\n" + info.text;
+            } else {
+                groupedData[info.file] = info;
+            }
+        }
+        QList<ResultInfo> consolidatedSources = groupedData.values();
+        return consolidatedSources;
+    }
+
+    Q_INVOKABLE void updateSources(int index, const QList<ResultInfo> &sources)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return;
+
+        ChatItem &item = m_chatItems[index];
+        item.sources = sources;
+        item.consolidatedSources = consolidateSources(sources);
+        emit dataChanged(createIndex(index, 0), createIndex(index, 0), {SourcesRole});
+        emit dataChanged(createIndex(index, 0), createIndex(index, 0), {ConsolidatedSourcesRole});
+    }
+
+    Q_INVOKABLE void updateThumbsUpState(int index, bool b)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return;
+
+        ChatItem &item = m_chatItems[index];
+        if (item.thumbsUpState != b) {
+            item.thumbsUpState = b;
+            emit dataChanged(createIndex(index, 0), createIndex(index, 0), {ThumbsUpStateRole});
+        }
+    }
+
+    Q_INVOKABLE void updateThumbsDownState(int index, bool b)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return;
+
+        ChatItem &item = m_chatItems[index];
+        if (item.thumbsDownState != b) {
+            item.thumbsDownState = b;
+            emit dataChanged(createIndex(index, 0), createIndex(index, 0), {ThumbsDownStateRole});
+        }
+    }
+
+    Q_INVOKABLE void updateNewResponse(int index, const QString &newResponse)
+    {
+        if (index < 0 || index >= m_chatItems.size()) return;
+
+        ChatItem &item = m_chatItems[index];
+        if (item.newResponse != newResponse) {
+            item.newResponse = newResponse;
+            emit dataChanged(createIndex(index, 0), createIndex(index, 0), {NewResponseRole});
+        }
+    }
+
+    int count() const { return m_chatItems.size(); }
+
+    bool serialize(QDataStream &stream, int version) const
+    {
+        stream << count();
+        for (const auto &c : m_chatItems) {
+            stream << c.id;
+            stream << c.name;
+            stream << c.value;
+            stream << c.prompt;
+            stream << c.newResponse;
+            stream << c.currentResponse;
+            stream << c.stopped;
+            stream << c.thumbsUpState;
+            stream << c.thumbsDownState;
+            if (version > 7) {
+                stream << c.sources.size();
+                for (const ResultInfo &info : c.sources) {
+                    Q_ASSERT(!info.file.isEmpty());
+                    stream << info.collection;
+                    stream << info.path;
+                    stream << info.file;
+                    stream << info.title;
+                    stream << info.author;
+                    stream << info.date;
+                    stream << info.text;
+                    stream << info.page;
+                    stream << info.from;
+                    stream << info.to;
+                }
+            } else if (version > 2) {
+                QList<QString> references;
+                QList<QString> referencesContext;
+                int validReferenceNumber = 1;
+                for (const ResultInfo &info : c.sources) {
+                    if (info.file.isEmpty())
+                        continue;
+
+                    QString reference;
+                    {
+                        QTextStream stream(&reference);
+                        stream << (validReferenceNumber++) << ". ";
+                        if (!info.title.isEmpty())
+                            stream << "\"" << info.title << "\". ";
+                        if (!info.author.isEmpty())
+                            stream << "By " << info.author << ". ";
+                        if (!info.date.isEmpty())
+                            stream << "Date: " << info.date << ". ";
+                        stream << "In " << info.file << ". ";
+                        if (info.page != -1)
+                            stream << "Page " << info.page << ". ";
+                        if (info.from != -1) {
+                            stream << "Lines " << info.from;
+                            if (info.to != -1)
+                                stream << "-" << info.to;
+                            stream << ". ";
+                        }
+                        stream << "[Context](context://" << validReferenceNumber - 1 << ")";
+                    }
+                    references.append(reference);
+                    referencesContext.append(info.text);
+                }
+
+                stream << references.join("\n");
+                stream << referencesContext;
+            }
+        }
+        return stream.status() == QDataStream::Ok;
+    }
+
+    bool deserialize(QDataStream &stream, int version)
+    {
+        int size;
+        stream >> size;
+        for (int i = 0; i < size; ++i) {
+            ChatItem c;
+            stream >> c.id;
+            stream >> c.name;
+            stream >> c.value;
+            stream >> c.prompt;
+            stream >> c.newResponse;
+            stream >> c.currentResponse;
+            stream >> c.stopped;
+            stream >> c.thumbsUpState;
+            stream >> c.thumbsDownState;
+            if (version > 7) {
+                qsizetype count;
+                stream >> count;
+                QList<ResultInfo> sources;
+                for (int i = 0; i < count; ++i) {
+                    ResultInfo info;
+                    stream >> info.collection;
+                    stream >> info.path;
+                    stream >> info.file;
+                    stream >> info.title;
+                    stream >> info.author;
+                    stream >> info.date;
+                    stream >> info.text;
+                    stream >> info.page;
+                    stream >> info.from;
+                    stream >> info.to;
+                    sources.append(info);
+                }
+                c.sources = sources;
+                c.consolidatedSources = consolidateSources(sources);
+            }else if (version > 2) {
+                QString references;
+                QList<QString> referencesContext;
+                stream >> references;
+                stream >> referencesContext;
+
+                if (!references.isEmpty()) {
+                    QList<ResultInfo> sources;
+                    QList<QString> referenceList = references.split("\n");
+
+                    // Ignore empty lines and those that begin with "---" which is no longer used
+                    for (auto it = referenceList.begin(); it != referenceList.end();) {
+                        if (it->trimmed().isEmpty() || it->trimmed().startsWith("---"))
+                            it = referenceList.erase(it);
+                        else
+                            ++it;
+                    }
+
+                    Q_ASSERT(referenceList.size() == referencesContext.size());
+                    for (int j = 0; j < referenceList.size(); ++j) {
+                        QString reference = referenceList[j];
+                        QString context = referencesContext[j];
+                        ResultInfo info;
+                        QTextStream refStream(&reference);
+                        QString dummy;
+                        int validReferenceNumber;
+                        refStream >> validReferenceNumber >> dummy;
+                        // Extract title (between quotes)
+                        if (reference.contains("\"")) {
+                            int startIndex = reference.indexOf('"') + 1;
+                            int endIndex = reference.indexOf('"', startIndex);
+                            info.title = reference.mid(startIndex, endIndex - startIndex);
+                        }
+
+                        // Extract author (after "By " and before the next period)
+                        if (reference.contains("By ")) {
+                            int startIndex = reference.indexOf("By ") + 3;
+                            int endIndex = reference.indexOf('.', startIndex);
+                            info.author = reference.mid(startIndex, endIndex - startIndex).trimmed();
+                        }
+
+                        // Extract date (after "Date: " and before the next period)
+                        if (reference.contains("Date: ")) {
+                            int startIndex = reference.indexOf("Date: ") + 6;
+                            int endIndex = reference.indexOf('.', startIndex);
+                            info.date = reference.mid(startIndex, endIndex - startIndex).trimmed();
+                        }
+
+                        // Extract file name (after "In " and before the "[Context]")
+                        if (reference.contains("In ") && reference.contains(". [Context]")) {
+                            int startIndex = reference.indexOf("In ") + 3;
+                            int endIndex = reference.indexOf(". [Context]", startIndex);
+                            info.file = reference.mid(startIndex, endIndex - startIndex).trimmed();
+                        }
+
+                        // Extract page number (after "Page " and before the next space)
+                        if (reference.contains("Page ")) {
+                            int startIndex = reference.indexOf("Page ") + 5;
+                            int endIndex = reference.indexOf(' ', startIndex);
+                            if (endIndex == -1) endIndex = reference.length();
+                            info.page = reference.mid(startIndex, endIndex - startIndex).toInt();
+                        }
+
+                        // Extract lines (after "Lines " and before the next space or hyphen)
+                        if (reference.contains("Lines ")) {
+                            int startIndex = reference.indexOf("Lines ") + 6;
+                            int endIndex = reference.indexOf(' ', startIndex);
+                            if (endIndex == -1) endIndex = reference.length();
+                            int hyphenIndex = reference.indexOf('-', startIndex);
+                            if (hyphenIndex != -1 && hyphenIndex < endIndex) {
+                                info.from = reference.mid(startIndex, hyphenIndex - startIndex).toInt();
+                                info.to = reference.mid(hyphenIndex + 1, endIndex - hyphenIndex - 1).toInt();
+                            } else {
+                                info.from = reference.mid(startIndex, endIndex - startIndex).toInt();
+                            }
+                        }
+                        info.text = context;
+                        sources.append(info);
+                    }
+
+                    c.sources = sources;
+                    c.consolidatedSources = consolidateSources(sources);
+                }
+            }
+            beginInsertRows(QModelIndex(), m_chatItems.size(), m_chatItems.size());
+            m_chatItems.append(c);
+            endInsertRows();
+        }
+        emit countChanged();
+        return stream.status() == QDataStream::Ok;
+    }
+
+    QVector<QPair<QString, QString>> text() const
+    {
+        QVector<QPair<QString, QString>> result;
+        for (const auto &c : m_chatItems)
+            result << qMakePair(c.name, c.value);
+        return result;
+    }
+
+Q_SIGNALS:
+    void countChanged();
+    void valueChanged(int index, const QString &value);
+
+private:
+
+    QList<ChatItem> m_chatItems;
+};
+
+#endif // CHATMODEL_H

gpt4all-chat/src/chatviewtextprocessor.h

@@ -0,0 +1,131 @@
+#ifndef CHATVIEWTEXTPROCESSOR_H
+#define CHATVIEWTEXTPROCESSOR_H
+
+#include <QColor>
+#include <QObject>
+#include <QQmlEngine>
+#include <QQuickTextDocument> // IWYU pragma: keep
+#include <QRectF>
+#include <QSizeF>
+#include <QString>
+#include <QSyntaxHighlighter>
+#include <QTextObjectInterface>
+#include <QVector>
+
+class QPainter;
+class QTextDocument;
+class QTextFormat;
+
+struct CodeColors {
+    Q_GADGET
+    Q_PROPERTY(QColor defaultColor MEMBER defaultColor)
+    Q_PROPERTY(QColor keywordColor MEMBER keywordColor)
+    Q_PROPERTY(QColor functionColor MEMBER functionColor)
+    Q_PROPERTY(QColor functionCallColor MEMBER functionCallColor)
+    Q_PROPERTY(QColor commentColor MEMBER commentColor)
+    Q_PROPERTY(QColor stringColor MEMBER stringColor)
+    Q_PROPERTY(QColor numberColor MEMBER numberColor)
+    Q_PROPERTY(QColor headerColor MEMBER headerColor)
+    Q_PROPERTY(QColor backgroundColor MEMBER backgroundColor)
+
+public:
+    QColor defaultColor;
+    QColor keywordColor;
+    QColor functionColor;
+    QColor functionCallColor;
+    QColor commentColor;
+    QColor stringColor;
+    QColor numberColor;
+    QColor headerColor;
+    QColor backgroundColor;
+
+    QColor preprocessorColor = keywordColor;
+    QColor typeColor = numberColor;
+    QColor arrowColor = functionColor;
+    QColor commandColor = functionCallColor;
+    QColor variableColor = numberColor;
+    QColor keyColor = functionColor;
+    QColor valueColor = stringColor;
+    QColor parameterColor = stringColor;
+    QColor attributeNameColor = numberColor;
+    QColor attributeValueColor = stringColor;
+    QColor specialCharacterColor = functionColor;
+    QColor doctypeColor = commentColor;
+};
+
+Q_DECLARE_METATYPE(CodeColors)
+
+class SyntaxHighlighter : public QSyntaxHighlighter {
+    Q_OBJECT
+public:
+    SyntaxHighlighter(QObject *parent);
+    ~SyntaxHighlighter();
+    void highlightBlock(const QString &text) override;
+
+    CodeColors codeColors() const { return m_codeColors; }
+    void setCodeColors(const CodeColors &colors) { m_codeColors = colors; }
+
+private:
+    CodeColors m_codeColors;
+};
+
+struct ContextLink {
+    int startPos = -1;
+    int endPos = -1;
+    QString text;
+    QString href;
+};
+
+struct CodeCopy {
+    int startPos = -1;
+    int endPos = -1;
+    QString text;
+};
+
+class ChatViewTextProcessor : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQuickTextDocument* textDocument READ textDocument WRITE setTextDocument NOTIFY textDocumentChanged())
+    Q_PROPERTY(bool shouldProcessText READ shouldProcessText WRITE setShouldProcessText NOTIFY shouldProcessTextChanged())
+    Q_PROPERTY(qreal fontPixelSize READ fontPixelSize WRITE setFontPixelSize NOTIFY fontPixelSizeChanged())
+    Q_PROPERTY(CodeColors codeColors READ codeColors WRITE setCodeColors NOTIFY codeColorsChanged())
+    QML_ELEMENT
+public:
+    explicit ChatViewTextProcessor(QObject *parent = nullptr);
+
+    QQuickTextDocument* textDocument() const;
+    void setTextDocument(QQuickTextDocument* textDocument);
+
+    Q_INVOKABLE void setValue(const QString &value);
+    Q_INVOKABLE bool tryCopyAtPosition(int position) const;
+
+    bool shouldProcessText() const;
+    void setShouldProcessText(bool b);
+
+    qreal fontPixelSize() const;
+    void setFontPixelSize(qreal b);
+
+    CodeColors codeColors() const;
+    void setCodeColors(const CodeColors &colors);
+
+Q_SIGNALS:
+    void textDocumentChanged();
+    void shouldProcessTextChanged();
+    void fontPixelSizeChanged();
+    void codeColorsChanged();
+
+private Q_SLOTS:
+    void handleTextChanged();
+    void handleCodeBlocks();
+    void handleMarkdown();
+
+private:
+    QQuickTextDocument *m_quickTextDocument;
+    SyntaxHighlighter *m_syntaxHighlighter;
+    QVector<ContextLink> m_links;
+    QVector<CodeCopy> m_copies;
+    bool m_shouldProcessText = false;
+    qreal m_fontPixelSize;
+};
+
+#endif // CHATVIEWTEXTPROCESSOR_H

gpt4all-chat/src/database.h

@@ -0,0 +1,238 @@
+#ifndef DATABASE_H
+#define DATABASE_H
+
+#include "embllm.h" // IWYU pragma: keep
+
+#include <QDateTime>
+#include <QFileInfo>
+#include <QHash>
+#include <QLatin1String>
+#include <QList>
+#include <QMap>
+#include <QObject>
+#include <QQueue>
+#include <QSet>
+#include <QSqlDatabase>
+#include <QString>
+#include <QStringList>
+#include <QThread>
+#include <QUrl>
+#include <QVector>
+
+#include <cstddef>
+
+using namespace Qt::Literals::StringLiterals;
+
+class QFileSystemWatcher;
+class QSqlError;
+class QTextStream;
+class QTimer;
+
+/* Version 0: GPT4All v2.4.3, full-text search
+ * Version 1: GPT4All v2.5.3, embeddings in hsnwlib
+ * Version 2: GPT4All v3.0.0, embeddings in sqlite */
+
+// minimum supported version
+static const int LOCALDOCS_MIN_VER = 1;
+// current version
+static const int LOCALDOCS_VERSION = 2;
+
+struct DocumentInfo
+{
+    int folder;
+    QFileInfo doc;
+    int currentPage = 0;
+    size_t currentPosition = 0;
+    bool currentlyProcessing = false;
+    bool isPdf() const {
+        return doc.suffix().compare(u"pdf"_s, Qt::CaseInsensitive) == 0;
+    }
+};
+
+struct ResultInfo {
+    Q_GADGET
+    Q_PROPERTY(QString collection MEMBER collection)
+    Q_PROPERTY(QString path MEMBER path)
+    Q_PROPERTY(QString file MEMBER file)
+    Q_PROPERTY(QString title MEMBER title)
+    Q_PROPERTY(QString author MEMBER author)
+    Q_PROPERTY(QString date MEMBER date)
+    Q_PROPERTY(QString text MEMBER text)
+    Q_PROPERTY(int page MEMBER page)
+    Q_PROPERTY(int from MEMBER from)
+    Q_PROPERTY(int to MEMBER to)
+    Q_PROPERTY(QString fileUri READ fileUri STORED false)
+
+public:
+    QString collection; // [Required] The name of the collection
+    QString path;       // [Required] The full path
+    QString file;       // [Required] The name of the file, but not the full path
+    QString title;      // [Optional] The title of the document
+    QString author;     // [Optional] The author of the document
+    QString date;       // [Required] The creation or the last modification date whichever is latest
+    QString text;       // [Required] The text actually used in the augmented context
+    int page = -1;      // [Optional] The page where the text was found
+    int from = -1;      // [Optional] The line number where the text begins
+    int to = -1;        // [Optional] The line number where the text ends
+
+    QString fileUri() const {
+        // QUrl reserved chars that are not UNSAFE_PATH according to glib/gconvert.c
+        static const QByteArray s_exclude = "!$&'()*+,/:=@~"_ba;
+
+        Q_ASSERT(!QFileInfo(path).isRelative());
+#ifdef Q_OS_WINDOWS
+        Q_ASSERT(!path.contains('\\')); // Qt normally uses forward slash as path separator
+#endif
+
+        auto escaped = QString::fromUtf8(QUrl::toPercentEncoding(path, s_exclude));
+        if (escaped.front() != '/')
+            escaped = '/' + escaped;
+        return u"file://"_s + escaped;
+    }
+
+    bool operator==(const ResultInfo &other) const {
+        return file == other.file &&
+               title == other.title &&
+               author == other.author &&
+               date == other.date &&
+               text == other.text &&
+               page == other.page &&
+               from == other.from &&
+               to == other.to;
+    }
+    bool operator!=(const ResultInfo &other) const {
+        return !(*this == other);
+    }
+};
+
+Q_DECLARE_METATYPE(ResultInfo)
+
+struct CollectionItem {
+    // -- Fields persisted to database --
+
+    int collection_id = -1;
+    int folder_id = -1;
+    QString collection;
+    QString folder_path;
+    QString embeddingModel;
+
+    // -- Transient fields --
+
+    bool installed = false;
+    bool indexing = false;
+    bool forceIndexing = false;
+    QString error;
+
+    // progress
+    int currentDocsToIndex = 0;
+    int totalDocsToIndex = 0;
+    size_t currentBytesToIndex = 0;
+    size_t totalBytesToIndex = 0;
+    size_t currentEmbeddingsToIndex = 0;
+    size_t totalEmbeddingsToIndex = 0;
+
+    // statistics
+    size_t totalDocs = 0;
+    size_t totalWords = 0;
+    size_t totalTokens = 0;
+    QDateTime startUpdate;
+    QDateTime lastUpdate;
+    QString fileCurrentlyProcessing;
+};
+Q_DECLARE_METATYPE(CollectionItem)
+
+class Database : public QObject
+{
+    Q_OBJECT
+public:
+    Database(int chunkSize, QStringList extensions);
+    ~Database() override;
+
+    bool isValid() const { return m_databaseValid; }
+
+public Q_SLOTS:
+    void start();
+    void scanQueueBatch();
+    void scanDocuments(int folder_id, const QString &folder_path);
+    void forceIndexing(const QString &collection, const QString &embedding_model);
+    void forceRebuildFolder(const QString &path);
+    bool addFolder(const QString &collection, const QString &path, const QString &embedding_model);
+    void removeFolder(const QString &collection, const QString &path);
+    void retrieveFromDB(const QList<QString> &collections, const QString &text, int retrievalSize, QList<ResultInfo> *results);
+    void changeChunkSize(int chunkSize);
+    void changeFileExtensions(const QStringList &extensions);
+
+Q_SIGNALS:
+    // Signals for the gui only
+    void requestUpdateGuiForCollectionItem(const CollectionItem &item);
+    void requestAddGuiCollectionItem(const CollectionItem &item);
+    void requestRemoveGuiFolderById(const QString &collection, int folder_id);
+    void requestGuiCollectionListUpdated(const QList<CollectionItem> &collectionList);
+    void databaseValidChanged();
+
+private Q_SLOTS:
+    void directoryChanged(const QString &path);
+    void addCurrentFolders();
+    void handleEmbeddingsGenerated(const QVector<EmbeddingResult> &embeddings);
+    void handleErrorGenerated(const QVector<EmbeddingChunk> &chunks, const QString &error);
+
+private:
+    void transaction();
+    void commit();
+    void rollback();
+
+    bool hasContent();
+    // not found -> 0, , exists and has content -> 1, error -> -1
+    int openDatabase(const QString &modelPath, bool create = true, int ver = LOCALDOCS_VERSION);
+    bool openLatestDb(const QString &modelPath, QList<CollectionItem> &oldCollections);
+    bool initDb(const QString &modelPath, const QList<CollectionItem> &oldCollections);
+    int checkAndAddFolderToDB(const QString &path);
+    bool removeFolderInternal(const QString &collection, int folder_id, const QString &path);
+    size_t chunkStream(QTextStream &stream, int folder_id, int document_id, const QString &embedding_model,
+        const QString &file, const QString &title, const QString &author, const QString &subject,
+        const QString &keywords, int page, int maxChunks = -1);
+    void appendChunk(const EmbeddingChunk &chunk);
+    void sendChunkList();
+    void updateFolderToIndex(int folder_id, size_t countForFolder, bool sendChunks = true);
+    void handleDocumentError(const QString &errorMessage,
+        int document_id, const QString &document_path, const QSqlError &error);
+    size_t countOfDocuments(int folder_id) const;
+    size_t countOfBytes(int folder_id) const;
+    DocumentInfo dequeueDocument();
+    void removeFolderFromDocumentQueue(int folder_id);
+    void enqueueDocumentInternal(const DocumentInfo &info, bool prepend = false);
+    void enqueueDocuments(int folder_id, const QVector<DocumentInfo> &infos);
+    void scanQueue();
+    bool cleanDB();
+    void addFolderToWatch(const QString &path);
+    void removeFolderFromWatch(const QString &path);
+    QList<int> searchEmbeddings(const std::vector<float> &query, const QList<QString> &collections, int nNeighbors);
+
+    void setStartUpdateTime(CollectionItem &item);
+    void setLastUpdateTime(CollectionItem &item);
+
+    CollectionItem guiCollectionItem(int folder_id) const;
+    void updateGuiForCollectionItem(const CollectionItem &item);
+    void addGuiCollectionItem(const CollectionItem &item);
+    void removeGuiFolderById(const QString &collection, int folder_id);
+    void guiCollectionListUpdated(const QList<CollectionItem> &collectionList);
+    void scheduleUncompletedEmbeddings();
+    void updateCollectionStatistics();
+
+private:
+    QSqlDatabase m_db;
+    int m_chunkSize;
+    QStringList m_scannedFileExtensions;
+    QTimer *m_scanTimer;
+    QMap<int, QQueue<DocumentInfo>> m_docsToScan;
+    QList<ResultInfo> m_retrieve;
+    QThread m_dbThread;
+    QFileSystemWatcher *m_watcher;
+    QSet<QString> m_watchedPaths;
+    EmbeddingLLM *m_embLLM;
+    QVector<EmbeddingChunk> m_chunkList;
+    QHash<int, CollectionItem> m_collectionMap; // used only for tracking indexing/embedding progress
+    std::atomic<bool> m_databaseValid;
+};
+
+#endif // DATABASE_H

gpt4all-chat/src/download.cpp

@@ -0,0 +1,702 @@
+#include "download.h"
+
+#include "modellist.h"
+#include "mysettings.h"
+#include "network.h"
+
+#include <QByteArray>
+#include <QCollator>
+#include <QCoreApplication>
+#include <QDebug>
+#include <QGlobalStatic>
+#include <QGuiApplication>
+#include <QIODevice>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QLocale>
+#include <QNetworkRequest>
+#include <QPair>
+#include <QSettings>
+#include <QSslConfiguration>
+#include <QSslSocket>
+#include <QStringList>
+#include <QTextStream>
+#include <QUrl>
+#include <QVariant>
+#include <QVector>
+#include <Qt>
+#include <QtLogging>
+
+#include <algorithm>
+#include <compare>
+#include <cstddef>
+#include <utility>
+
+using namespace Qt::Literals::StringLiterals;
+
+class MyDownload: public Download { };
+Q_GLOBAL_STATIC(MyDownload, downloadInstance)
+Download *Download::globalInstance()
+{
+    return downloadInstance();
+}
+
+Download::Download()
+    : QObject(nullptr)
+    , m_hashAndSave(new HashAndSaveFile)
+{
+    connect(this, &Download::requestHashAndSave, m_hashAndSave,
+        &HashAndSaveFile::hashAndSave, Qt::QueuedConnection);
+    connect(m_hashAndSave, &HashAndSaveFile::hashAndSaveFinished, this,
+        &Download::handleHashAndSaveFinished, Qt::QueuedConnection);
+    connect(&m_networkManager, &QNetworkAccessManager::sslErrors, this,
+        &Download::handleSslErrors);
+    updateLatestNews();
+    updateReleaseNotes();
+    m_startTime = QDateTime::currentDateTime();
+}
+
+static bool operator==(const ReleaseInfo& lhs, const ReleaseInfo& rhs)
+{
+    return lhs.version == rhs.version;
+}
+
+std::strong_ordering Download::compareAppVersions(const QString &a, const QString &b)
+{
+    static QRegularExpression versionRegex(R"(^(\d+(?:\.\d+){0,2})(-.+)?$)");
+
+    // When comparing versions, make sure a2 < a10.
+    QCollator versionCollator(QLocale(QLocale::English, QLocale::UnitedStates));
+    versionCollator.setNumericMode(true);
+
+    QRegularExpressionMatch aMatch = versionRegex.match(a);
+    QRegularExpressionMatch bMatch = versionRegex.match(b);
+
+    Q_ASSERT(aMatch.hasMatch() && bMatch.hasMatch()); // expect valid versions
+
+    // Check for an invalid version. foo < 3.0.0 -> !hasMatch < hasMatch
+    if (auto diff = aMatch.hasMatch() <=> bMatch.hasMatch(); diff != 0)
+        return diff; // invalid version compares as lower
+
+    // Compare invalid versions. fooa < foob
+    if (!aMatch.hasMatch() && !bMatch.hasMatch())
+        return versionCollator.compare(a, b) <=> 0; // lexicographic comparison
+
+    // Compare first three components. 3.0.0 < 3.0.1
+    QStringList aParts = aMatch.captured(1).split('.');
+    QStringList bParts = bMatch.captured(1).split('.');
+    for (int i = 0; i < qMax(aParts.size(), bParts.size()); i++) {
+        bool ok = false;
+        int aInt = aParts.value(i, "0").toInt(&ok);
+        Q_ASSERT(ok);
+        int bInt = bParts.value(i, "0").toInt(&ok);
+        Q_ASSERT(ok);
+        if (auto diff = aInt <=> bInt; diff != 0)
+            return diff; // version with lower component compares as lower
+    }
+
+    // Check for a pre/post-release suffix. 3.0.0-dev0 < 3.0.0-rc1 < 3.0.0 < 3.0.0-post1
+    auto getSuffixOrder = [](const QRegularExpressionMatch &match) -> int {
+        QString suffix = match.captured(2);
+        return suffix.startsWith("-dev") ? 0 :
+               suffix.startsWith("-rc")  ? 1 :
+               suffix.isEmpty()          ? 2 :
+               /* some other suffix */     3;
+    };
+    if (auto diff = getSuffixOrder(aMatch) <=> getSuffixOrder(bMatch); diff != 0)
+        return diff; // different suffix types
+
+    // Lexicographic comparison of suffix. 3.0.0-rc1 < 3.0.0-rc2
+    if (aMatch.hasCaptured(2) && bMatch.hasCaptured(2)) {
+        if (auto diff = versionCollator.compare(aMatch.captured(2), bMatch.captured(2)); diff != 0)
+            return diff <=> 0;
+    }
+
+    return std::strong_ordering::equal;
+}
+
+ReleaseInfo Download::releaseInfo() const
+{
+    const QString currentVersion = QCoreApplication::applicationVersion();
+    if (m_releaseMap.contains(currentVersion))
+        return m_releaseMap.value(currentVersion);
+    if (!m_releaseMap.empty())
+        return m_releaseMap.last();
+    return ReleaseInfo();
+}
+
+bool Download::hasNewerRelease() const
+{
+    const QString currentVersion = QCoreApplication::applicationVersion();
+    for (const auto &version : m_releaseMap.keys()) {
+        if (compareAppVersions(version, currentVersion) > 0)
+            return true;
+    }
+    return false;
+}
+
+bool Download::isFirstStart(bool writeVersion) const
+{
+    auto *mySettings = MySettings::globalInstance();
+
+    QSettings settings;
+    QString lastVersionStarted = settings.value("download/lastVersionStarted").toString();
+    bool first = lastVersionStarted != QCoreApplication::applicationVersion();
+    if (first && writeVersion) {
+        settings.setValue("download/lastVersionStarted", QCoreApplication::applicationVersion());
+        // let the user select these again
+        settings.remove("network/usageStatsActive");
+        settings.remove("network/isActive");
+        emit mySettings->networkUsageStatsActiveChanged();
+        emit mySettings->networkIsActiveChanged();
+    }
+
+    return first || !mySettings->isNetworkUsageStatsActiveSet() || !mySettings->isNetworkIsActiveSet();
+}
+
+void Download::updateReleaseNotes()
+{
+    QUrl jsonUrl("http://gpt4all.io/meta/release.json");
+    QNetworkRequest request(jsonUrl);
+    QSslConfiguration conf = request.sslConfiguration();
+    conf.setPeerVerifyMode(QSslSocket::VerifyNone);
+    request.setSslConfiguration(conf);
+    QNetworkReply *jsonReply = m_networkManager.get(request);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, jsonReply, &QNetworkReply::abort);
+    connect(jsonReply, &QNetworkReply::finished, this, &Download::handleReleaseJsonDownloadFinished);
+}
+
+void Download::updateLatestNews()
+{
+    QUrl url("http://gpt4all.io/meta/latestnews.md");
+    QNetworkRequest request(url);
+    QSslConfiguration conf = request.sslConfiguration();
+    conf.setPeerVerifyMode(QSslSocket::VerifyNone);
+    request.setSslConfiguration(conf);
+    QNetworkReply *reply = m_networkManager.get(request);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, reply, &QNetworkReply::abort);
+    connect(reply, &QNetworkReply::finished, this, &Download::handleLatestNewsDownloadFinished);
+}
+
+void Download::downloadModel(const QString &modelFile)
+{
+    QFile *tempFile = new QFile(ModelList::globalInstance()->incompleteDownloadPath(modelFile));
+    bool success = tempFile->open(QIODevice::WriteOnly | QIODevice::Append);
+    qWarning() << "Opening temp file for writing:" << tempFile->fileName();
+    if (!success) {
+        const QString error
+            = u"ERROR: Could not open temp file: %1 %2"_s.arg(tempFile->fileName(), modelFile);
+        qWarning() << error;
+        clearRetry(modelFile);
+        ModelList::globalInstance()->updateDataByFilename(modelFile, {{ ModelList::DownloadErrorRole, error }});
+        return;
+    }
+    tempFile->flush();
+    size_t incomplete_size = tempFile->size();
+    if (incomplete_size > 0) {
+        bool success = tempFile->seek(incomplete_size);
+        if (!success) {
+            incomplete_size = 0;
+            success = tempFile->seek(incomplete_size);
+            Q_ASSERT(success);
+        }
+    }
+
+    if (!ModelList::globalInstance()->containsByFilename(modelFile)) {
+        qWarning() << "ERROR: Could not find file:" << modelFile;
+        return;
+    }
+
+    ModelList::globalInstance()->updateDataByFilename(modelFile, {{ ModelList::DownloadingRole, true }});
+    ModelInfo info = ModelList::globalInstance()->modelInfoByFilename(modelFile);
+    QString url = !info.url().isEmpty() ? info.url() : "http://gpt4all.io/models/gguf/" + modelFile;
+    Network::globalInstance()->trackEvent("download_started", { {"model", modelFile} });
+    QNetworkRequest request(url);
+    request.setAttribute(QNetworkRequest::User, modelFile);
+    request.setRawHeader("range", u"bytes=%1-"_s.arg(tempFile->pos()).toUtf8());
+    QSslConfiguration conf = request.sslConfiguration();
+    conf.setPeerVerifyMode(QSslSocket::VerifyNone);
+    request.setSslConfiguration(conf);
+    QNetworkReply *modelReply = m_networkManager.get(request);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, modelReply, &QNetworkReply::abort);
+    connect(modelReply, &QNetworkReply::downloadProgress, this, &Download::handleDownloadProgress);
+    connect(modelReply, &QNetworkReply::errorOccurred, this, &Download::handleErrorOccurred);
+    connect(modelReply, &QNetworkReply::finished, this, &Download::handleModelDownloadFinished);
+    connect(modelReply, &QNetworkReply::readyRead, this, &Download::handleReadyRead);
+    m_activeDownloads.insert(modelReply, tempFile);
+}
+
+void Download::cancelDownload(const QString &modelFile)
+{
+    for (auto [modelReply, tempFile]: m_activeDownloads.asKeyValueRange()) {
+        QUrl url = modelReply->request().url();
+        if (url.toString().endsWith(modelFile)) {
+            Network::globalInstance()->trackEvent("download_canceled", { {"model", modelFile} });
+
+            // Disconnect the signals
+            disconnect(modelReply, &QNetworkReply::downloadProgress, this, &Download::handleDownloadProgress);
+            disconnect(modelReply, &QNetworkReply::finished, this, &Download::handleModelDownloadFinished);
+
+            modelReply->abort(); // Abort the download
+            modelReply->deleteLater(); // Schedule the reply for deletion
+
+            tempFile->deleteLater();
+            m_activeDownloads.remove(modelReply);
+
+            ModelList::globalInstance()->updateDataByFilename(modelFile, {{ ModelList::DownloadingRole, false }});
+            break;
+        }
+    }
+}
+
+void Download::installModel(const QString &modelFile, const QString &apiKey)
+{
+    Q_ASSERT(!apiKey.isEmpty());
+    if (apiKey.isEmpty())
+        return;
+
+    Network::globalInstance()->trackEvent("install_model", { {"model", modelFile} });
+
+    QString filePath = MySettings::globalInstance()->modelPath() + modelFile;
+    QFile file(filePath);
+    if (file.open(QIODeviceBase::WriteOnly | QIODeviceBase::Text)) {
+
+        QJsonObject obj;
+        QString modelName(modelFile);
+        modelName.remove(0, 8); // strip "gpt4all-" prefix
+        modelName.chop(7); // strip ".rmodel" extension
+        obj.insert("apiKey", apiKey);
+        obj.insert("modelName", modelName);
+        QJsonDocument doc(obj);
+
+        QTextStream stream(&file);
+        stream << doc.toJson();
+        file.close();
+        ModelList::globalInstance()->updateModelsFromDirectory();
+        emit toastMessage(tr("Model \"%1\" is installed successfully.").arg(modelName));
+    }
+
+    ModelList::globalInstance()->updateDataByFilename(modelFile, {{ ModelList::InstalledRole, true }});
+}
+
+void Download::installCompatibleModel(const QString &modelName, const QString &apiKey, const QString &baseUrl)
+{
+    Q_ASSERT(!modelName.isEmpty());
+    if (modelName.isEmpty()) {
+        emit toastMessage(tr("ERROR: $MODEL_NAME is empty."));
+        return;
+    }
+
+    Q_ASSERT(!apiKey.isEmpty());
+    if (apiKey.isEmpty()) {
+        emit toastMessage(tr("ERROR: $API_KEY is empty."));
+        return;
+    }
+
+    QUrl apiBaseUrl(QUrl::fromUserInput(baseUrl));
+    if (!Network::isHttpUrlValid(baseUrl)) {
+        emit toastMessage(tr("ERROR: $BASE_URL is invalid."));
+        return;
+    }
+
+    QString modelFile(ModelList::compatibleModelFilename(baseUrl, modelName));
+    if (ModelList::globalInstance()->contains(modelFile)) {
+        emit toastMessage(tr("ERROR: Model \"%1 (%2)\" is conflict.").arg(modelName, baseUrl));
+        return;
+    }
+    ModelList::globalInstance()->addModel(modelFile);
+    Network::globalInstance()->trackEvent("install_model", { {"model", modelFile} });
+
+    QString filePath = MySettings::globalInstance()->modelPath() + modelFile;
+    QFile file(filePath);
+    if (file.open(QIODeviceBase::WriteOnly | QIODeviceBase::Text)) {
+        QJsonObject obj;
+        obj.insert("apiKey", apiKey);
+        obj.insert("modelName", modelName);
+        obj.insert("baseUrl", apiBaseUrl.toString());
+        QJsonDocument doc(obj);
+
+        QTextStream stream(&file);
+        stream << doc.toJson();
+        file.close();
+        ModelList::globalInstance()->updateModelsFromDirectory();
+        emit toastMessage(tr("Model \"%1 (%2)\" is installed successfully.").arg(modelName, baseUrl));
+    }
+
+    ModelList::globalInstance()->updateDataByFilename(modelFile, {{ ModelList::InstalledRole, true }});
+}
+
+void Download::removeModel(const QString &modelFile)
+{
+    const QString filePath = MySettings::globalInstance()->modelPath() + modelFile;
+    QFile incompleteFile(ModelList::globalInstance()->incompleteDownloadPath(modelFile));
+    if (incompleteFile.exists()) {
+        incompleteFile.remove();
+    }
+
+    bool shouldRemoveInstalled = false;
+    QFile file(filePath);
+    if (file.exists()) {
+        const ModelInfo info = ModelList::globalInstance()->modelInfoByFilename(modelFile);
+        MySettings::globalInstance()->eraseModel(info);
+        shouldRemoveInstalled = info.installed && !info.isClone() && (info.isDiscovered() || info.isCompatibleApi || info.description() == "" /*indicates sideloaded*/);
+        if (shouldRemoveInstalled)
+            ModelList::globalInstance()->removeInstalled(info);
+        Network::globalInstance()->trackEvent("remove_model", { {"model", modelFile} });
+        file.remove();
+        emit toastMessage(tr("Model \"%1\" is removed.").arg(info.name()));
+    }
+
+    if (!shouldRemoveInstalled) {
+        QVector<QPair<int, QVariant>> data {
+            { ModelList::InstalledRole, false },
+            { ModelList::BytesReceivedRole, 0 },
+            { ModelList::BytesTotalRole, 0 },
+            { ModelList::TimestampRole, 0 },
+            { ModelList::SpeedRole, QString() },
+            { ModelList::DownloadErrorRole, QString() },
+        };
+        ModelList::globalInstance()->updateDataByFilename(modelFile, data);
+    }
+}
+
+void Download::handleSslErrors(QNetworkReply *reply, const QList<QSslError> &errors)
+{
+    QUrl url = reply->request().url();
+    for (const auto &e : errors)
+        qWarning() << "ERROR: Received ssl error:" << e.errorString() << "for" << url;
+}
+
+void Download::handleReleaseJsonDownloadFinished()
+{
+    QNetworkReply *jsonReply = qobject_cast<QNetworkReply *>(sender());
+    if (!jsonReply)
+        return;
+
+    QByteArray jsonData = jsonReply->readAll();
+    jsonReply->deleteLater();
+    parseReleaseJsonFile(jsonData);
+}
+
+void Download::parseReleaseJsonFile(const QByteArray &jsonData)
+{
+    QJsonParseError err;
+    QJsonDocument document = QJsonDocument::fromJson(jsonData, &err);
+    if (err.error != QJsonParseError::NoError) {
+        qWarning() << "ERROR: Couldn't parse: " << jsonData << err.errorString();
+        return;
+    }
+
+    QJsonArray jsonArray = document.array();
+
+    m_releaseMap.clear();
+    for (const QJsonValue &value : jsonArray) {
+        QJsonObject obj = value.toObject();
+
+        QString version = obj["version"].toString();
+        QString notes = obj["notes"].toString();
+        QString contributors = obj["contributors"].toString();
+        ReleaseInfo releaseInfo;
+        releaseInfo.version = version;
+        releaseInfo.notes = notes;
+        releaseInfo.contributors = contributors;
+        m_releaseMap.insert(version, releaseInfo);
+    }
+
+    emit hasNewerReleaseChanged();
+    emit releaseInfoChanged();
+}
+
+void Download::handleLatestNewsDownloadFinished()
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply)
+        return;
+
+    if (reply->error() != QNetworkReply::NoError) {
+        qWarning() << "ERROR: network error occurred attempting to download latest news:" << reply->errorString();
+        reply->deleteLater();
+        return;
+    }
+
+    QByteArray responseData = reply->readAll();
+    m_latestNews = QString::fromUtf8(responseData);
+    reply->deleteLater();
+    emit latestNewsChanged();
+}
+
+bool Download::hasRetry(const QString &filename) const
+{
+    return m_activeRetries.contains(filename);
+}
+
+bool Download::shouldRetry(const QString &filename)
+{
+    int retries = 0;
+    if (m_activeRetries.contains(filename))
+        retries = m_activeRetries.value(filename);
+
+    ++retries;
+
+    // Allow up to ten retries for now
+    if (retries < 10) {
+        m_activeRetries.insert(filename, retries);
+        return true;
+    }
+
+    return false;
+}
+
+void Download::clearRetry(const QString &filename)
+{
+    m_activeRetries.remove(filename);
+}
+
+void Download::handleErrorOccurred(QNetworkReply::NetworkError code)
+{
+    QNetworkReply *modelReply = qobject_cast<QNetworkReply *>(sender());
+    if (!modelReply)
+        return;
+
+    // This occurs when the user explicitly cancels the download
+    if (code == QNetworkReply::OperationCanceledError)
+        return;
+
+    QString modelFilename = modelReply->request().attribute(QNetworkRequest::User).toString();
+    if (shouldRetry(modelFilename)) {
+        downloadModel(modelFilename);
+        return;
+    }
+
+    clearRetry(modelFilename);
+
+    const QString error
+        = u"ERROR: Network error occurred attempting to download %1 code: %2 errorString %3"_s
+            .arg(modelFilename)
+            .arg(code)
+            .arg(modelReply->errorString());
+    qWarning() << error;
+    ModelList::globalInstance()->updateDataByFilename(modelFilename, {{ ModelList::DownloadErrorRole, error }});
+    Network::globalInstance()->trackEvent("download_error", {
+        {"model", modelFilename},
+        {"code", (int)code},
+        {"error", modelReply->errorString()},
+    });
+    cancelDownload(modelFilename);
+}
+
+void Download::handleDownloadProgress(qint64 bytesReceived, qint64 bytesTotal)
+{
+    QNetworkReply *modelReply = qobject_cast<QNetworkReply *>(sender());
+    if (!modelReply)
+        return;
+    QFile *tempFile = m_activeDownloads.value(modelReply);
+    if (!tempFile)
+        return;
+    QString contentRange = modelReply->rawHeader("content-range");
+    if (contentRange.contains("/")) {
+        QString contentTotalSize = contentRange.split("/").last();
+        bytesTotal = contentTotalSize.toLongLong();
+    }
+
+    const QString modelFilename = modelReply->request().attribute(QNetworkRequest::User).toString();
+    const qint64 lastUpdate = ModelList::globalInstance()->dataByFilename(modelFilename, ModelList::TimestampRole).toLongLong();
+    const qint64 currentUpdate = QDateTime::currentMSecsSinceEpoch();
+    if (currentUpdate - lastUpdate < 1000)
+        return;
+
+    const qint64 lastBytesReceived = ModelList::globalInstance()->dataByFilename(modelFilename, ModelList::BytesReceivedRole).toLongLong();
+    const qint64 currentBytesReceived = tempFile->pos();
+
+    qint64 timeDifference = currentUpdate - lastUpdate;
+    qint64 bytesDifference = currentBytesReceived - lastBytesReceived;
+    qint64 speed = (bytesDifference / timeDifference) * 1000; // bytes per second
+    QString speedText;
+    if (speed < 1024)
+        speedText = QString::number(static_cast<double>(speed), 'f', 2) + " B/s";
+    else if (speed < 1024 * 1024)
+        speedText = QString::number(static_cast<double>(speed / 1024.0), 'f', 2) + " KB/s";
+    else
+        speedText = QString::number(static_cast<double>(speed / (1024.0 * 1024.0)), 'f', 2) + " MB/s";
+
+    QVector<QPair<int, QVariant>> data {
+        { ModelList::BytesReceivedRole, currentBytesReceived },
+        { ModelList::BytesTotalRole, bytesTotal },
+        { ModelList::SpeedRole, speedText },
+        { ModelList::TimestampRole, currentUpdate },
+    };
+    ModelList::globalInstance()->updateDataByFilename(modelFilename, data);
+}
+
+HashAndSaveFile::HashAndSaveFile()
+    : QObject(nullptr)
+{
+    moveToThread(&m_hashAndSaveThread);
+    m_hashAndSaveThread.setObjectName("hashandsave thread");
+    m_hashAndSaveThread.start();
+}
+
+void HashAndSaveFile::hashAndSave(const QString &expectedHash, QCryptographicHash::Algorithm a,
+    const QString &saveFilePath, QFile *tempFile, QNetworkReply *modelReply)
+{
+    Q_ASSERT(!tempFile->isOpen());
+    QString modelFilename = modelReply->request().attribute(QNetworkRequest::User).toString();
+
+    // Reopen the tempFile for hashing
+    if (!tempFile->open(QIODevice::ReadOnly)) {
+        const QString error
+            = u"ERROR: Could not open temp file for hashing: %1 %2"_s.arg(tempFile->fileName(), modelFilename);
+        qWarning() << error;
+        emit hashAndSaveFinished(false, error, tempFile, modelReply);
+        return;
+    }
+
+    QCryptographicHash hash(a);
+    while(!tempFile->atEnd())
+        hash.addData(tempFile->read(16384));
+    if (hash.result().toHex() != expectedHash.toLatin1()) {
+        tempFile->close();
+        const QString error
+            = u"ERROR: Download error hash did not match: %1 != %2 for %3"_s
+                .arg(hash.result().toHex(), expectedHash.toLatin1(), modelFilename);
+        qWarning() << error;
+        tempFile->remove();
+        emit hashAndSaveFinished(false, error, tempFile, modelReply);
+        return;
+    }
+
+    // The file save needs the tempFile closed
+    tempFile->close();
+
+    // Attempt to *move* the verified tempfile into place - this should be atomic
+    // but will only work if the destination is on the same filesystem
+    if (tempFile->rename(saveFilePath)) {
+        emit hashAndSaveFinished(true, QString(), tempFile, modelReply);
+        ModelList::globalInstance()->updateModelsFromDirectory();
+        return;
+    }
+
+    // Reopen the tempFile for copying
+    if (!tempFile->open(QIODevice::ReadOnly)) {
+        const QString error
+            = u"ERROR: Could not open temp file at finish: %1 %2"_s.arg(tempFile->fileName(), modelFilename);
+        qWarning() << error;
+        emit hashAndSaveFinished(false, error, tempFile, modelReply);
+        return;
+    }
+
+    // Save the model file to disk
+    QFile file(saveFilePath);
+    if (file.open(QIODevice::WriteOnly)) {
+        QByteArray buffer;
+        while (!tempFile->atEnd()) {
+            buffer = tempFile->read(16384);
+            file.write(buffer);
+        }
+        file.close();
+        tempFile->close();
+        emit hashAndSaveFinished(true, QString(), tempFile, modelReply);
+    } else {
+        QFile::FileError error = file.error();
+        const QString errorString
+            = u"ERROR: Could not save model to location: %1 failed with code %1"_s.arg(saveFilePath).arg(error);
+        qWarning() << errorString;
+        tempFile->close();
+        emit hashAndSaveFinished(false, errorString, tempFile, modelReply);
+    }
+
+    ModelList::globalInstance()->updateModelsFromDirectory();
+}
+
+void Download::handleModelDownloadFinished()
+{
+    QNetworkReply *modelReply = qobject_cast<QNetworkReply *>(sender());
+    if (!modelReply)
+        return;
+
+    QString modelFilename = modelReply->request().attribute(QNetworkRequest::User).toString();
+    QFile *tempFile = m_activeDownloads.value(modelReply);
+    m_activeDownloads.remove(modelReply);
+
+    if (modelReply->error()) {
+        const QString errorString
+            = u"ERROR: Downloading failed with code %1 \"%2\""_s.arg(modelReply->error()).arg(modelReply->errorString());
+        qWarning() << errorString;
+        modelReply->deleteLater();
+        tempFile->deleteLater();
+        if (!hasRetry(modelFilename)) {
+            QVector<QPair<int, QVariant>> data {
+                { ModelList::DownloadingRole, false },
+                { ModelList::DownloadErrorRole, errorString },
+            };
+            ModelList::globalInstance()->updateDataByFilename(modelFilename, data);
+        }
+        return;
+    }
+
+    clearRetry(modelFilename);
+
+    // The hash and save needs the tempFile closed
+    tempFile->close();
+
+    if (!ModelList::globalInstance()->containsByFilename(modelFilename)) {
+        qWarning() << "ERROR: downloading no such file:" << modelFilename;
+        modelReply->deleteLater();
+        tempFile->deleteLater();
+        return;
+    }
+
+    // Notify that we are calculating hash
+    ModelList::globalInstance()->updateDataByFilename(modelFilename, {{ ModelList::CalcHashRole, true }});
+    QByteArray hash =  ModelList::globalInstance()->modelInfoByFilename(modelFilename).hash;
+    ModelInfo::HashAlgorithm hashAlgorithm =  ModelList::globalInstance()->modelInfoByFilename(modelFilename).hashAlgorithm;
+    const QString saveFilePath = MySettings::globalInstance()->modelPath() + modelFilename;
+    emit requestHashAndSave(hash,
+        (hashAlgorithm == ModelInfo::Md5 ? QCryptographicHash::Md5 : QCryptographicHash::Sha256),
+        saveFilePath, tempFile, modelReply);
+}
+
+void Download::handleHashAndSaveFinished(bool success, const QString &error,
+        QFile *tempFile, QNetworkReply *modelReply)
+{
+    // The hash and save should send back with tempfile closed
+    Q_ASSERT(!tempFile->isOpen());
+    QString modelFilename = modelReply->request().attribute(QNetworkRequest::User).toString();
+    Network::globalInstance()->trackEvent("download_finished", { {"model", modelFilename}, {"success", success} });
+
+    QVector<QPair<int, QVariant>> data {
+        { ModelList::CalcHashRole, false },
+        { ModelList::DownloadingRole, false },
+    };
+
+    modelReply->deleteLater();
+    tempFile->deleteLater();
+
+    if (!success) {
+        data.append({ ModelList::DownloadErrorRole, error });
+    } else {
+        data.append({ ModelList::DownloadErrorRole, QString() });
+        ModelInfo info = ModelList::globalInstance()->modelInfoByFilename(modelFilename);
+        if (info.isDiscovered())
+            ModelList::globalInstance()->updateDiscoveredInstalled(info);
+    }
+
+    ModelList::globalInstance()->updateDataByFilename(modelFilename, data);
+}
+
+void Download::handleReadyRead()
+{
+    QNetworkReply *modelReply = qobject_cast<QNetworkReply *>(sender());
+    if (!modelReply)
+        return;
+
+    QFile *tempFile = m_activeDownloads.value(modelReply);
+    QByteArray buffer;
+    while (!modelReply->atEnd()) {
+        buffer = modelReply->read(16384);
+        tempFile->write(buffer);
+    }
+    tempFile->flush();
+}

gpt4all-chat/src/download.h

@@ -0,0 +1,115 @@
+#ifndef DOWNLOAD_H
+#define DOWNLOAD_H
+
+#include <QCryptographicHash>
+#include <QDateTime>
+#include <QFile>
+#include <QHash>
+#include <QList>
+#include <QMap>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QObject>
+#include <QSslError>
+#include <QString>
+#include <QThread>
+#include <QtGlobal>
+
+class QByteArray;
+
+struct ReleaseInfo {
+    Q_GADGET
+    Q_PROPERTY(QString version MEMBER version)
+    Q_PROPERTY(QString notes MEMBER notes)
+    Q_PROPERTY(QString contributors MEMBER contributors)
+
+public:
+    QString version;
+    QString notes;
+    QString contributors;
+};
+
+class HashAndSaveFile : public QObject
+{
+    Q_OBJECT
+public:
+    HashAndSaveFile();
+
+public Q_SLOTS:
+    void hashAndSave(const QString &hash, QCryptographicHash::Algorithm a, const QString &saveFilePath,
+        QFile *tempFile, QNetworkReply *modelReply);
+
+Q_SIGNALS:
+    void hashAndSaveFinished(bool success, const QString &error,
+        QFile *tempFile, QNetworkReply *modelReply);
+
+private:
+    QThread m_hashAndSaveThread;
+};
+
+class Download : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool hasNewerRelease READ hasNewerRelease NOTIFY hasNewerReleaseChanged)
+    Q_PROPERTY(ReleaseInfo releaseInfo READ releaseInfo NOTIFY releaseInfoChanged)
+    Q_PROPERTY(QString latestNews READ latestNews NOTIFY latestNewsChanged)
+
+public:
+    static Download *globalInstance();
+
+    static std::strong_ordering compareAppVersions(const QString &a, const QString &b);
+    ReleaseInfo releaseInfo() const;
+    bool hasNewerRelease() const;
+    QString latestNews() const { return m_latestNews; }
+    Q_INVOKABLE void downloadModel(const QString &modelFile);
+    Q_INVOKABLE void cancelDownload(const QString &modelFile);
+    Q_INVOKABLE void installModel(const QString &modelFile, const QString &apiKey);
+    Q_INVOKABLE void installCompatibleModel(const QString &modelName, const QString &apiKey, const QString &baseUrl);
+    Q_INVOKABLE void removeModel(const QString &modelFile);
+    Q_INVOKABLE bool isFirstStart(bool writeVersion = false) const;
+
+public Q_SLOTS:
+    void updateLatestNews();
+    void updateReleaseNotes();
+
+private Q_SLOTS:
+    void handleSslErrors(QNetworkReply *reply, const QList<QSslError> &errors);
+    void handleReleaseJsonDownloadFinished();
+    void handleLatestNewsDownloadFinished();
+    void handleErrorOccurred(QNetworkReply::NetworkError code);
+    void handleDownloadProgress(qint64 bytesReceived, qint64 bytesTotal);
+    void handleModelDownloadFinished();
+    void handleHashAndSaveFinished(bool success, const QString &error,
+        QFile *tempFile, QNetworkReply *modelReply);
+    void handleReadyRead();
+
+Q_SIGNALS:
+    void releaseInfoChanged();
+    void hasNewerReleaseChanged();
+    void requestHashAndSave(const QString &hash, QCryptographicHash::Algorithm a, const QString &saveFilePath,
+        QFile *tempFile, QNetworkReply *modelReply);
+    void latestNewsChanged();
+    void toastMessage(const QString &message);
+
+private:
+    void parseReleaseJsonFile(const QByteArray &jsonData);
+    QString incompleteDownloadPath(const QString &modelFile);
+    bool hasRetry(const QString &filename) const;
+    bool shouldRetry(const QString &filename);
+    void clearRetry(const QString &filename);
+
+    HashAndSaveFile *m_hashAndSave;
+    QMap<QString, ReleaseInfo> m_releaseMap;
+    QString m_latestNews;
+    QNetworkAccessManager m_networkManager;
+    QMap<QNetworkReply*, QFile*> m_activeDownloads;
+    QHash<QString, int> m_activeRetries;
+    QDateTime m_startTime;
+
+private:
+    explicit Download();
+    ~Download() {}
+    friend class MyDownload;
+};
+
+#endif // DOWNLOAD_H

gpt4all-chat/src/embllm.cpp

@@ -0,0 +1,434 @@
+#include "embllm.h"
+
+#include "modellist.h"
+#include "mysettings.h"
+
+#include <gpt4all-backend/llmodel.h>
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QFile>
+#include <QFileInfo>
+#include <QGuiApplication>
+#include <QIODevice>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QList>
+#include <QMutexLocker>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QUrl>
+#include <Qt>
+#include <QtGlobal>
+#include <QtLogging>
+
+#include <exception>
+#include <utility>
+#include <vector>
+
+using namespace Qt::Literals::StringLiterals;
+
+static const QString EMBEDDING_MODEL_NAME = u"nomic-embed-text-v1.5"_s;
+static const QString LOCAL_EMBEDDING_MODEL = u"nomic-embed-text-v1.5.f16.gguf"_s;
+
+EmbeddingLLMWorker::EmbeddingLLMWorker()
+    : QObject(nullptr)
+    , m_networkManager(new QNetworkAccessManager(this))
+    , m_stopGenerating(false)
+{
+    moveToThread(&m_workerThread);
+    connect(this, &EmbeddingLLMWorker::requestAtlasQueryEmbedding, this, &EmbeddingLLMWorker::atlasQueryEmbeddingRequested);
+    connect(this, &EmbeddingLLMWorker::finished, &m_workerThread, &QThread::quit, Qt::DirectConnection);
+    m_workerThread.setObjectName("embedding");
+    m_workerThread.start();
+}
+
+EmbeddingLLMWorker::~EmbeddingLLMWorker()
+{
+    m_stopGenerating = true;
+    m_workerThread.quit();
+    m_workerThread.wait();
+
+    if (m_model) {
+        delete m_model;
+        m_model = nullptr;
+    }
+}
+
+void EmbeddingLLMWorker::wait()
+{
+    m_workerThread.wait();
+}
+
+bool EmbeddingLLMWorker::loadModel()
+{
+    constexpr int n_ctx = 2048;
+
+    m_nomicAPIKey.clear();
+    m_model = nullptr;
+
+    // TODO(jared): react to setting changes without restarting
+
+    if (MySettings::globalInstance()->localDocsUseRemoteEmbed()) {
+        m_nomicAPIKey = MySettings::globalInstance()->localDocsNomicAPIKey();
+        return true;
+    }
+
+#ifdef Q_OS_DARWIN
+    static const QString embPathFmt = u"%1/../Resources/%2"_s;
+#else
+    static const QString embPathFmt = u"%1/../resources/%2"_s;
+#endif
+
+    QString filePath = embPathFmt.arg(QCoreApplication::applicationDirPath(), LOCAL_EMBEDDING_MODEL);
+    if (!QFileInfo::exists(filePath)) {
+        qWarning() << "embllm WARNING: Local embedding model not found";
+        return false;
+    }
+
+    QString requestedDevice = MySettings::globalInstance()->localDocsEmbedDevice();
+    std::string backend = "auto";
+#ifdef Q_OS_MAC
+    if (requestedDevice == "Auto" || requestedDevice == "CPU")
+        backend = "cpu";
+#else
+    if (requestedDevice.startsWith("CUDA: "))
+        backend = "cuda";
+#endif
+
+    try {
+        m_model = LLModel::Implementation::construct(filePath.toStdString(), backend, n_ctx);
+    } catch (const std::exception &e) {
+        qWarning() << "embllm WARNING: Could not load embedding model:" << e.what();
+        return false;
+    }
+
+    bool actualDeviceIsCPU = true;
+
+#if defined(Q_OS_MAC) && defined(__aarch64__)
+    if (m_model->implementation().buildVariant() == "metal")
+        actualDeviceIsCPU = false;
+#else
+    if (requestedDevice != "CPU") {
+        const LLModel::GPUDevice *device = nullptr;
+        std::vector<LLModel::GPUDevice> availableDevices = m_model->availableGPUDevices(0);
+        if (requestedDevice != "Auto") {
+            // Use the selected device
+            for (const LLModel::GPUDevice &d : availableDevices) {
+                if (QString::fromStdString(d.selectionName()) == requestedDevice) {
+                    device = &d;
+                    break;
+                }
+            }
+        }
+
+        std::string unavail_reason;
+        if (!device) {
+            // GPU not available
+        } else if (!m_model->initializeGPUDevice(device->index, &unavail_reason)) {
+            qWarning().noquote() << "embllm WARNING: Did not use GPU:" << QString::fromStdString(unavail_reason);
+        } else {
+            actualDeviceIsCPU = false;
+        }
+    }
+#endif
+
+    bool success = m_model->loadModel(filePath.toStdString(), n_ctx, 100);
+
+    // CPU fallback
+    if (!actualDeviceIsCPU && !success) {
+        // llama_init_from_file returned nullptr
+        qWarning() << "embllm WARNING: Did not use GPU: GPU loading failed (out of VRAM?)";
+
+        if (backend == "cuda") {
+            // For CUDA, make sure we don't use the GPU at all - ngl=0 still offloads matmuls
+            try {
+                m_model = LLModel::Implementation::construct(filePath.toStdString(), "auto", n_ctx);
+            } catch (const std::exception &e) {
+                qWarning() << "embllm WARNING: Could not load embedding model:" << e.what();
+                return false;
+            }
+        }
+
+        success = m_model->loadModel(filePath.toStdString(), n_ctx, 0);
+    }
+
+    if (!success) {
+        qWarning() << "embllm WARNING: Could not load embedding model";
+        delete m_model;
+        m_model = nullptr;
+        return false;
+    }
+
+    if (!m_model->supportsEmbedding()) {
+        qWarning() << "embllm WARNING: Model type does not support embeddings";
+        delete m_model;
+        m_model = nullptr;
+        return false;
+    }
+
+    // FIXME(jared): the user may want this to take effect without having to restart
+    int n_threads = MySettings::globalInstance()->threadCount();
+    m_model->setThreadCount(n_threads);
+
+    return true;
+}
+
+std::vector<float> EmbeddingLLMWorker::generateQueryEmbedding(const QString &text)
+{
+    {
+        QMutexLocker locker(&m_mutex);
+
+        if (!hasModel() && !loadModel()) {
+            qWarning() << "WARNING: Could not load model for embeddings";
+            return {};
+        }
+
+        if (!isNomic()) {
+            std::vector<float> embedding(m_model->embeddingSize());
+
+            try {
+                m_model->embed({text.toStdString()}, embedding.data(), /*isRetrieval*/ true);
+            } catch (const std::exception &e) {
+                qWarning() << "WARNING: LLModel::embed failed:" << e.what();
+                return {};
+            }
+
+            return embedding;
+        }
+    }
+
+    EmbeddingLLMWorker worker;
+    emit worker.requestAtlasQueryEmbedding(text);
+    worker.wait();
+    return worker.lastResponse();
+}
+
+void EmbeddingLLMWorker::sendAtlasRequest(const QStringList &texts, const QString &taskType, const QVariant &userData)
+{
+    QJsonObject root;
+    root.insert("model", "nomic-embed-text-v1");
+    root.insert("texts", QJsonArray::fromStringList(texts));
+    root.insert("task_type", taskType);
+
+    QJsonDocument doc(root);
+
+    QUrl nomicUrl("https://api-atlas.nomic.ai/v1/embedding/text");
+    const QString authorization = u"Bearer %1"_s.arg(m_nomicAPIKey).trimmed();
+    QNetworkRequest request(nomicUrl);
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+    request.setRawHeader("Authorization", authorization.toUtf8());
+    request.setAttribute(QNetworkRequest::User, userData);
+    QNetworkReply *reply = m_networkManager->post(request, doc.toJson(QJsonDocument::Compact));
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, reply, &QNetworkReply::abort);
+    connect(reply, &QNetworkReply::finished, this, &EmbeddingLLMWorker::handleFinished);
+}
+
+void EmbeddingLLMWorker::atlasQueryEmbeddingRequested(const QString &text)
+{
+    {
+        QMutexLocker locker(&m_mutex);
+        if (!hasModel() && !loadModel()) {
+            qWarning() << "WARNING: Could not load model for embeddings";
+            return;
+        }
+
+        if (!isNomic()) {
+            qWarning() << "WARNING: Request to generate sync embeddings for local model invalid";
+            return;
+        }
+
+        Q_ASSERT(hasModel());
+    }
+
+    sendAtlasRequest({text}, "search_query");
+}
+
+void EmbeddingLLMWorker::docEmbeddingsRequested(const QVector<EmbeddingChunk> &chunks)
+{
+    if (m_stopGenerating)
+        return;
+
+    bool isNomic;
+    {
+        QMutexLocker locker(&m_mutex);
+        if (!hasModel() && !loadModel()) {
+            qWarning() << "WARNING: Could not load model for embeddings";
+            return;
+        }
+
+        isNomic = this->isNomic();
+    }
+
+    if (!isNomic) {
+        QVector<EmbeddingResult> results;
+        results.reserve(chunks.size());
+        std::vector<std::string> texts;
+        texts.reserve(chunks.size());
+        for (const auto &c: chunks) {
+            EmbeddingResult result;
+            result.model = c.model;
+            result.folder_id = c.folder_id;
+            result.chunk_id = c.chunk_id;
+            result.embedding.resize(m_model->embeddingSize());
+            results << result;
+            texts.push_back(c.chunk.toStdString());
+        }
+
+        constexpr int BATCH_SIZE = 4;
+        std::vector<float> result;
+        result.resize(chunks.size() * m_model->embeddingSize());
+        for (int j = 0; j < chunks.size(); j += BATCH_SIZE) {
+            QMutexLocker locker(&m_mutex);
+            std::vector batchTexts(texts.begin() + j, texts.begin() + std::min(j + BATCH_SIZE, int(texts.size())));
+            try {
+                m_model->embed(batchTexts, result.data() + j * m_model->embeddingSize(), /*isRetrieval*/ false);
+            } catch (const std::exception &e) {
+                qWarning() << "WARNING: LLModel::embed failed:" << e.what();
+                return;
+            }
+        }
+        for (int i = 0; i < chunks.size(); i++)
+            memcpy(results[i].embedding.data(), &result[i * m_model->embeddingSize()], m_model->embeddingSize() * sizeof(float));
+
+        emit embeddingsGenerated(results);
+        return;
+    };
+
+    QStringList texts;
+    for (auto &c: chunks)
+        texts.append(c.chunk);
+    sendAtlasRequest(texts, "search_document", QVariant::fromValue(chunks));
+}
+
+std::vector<float> jsonArrayToVector(const QJsonArray &jsonArray)
+{
+    std::vector<float> result;
+
+    for (const auto &innerValue: jsonArray) {
+        if (innerValue.isArray()) {
+            QJsonArray innerArray = innerValue.toArray();
+            result.reserve(result.size() + innerArray.size());
+            for (const auto &value: innerArray) {
+                result.push_back(static_cast<float>(value.toDouble()));
+            }
+        }
+    }
+
+    return result;
+}
+
+QVector<EmbeddingResult> jsonArrayToEmbeddingResults(const QVector<EmbeddingChunk>& chunks, const QJsonArray& embeddings)
+{
+    QVector<EmbeddingResult> results;
+
+    if (chunks.size() != embeddings.size()) {
+        qWarning() << "WARNING: Size of json array result does not match input!";
+        return results;
+    }
+
+    for (int i = 0; i < chunks.size(); ++i) {
+        const EmbeddingChunk& chunk = chunks.at(i);
+        const QJsonArray embeddingArray = embeddings.at(i).toArray();
+
+        std::vector<float> embeddingVector;
+        for (const auto &value: embeddingArray)
+            embeddingVector.push_back(static_cast<float>(value.toDouble()));
+
+        EmbeddingResult result;
+        result.model = chunk.model;
+        result.folder_id = chunk.folder_id;
+        result.chunk_id = chunk.chunk_id;
+        result.embedding = std::move(embeddingVector);
+        results.push_back(std::move(result));
+    }
+
+    return results;
+}
+
+void EmbeddingLLMWorker::handleFinished()
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply)
+        return;
+
+    QVariant retrievedData = reply->request().attribute(QNetworkRequest::User);
+    QVector<EmbeddingChunk> chunks;
+    if (retrievedData.isValid() && retrievedData.canConvert<QVector<EmbeddingChunk>>())
+        chunks = retrievedData.value<QVector<EmbeddingChunk>>();
+
+    QVariant response = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    Q_ASSERT(response.isValid());
+    bool ok;
+    int code = response.toInt(&ok);
+    if (!ok || code != 200) {
+        QString errorDetails;
+        QString replyErrorString = reply->errorString().trimmed();
+        QByteArray replyContent = reply->readAll().trimmed();
+        errorDetails = u"ERROR: Nomic Atlas responded with error code \"%1\""_s.arg(code);
+        if (!replyErrorString.isEmpty())
+            errorDetails += u". Error Details: \"%1\""_s.arg(replyErrorString);
+        if (!replyContent.isEmpty())
+            errorDetails += u". Response Content: \"%1\""_s.arg(QString::fromUtf8(replyContent));
+        qWarning() << errorDetails;
+        emit errorGenerated(chunks, errorDetails);
+        return;
+    }
+
+    QByteArray jsonData = reply->readAll();
+
+    QJsonParseError err;
+    QJsonDocument document = QJsonDocument::fromJson(jsonData, &err);
+    if (err.error != QJsonParseError::NoError) {
+        qWarning() << "ERROR: Couldn't parse Nomic Atlas response:" << jsonData << err.errorString();
+        return;
+    }
+
+    const QJsonObject root = document.object();
+    const QJsonArray embeddings = root.value("embeddings").toArray();
+
+    if (!chunks.isEmpty()) {
+        emit embeddingsGenerated(jsonArrayToEmbeddingResults(chunks, embeddings));
+    } else {
+        m_lastResponse = jsonArrayToVector(embeddings);
+        emit finished();
+    }
+
+    reply->deleteLater();
+}
+
+EmbeddingLLM::EmbeddingLLM()
+    : QObject(nullptr)
+    , m_embeddingWorker(new EmbeddingLLMWorker)
+{
+    connect(this, &EmbeddingLLM::requestDocEmbeddings, m_embeddingWorker,
+        &EmbeddingLLMWorker::docEmbeddingsRequested, Qt::QueuedConnection);
+    connect(m_embeddingWorker, &EmbeddingLLMWorker::embeddingsGenerated, this,
+        &EmbeddingLLM::embeddingsGenerated, Qt::QueuedConnection);
+    connect(m_embeddingWorker, &EmbeddingLLMWorker::errorGenerated, this,
+        &EmbeddingLLM::errorGenerated, Qt::QueuedConnection);
+}
+
+EmbeddingLLM::~EmbeddingLLM()
+{
+    delete m_embeddingWorker;
+    m_embeddingWorker = nullptr;
+}
+
+QString EmbeddingLLM::model()
+{
+    return EMBEDDING_MODEL_NAME;
+}
+
+// TODO(jared): embed using all necessary embedding models given collection
+std::vector<float> EmbeddingLLM::generateQueryEmbedding(const QString &text)
+{
+    return m_embeddingWorker->generateQueryEmbedding(text);
+}
+
+void EmbeddingLLM::generateDocEmbeddingsAsync(const QVector<EmbeddingChunk> &chunks)
+{
+    emit requestDocEmbeddings(chunks);
+}

gpt4all-chat/src/embllm.h

@@ -0,0 +1,100 @@
+#ifndef EMBLLM_H
+#define EMBLLM_H
+
+#include <QByteArray>
+#include <QMutex>
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QThread>
+#include <QVariant>
+#include <QVector>
+
+#include <atomic>
+#include <vector>
+
+class LLModel;
+class QNetworkAccessManager;
+
+struct EmbeddingChunk {
+    QString model; // TODO(jared): use to select model
+    int folder_id;
+    int chunk_id;
+    QString chunk;
+};
+
+Q_DECLARE_METATYPE(EmbeddingChunk)
+
+struct EmbeddingResult {
+    QString model;
+    int folder_id;
+    int chunk_id;
+    std::vector<float> embedding;
+};
+
+class EmbeddingLLMWorker : public QObject {
+    Q_OBJECT
+public:
+    EmbeddingLLMWorker();
+    ~EmbeddingLLMWorker() override;
+
+    void wait();
+
+    std::vector<float> lastResponse() const { return m_lastResponse; }
+
+    bool loadModel();
+    bool isNomic() const { return !m_nomicAPIKey.isEmpty(); }
+    bool hasModel() const { return isNomic() || m_model; }
+
+    std::vector<float> generateQueryEmbedding(const QString &text);
+
+public Q_SLOTS:
+    void atlasQueryEmbeddingRequested(const QString &text);
+    void docEmbeddingsRequested(const QVector<EmbeddingChunk> &chunks);
+
+Q_SIGNALS:
+    void requestAtlasQueryEmbedding(const QString &text);
+    void embeddingsGenerated(const QVector<EmbeddingResult> &embeddings);
+    void errorGenerated(const QVector<EmbeddingChunk> &chunks, const QString &error);
+    void finished();
+
+private Q_SLOTS:
+    void handleFinished();
+
+private:
+    void sendAtlasRequest(const QStringList &texts, const QString &taskType, const QVariant &userData = {});
+
+    QString m_nomicAPIKey;
+    QNetworkAccessManager *m_networkManager;
+    std::vector<float> m_lastResponse;
+    LLModel *m_model = nullptr;
+    std::atomic<bool> m_stopGenerating;
+    QThread m_workerThread;
+    QMutex m_mutex; // guards m_model and m_nomicAPIKey
+};
+
+class EmbeddingLLM : public QObject
+{
+    Q_OBJECT
+public:
+    EmbeddingLLM();
+    ~EmbeddingLLM() override;
+
+    static QString model();
+    bool loadModel();
+    bool hasModel() const;
+
+public Q_SLOTS:
+    std::vector<float> generateQueryEmbedding(const QString &text); // synchronous
+    void generateDocEmbeddingsAsync(const QVector<EmbeddingChunk> &chunks);
+
+Q_SIGNALS:
+    void requestDocEmbeddings(const QVector<EmbeddingChunk> &chunks);
+    void embeddingsGenerated(const QVector<EmbeddingResult> &embeddings);
+    void errorGenerated(const QVector<EmbeddingChunk> &chunks, const QString &error);
+
+private:
+    EmbeddingLLMWorker *m_embeddingWorker;
+};
+
+#endif // EMBLLM_H

gpt4all-chat/src/llm.cpp

@@ -0,0 +1,107 @@
+#include "llm.h"
+
+#include <gpt4all-backend/llmodel.h>
+#include <gpt4all-backend/sysinfo.h>
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QFileInfo>
+#include <QGlobalStatic>
+#include <QNetworkInformation>
+#include <QProcess>
+#include <QSettings>
+#include <QUrl>
+#include <QtLogging>
+
+#ifdef GPT4ALL_OFFLINE_INSTALLER
+#   include <QDesktopServices>
+#else
+#   include "network.h"
+#endif
+
+using namespace Qt::Literals::StringLiterals;
+
+class MyLLM: public LLM { };
+Q_GLOBAL_STATIC(MyLLM, llmInstance)
+LLM *LLM::globalInstance()
+{
+    return llmInstance();
+}
+
+LLM::LLM()
+    : QObject{nullptr}
+    , m_compatHardware(LLModel::Implementation::hasSupportedCPU())
+{
+    QNetworkInformation::loadDefaultBackend();
+    auto * netinfo = QNetworkInformation::instance();
+    if (netinfo) {
+        connect(netinfo, &QNetworkInformation::reachabilityChanged,
+            this, &LLM::isNetworkOnlineChanged);
+    }
+}
+
+bool LLM::hasSettingsAccess() const
+{
+    QSettings settings;
+    settings.sync();
+    return settings.status() == QSettings::NoError;
+}
+
+bool LLM::checkForUpdates() const
+{
+#ifdef GPT4ALL_OFFLINE_INSTALLER
+#   pragma message(__FILE__ ": WARNING: offline installer build will not check for updates!")
+    return QDesktopServices::openUrl(QUrl("https://github.com/nomic-ai/gpt4all/releases"));
+#else
+    Network::globalInstance()->trackEvent("check_for_updates");
+
+#if defined(Q_OS_LINUX)
+    QString tool = u"maintenancetool"_s;
+#elif defined(Q_OS_WINDOWS)
+    QString tool = u"maintenancetool.exe"_s;
+#elif defined(Q_OS_DARWIN)
+    QString tool = u"../../../maintenancetool.app/Contents/MacOS/maintenancetool"_s;
+#endif
+
+    QString fileName = QCoreApplication::applicationDirPath()
+        + "/../" + tool;
+    if (!QFileInfo::exists(fileName)) {
+        qDebug() << "Couldn't find tool at" << fileName << "so cannot check for updates!";
+        return false;
+    }
+
+    return QProcess::startDetached(fileName);
+#endif
+}
+
+bool LLM::directoryExists(const QString &path)
+{
+    const QUrl url(path);
+    const QString localFilePath = url.isLocalFile() ? url.toLocalFile() : path;
+    const QFileInfo info(localFilePath);
+    return info.exists() && info.isDir();
+}
+
+bool LLM::fileExists(const QString &path)
+{
+    const QUrl url(path);
+    const QString localFilePath = url.isLocalFile() ? url.toLocalFile() : path;
+    const QFileInfo info(localFilePath);
+    return info.exists() && info.isFile();
+}
+
+qint64 LLM::systemTotalRAMInGB() const
+{
+    return getSystemTotalRAMInGB();
+}
+
+QString LLM::systemTotalRAMInGBString() const
+{
+    return QString::fromStdString(getSystemTotalRAMInGBString());
+}
+
+bool LLM::isNetworkOnline() const
+{
+    auto * netinfo = QNetworkInformation::instance();
+    return !netinfo || netinfo->reachability() == QNetworkInformation::Reachability::Online;
+}

gpt4all-chat/src/llm.h

@@ -0,0 +1,38 @@
+#ifndef LLM_H
+#define LLM_H
+
+#include <QObject>
+#include <QString>
+#include <QtGlobal>
+
+class LLM : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool isNetworkOnline READ isNetworkOnline NOTIFY isNetworkOnlineChanged)
+
+public:
+    static LLM *globalInstance();
+
+    Q_INVOKABLE bool hasSettingsAccess() const;
+    Q_INVOKABLE bool compatHardware() const { return m_compatHardware; }
+
+    Q_INVOKABLE bool checkForUpdates() const;
+    Q_INVOKABLE static bool directoryExists(const QString &path);
+    Q_INVOKABLE static bool fileExists(const QString &path);
+    Q_INVOKABLE qint64 systemTotalRAMInGB() const;
+    Q_INVOKABLE QString systemTotalRAMInGBString() const;
+    Q_INVOKABLE bool isNetworkOnline() const;
+
+Q_SIGNALS:
+    void isNetworkOnlineChanged();
+
+private:
+    bool m_compatHardware;
+
+private:
+    explicit LLM();
+    ~LLM() {}
+    friend class MyLLM;
+};
+
+#endif // LLM_H

gpt4all-chat/src/localdocs.cpp

@@ -0,0 +1,106 @@
+#include "localdocs.h"
+
+#include "database.h"
+#include "embllm.h"
+#include "mysettings.h"
+
+#include <QCoreApplication>
+#include <QGlobalStatic>
+#include <QGuiApplication>
+#include <QUrl>
+#include <Qt>
+
+class MyLocalDocs: public LocalDocs { };
+Q_GLOBAL_STATIC(MyLocalDocs, localDocsInstance)
+LocalDocs *LocalDocs::globalInstance()
+{
+    return localDocsInstance();
+}
+
+LocalDocs::LocalDocs()
+    : QObject(nullptr)
+    , m_localDocsModel(new LocalDocsModel(this))
+    , m_database(nullptr)
+{
+    connect(MySettings::globalInstance(), &MySettings::localDocsChunkSizeChanged, this, &LocalDocs::handleChunkSizeChanged);
+    connect(MySettings::globalInstance(), &MySettings::localDocsFileExtensionsChanged, this, &LocalDocs::handleFileExtensionsChanged);
+
+    // Create the DB with the chunk size from settings
+    m_database = new Database(MySettings::globalInstance()->localDocsChunkSize(),
+                              MySettings::globalInstance()->localDocsFileExtensions());
+
+    connect(this, &LocalDocs::requestStart, m_database,
+        &Database::start, Qt::QueuedConnection);
+    connect(this, &LocalDocs::requestForceIndexing, m_database,
+        &Database::forceIndexing, Qt::QueuedConnection);
+    connect(this, &LocalDocs::forceRebuildFolder, m_database,
+        &Database::forceRebuildFolder, Qt::QueuedConnection);
+    connect(this, &LocalDocs::requestAddFolder, m_database,
+        &Database::addFolder, Qt::QueuedConnection);
+    connect(this, &LocalDocs::requestRemoveFolder, m_database,
+        &Database::removeFolder, Qt::QueuedConnection);
+    connect(this, &LocalDocs::requestChunkSizeChange, m_database,
+        &Database::changeChunkSize, Qt::QueuedConnection);
+    connect(this, &LocalDocs::requestFileExtensionsChange, m_database,
+        &Database::changeFileExtensions, Qt::QueuedConnection);
+    connect(m_database, &Database::databaseValidChanged,
+        this, &LocalDocs::databaseValidChanged, Qt::QueuedConnection);
+
+    // Connections for modifying the model and keeping it updated with the database
+    connect(m_database, &Database::requestUpdateGuiForCollectionItem,
+        m_localDocsModel, &LocalDocsModel::updateCollectionItem, Qt::QueuedConnection);
+    connect(m_database, &Database::requestAddGuiCollectionItem,
+        m_localDocsModel, &LocalDocsModel::addCollectionItem, Qt::QueuedConnection);
+    connect(m_database, &Database::requestRemoveGuiFolderById,
+        m_localDocsModel, &LocalDocsModel::removeFolderById, Qt::QueuedConnection);
+    connect(m_database, &Database::requestGuiCollectionListUpdated,
+        m_localDocsModel, &LocalDocsModel::collectionListUpdated, Qt::QueuedConnection);
+
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, this, &LocalDocs::aboutToQuit);
+}
+
+void LocalDocs::aboutToQuit()
+{
+    delete m_database;
+    m_database = nullptr;
+}
+
+void LocalDocs::addFolder(const QString &collection, const QString &path)
+{
+    const QUrl url(path);
+    const QString localPath = url.isLocalFile() ? url.toLocalFile() : path;
+
+    const QString embedding_model = EmbeddingLLM::model();
+    if (embedding_model.isEmpty()) {
+        qWarning() << "ERROR: We have no embedding model";
+        return;
+    }
+
+    emit requestAddFolder(collection, localPath, embedding_model);
+}
+
+void LocalDocs::removeFolder(const QString &collection, const QString &path)
+{
+    emit requestRemoveFolder(collection, path);
+}
+
+void LocalDocs::forceIndexing(const QString &collection)
+{
+    const QString embedding_model = EmbeddingLLM::model();
+    if (embedding_model.isEmpty()) {
+        qWarning() << "ERROR: We have no embedding model";
+        return;
+    }
+
+    emit requestForceIndexing(collection, embedding_model);
+}
+
+void LocalDocs::handleChunkSizeChanged()
+{
+    emit requestChunkSizeChange(MySettings::globalInstance()->localDocsChunkSize());
+}
+
+void LocalDocs::handleFileExtensionsChanged()
+{
+    emit requestFileExtensionsChange(MySettings::globalInstance()->localDocsFileExtensions());
+}

gpt4all-chat/src/localdocs.h

@@ -0,0 +1,55 @@
+#ifndef LOCALDOCS_H
+#define LOCALDOCS_H
+
+#include "database.h"
+#include "localdocsmodel.h" // IWYU pragma: keep
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+class LocalDocs : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool databaseValid READ databaseValid NOTIFY databaseValidChanged)
+    Q_PROPERTY(LocalDocsModel *localDocsModel READ localDocsModel NOTIFY localDocsModelChanged)
+
+public:
+    static LocalDocs *globalInstance();
+
+    LocalDocsModel *localDocsModel() const { return m_localDocsModel; }
+
+    Q_INVOKABLE void addFolder(const QString &collection, const QString &path);
+    Q_INVOKABLE void removeFolder(const QString &collection, const QString &path);
+    Q_INVOKABLE void forceIndexing(const QString &collection);
+
+    Database *database() const { return m_database; }
+
+    bool databaseValid() const { return m_database->isValid(); }
+
+public Q_SLOTS:
+    void handleChunkSizeChanged();
+    void handleFileExtensionsChanged();
+    void aboutToQuit();
+
+Q_SIGNALS:
+    void requestStart();
+    void requestForceIndexing(const QString &collection, const QString &embedding_model);
+    void forceRebuildFolder(const QString &path);
+    void requestAddFolder(const QString &collection, const QString &path, const QString &embedding_model);
+    void requestRemoveFolder(const QString &collection, const QString &path);
+    void requestChunkSizeChange(int chunkSize);
+    void requestFileExtensionsChange(const QStringList &extensions);
+    void localDocsModelChanged();
+    void databaseValidChanged();
+
+private:
+    LocalDocsModel *m_localDocsModel;
+    Database *m_database;
+
+private:
+    explicit LocalDocs();
+    friend class MyLocalDocs;
+};
+
+#endif // LOCALDOCS_H

gpt4all-chat/src/localdocsmodel.cpp

@@ -0,0 +1,259 @@
+#include "localdocsmodel.h"
+
+#include "localdocs.h"
+#include "network.h"
+
+#include <QDateTime>
+#include <QMap>
+#include <QVector>
+#include <QtGlobal>
+
+#include <utility>
+
+LocalDocsCollectionsModel::LocalDocsCollectionsModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+    setSourceModel(LocalDocs::globalInstance()->localDocsModel());
+
+    connect(LocalDocs::globalInstance()->localDocsModel(),
+        &LocalDocsModel::updatingChanged, this, &LocalDocsCollectionsModel::maybeTriggerUpdatingCountChanged);
+    connect(this, &LocalDocsCollectionsModel::rowsInserted, this, &LocalDocsCollectionsModel::countChanged);
+    connect(this, &LocalDocsCollectionsModel::rowsRemoved, this, &LocalDocsCollectionsModel::countChanged);
+    connect(this, &LocalDocsCollectionsModel::modelReset, this, &LocalDocsCollectionsModel::countChanged);
+    connect(this, &LocalDocsCollectionsModel::layoutChanged, this, &LocalDocsCollectionsModel::countChanged);
+}
+
+bool LocalDocsCollectionsModel::filterAcceptsRow(int sourceRow,
+                                       const QModelIndex &sourceParent) const
+{
+    QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
+    const QString collection = sourceModel()->data(index, LocalDocsModel::CollectionRole).toString();
+    return m_collections.contains(collection);
+}
+
+void LocalDocsCollectionsModel::setCollections(const QList<QString> &collections)
+{
+    m_collections = collections;
+    invalidateFilter();
+    maybeTriggerUpdatingCountChanged();
+}
+
+int LocalDocsCollectionsModel::updatingCount() const
+{
+    return m_updatingCount;
+}
+
+void LocalDocsCollectionsModel::maybeTriggerUpdatingCountChanged()
+{
+    int updatingCount = 0;
+    for (int row = 0; row < sourceModel()->rowCount(); ++row) {
+        QModelIndex index = sourceModel()->index(row, 0);
+        const QString collection = sourceModel()->data(index, LocalDocsModel::CollectionRole).toString();
+        if (!m_collections.contains(collection))
+            continue;
+        bool updating = sourceModel()->data(index, LocalDocsModel::UpdatingRole).toBool();
+        if (updating)
+            ++updatingCount;
+    }
+    if (updatingCount != m_updatingCount) {
+        m_updatingCount = updatingCount;
+        emit updatingCountChanged();
+    }
+}
+
+LocalDocsModel::LocalDocsModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    connect(this, &LocalDocsModel::rowsInserted, this, &LocalDocsModel::countChanged);
+    connect(this, &LocalDocsModel::rowsRemoved, this, &LocalDocsModel::countChanged);
+    connect(this, &LocalDocsModel::modelReset, this, &LocalDocsModel::countChanged);
+    connect(this, &LocalDocsModel::layoutChanged, this, &LocalDocsModel::countChanged);
+}
+
+int LocalDocsModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return m_collectionList.size();
+}
+
+QVariant LocalDocsModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() < 0 || index.row() >= m_collectionList.size())
+        return QVariant();
+
+    const CollectionItem item = m_collectionList.at(index.row());
+    switch (role) {
+        case CollectionRole:
+            return item.collection;
+        case FolderPathRole:
+            return item.folder_path;
+        case InstalledRole:
+            return item.installed;
+        case IndexingRole:
+            return item.indexing;
+        case ErrorRole:
+            return item.error;
+        case ForceIndexingRole:
+            return item.forceIndexing;
+        case CurrentDocsToIndexRole:
+            return item.currentDocsToIndex;
+        case TotalDocsToIndexRole:
+            return item.totalDocsToIndex;
+        case CurrentBytesToIndexRole:
+            return quint64(item.currentBytesToIndex);
+        case TotalBytesToIndexRole:
+            return quint64(item.totalBytesToIndex);
+        case CurrentEmbeddingsToIndexRole:
+            return quint64(item.currentEmbeddingsToIndex);
+        case TotalEmbeddingsToIndexRole:
+            return quint64(item.totalEmbeddingsToIndex);
+        case TotalDocsRole:
+            return quint64(item.totalDocs);
+        case TotalWordsRole:
+            return quint64(item.totalWords);
+        case TotalTokensRole:
+            return quint64(item.totalTokens);
+        case StartUpdateRole:
+            return item.startUpdate;
+        case LastUpdateRole:
+            return item.lastUpdate;
+        case FileCurrentlyProcessingRole:
+            return item.fileCurrentlyProcessing;
+        case EmbeddingModelRole:
+            return item.embeddingModel;
+        case UpdatingRole:
+            return item.indexing || item.currentEmbeddingsToIndex != 0;
+    }
+
+    return QVariant();
+}
+
+QHash<int, QByteArray> LocalDocsModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[CollectionRole] = "collection";
+    roles[FolderPathRole] = "folder_path";
+    roles[InstalledRole] = "installed";
+    roles[IndexingRole] = "indexing";
+    roles[ErrorRole] = "error";
+    roles[ForceIndexingRole] = "forceIndexing";
+    roles[CurrentDocsToIndexRole] = "currentDocsToIndex";
+    roles[TotalDocsToIndexRole] = "totalDocsToIndex";
+    roles[CurrentBytesToIndexRole] = "currentBytesToIndex";
+    roles[TotalBytesToIndexRole] = "totalBytesToIndex";
+    roles[CurrentEmbeddingsToIndexRole] = "currentEmbeddingsToIndex";
+    roles[TotalEmbeddingsToIndexRole] = "totalEmbeddingsToIndex";
+    roles[TotalDocsRole] = "totalDocs";
+    roles[TotalWordsRole] = "totalWords";
+    roles[TotalTokensRole] = "totalTokens";
+    roles[StartUpdateRole] = "startUpdate";
+    roles[LastUpdateRole] = "lastUpdate";
+    roles[FileCurrentlyProcessingRole] = "fileCurrentlyProcessing";
+    roles[EmbeddingModelRole] = "embeddingModel";
+    roles[UpdatingRole] = "updating";
+    return roles;
+}
+
+void LocalDocsModel::updateCollectionItem(const CollectionItem &item)
+{
+    for (int i = 0; i < m_collectionList.size(); ++i) {
+        CollectionItem &stored = m_collectionList[i];
+        if (stored.folder_id != item.folder_id)
+            continue;
+
+        QVector<int> changed;
+        if (stored.folder_path != item.folder_path)
+            changed.append(FolderPathRole);
+        if (stored.installed != item.installed)
+            changed.append(InstalledRole);
+        if (stored.indexing != item.indexing) {
+            changed.append(IndexingRole);
+            changed.append(UpdatingRole);
+        }
+        if (stored.error != item.error)
+            changed.append(ErrorRole);
+        if (stored.forceIndexing != item.forceIndexing)
+            changed.append(ForceIndexingRole);
+        if (stored.currentDocsToIndex != item.currentDocsToIndex)
+            changed.append(CurrentDocsToIndexRole);
+        if (stored.totalDocsToIndex != item.totalDocsToIndex)
+            changed.append(TotalDocsToIndexRole);
+        if (stored.currentBytesToIndex != item.currentBytesToIndex)
+            changed.append(CurrentBytesToIndexRole);
+        if (stored.totalBytesToIndex != item.totalBytesToIndex)
+            changed.append(TotalBytesToIndexRole);
+        if (stored.currentEmbeddingsToIndex != item.currentEmbeddingsToIndex) {
+            changed.append(CurrentEmbeddingsToIndexRole);
+            changed.append(UpdatingRole);
+        }
+        if (stored.totalEmbeddingsToIndex != item.totalEmbeddingsToIndex)
+            changed.append(TotalEmbeddingsToIndexRole);
+        if (stored.totalDocs != item.totalDocs)
+            changed.append(TotalDocsRole);
+        if (stored.totalWords != item.totalWords)
+            changed.append(TotalWordsRole);
+        if (stored.totalTokens != item.totalTokens)
+            changed.append(TotalTokensRole);
+        if (stored.startUpdate != item.startUpdate)
+            changed.append(StartUpdateRole);
+        if (stored.lastUpdate != item.lastUpdate)
+            changed.append(LastUpdateRole);
+        if (stored.fileCurrentlyProcessing != item.fileCurrentlyProcessing)
+            changed.append(FileCurrentlyProcessingRole);
+        if (stored.embeddingModel != item.embeddingModel)
+            changed.append(EmbeddingModelRole);
+
+        // preserve collection name as we ignore it for matching
+        QString collection = stored.collection;
+        stored = item;
+        stored.collection = collection;
+
+        emit dataChanged(this->index(i), this->index(i), changed);
+
+        if (changed.contains(UpdatingRole))
+            emit updatingChanged(item.collection);
+    }
+}
+
+void LocalDocsModel::addCollectionItem(const CollectionItem &item)
+{
+    beginInsertRows(QModelIndex(), m_collectionList.size(), m_collectionList.size());
+    m_collectionList.append(item);
+    endInsertRows();
+}
+
+void LocalDocsModel::removeCollectionIf(std::function<bool(CollectionItem)> const &predicate)
+{
+    for (int i = 0; i < m_collectionList.size();) {
+        if (predicate(m_collectionList.at(i))) {
+            beginRemoveRows(QModelIndex(), i, i);
+            m_collectionList.removeAt(i);
+            endRemoveRows();
+
+            Network::globalInstance()->trackEvent("doc_collection_remove", {
+                {"collection_count", m_collectionList.count()},
+            });
+        } else {
+            ++i;
+        }
+    }
+}
+
+void LocalDocsModel::removeFolderById(const QString &collection, int folder_id)
+{
+    removeCollectionIf([collection, folder_id](const auto &c) {
+        return c.collection == collection && c.folder_id == folder_id;
+    });
+}
+
+void LocalDocsModel::removeCollectionPath(const QString &name, const QString &path)
+{
+    removeCollectionIf([&name, &path](const auto &c) { return c.collection == name && c.folder_path == path; });
+}
+
+void LocalDocsModel::collectionListUpdated(const QList<CollectionItem> &collectionList)
+{
+    beginResetModel();
+    m_collectionList = collectionList;
+    endResetModel();
+}

gpt4all-chat/src/localdocsmodel.h

@@ -0,0 +1,97 @@
+#ifndef LOCALDOCSMODEL_H
+#define LOCALDOCSMODEL_H
+
+#include "database.h"
+
+#include <QAbstractListModel>
+#include <QByteArray>
+#include <QHash>
+#include <QList>
+#include <QObject>
+#include <QSortFilterProxyModel>
+#include <QString>
+#include <QVariant>
+#include <Qt>
+
+#include <functional>
+
+class LocalDocsCollectionsModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(int updatingCount READ updatingCount NOTIFY updatingCountChanged)
+public:
+    explicit LocalDocsCollectionsModel(QObject *parent);
+
+public Q_SLOTS:
+    int count() const { return rowCount(); }
+    void setCollections(const QList<QString> &collections);
+    int updatingCount() const;
+
+Q_SIGNALS:
+    void countChanged();
+    void updatingCountChanged();
+
+private Q_SLOT:
+    void maybeTriggerUpdatingCountChanged();
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+
+private:
+    QList<QString> m_collections;
+    int m_updatingCount = 0;
+};
+
+class LocalDocsModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+
+public:
+    enum Roles {
+        CollectionRole = Qt::UserRole + 1,
+        FolderPathRole,
+        InstalledRole,
+        IndexingRole,
+        ErrorRole,
+        ForceIndexingRole,
+        CurrentDocsToIndexRole,
+        TotalDocsToIndexRole,
+        CurrentBytesToIndexRole,
+        TotalBytesToIndexRole,
+        CurrentEmbeddingsToIndexRole,
+        TotalEmbeddingsToIndexRole,
+        TotalDocsRole,
+        TotalWordsRole,
+        TotalTokensRole,
+        StartUpdateRole,
+        LastUpdateRole,
+        FileCurrentlyProcessingRole,
+        EmbeddingModelRole,
+        UpdatingRole
+    };
+
+    explicit LocalDocsModel(QObject *parent = nullptr);
+    int rowCount(const QModelIndex & = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+    QHash<int, QByteArray> roleNames() const override;
+    int count() const { return rowCount(); }
+
+public Q_SLOTS:
+    void updateCollectionItem(const CollectionItem&);
+    void addCollectionItem(const CollectionItem &item);
+    void removeFolderById(const QString &collection, int folder_id);
+    void removeCollectionPath(const QString &name, const QString &path);
+    void collectionListUpdated(const QList<CollectionItem> &collectionList);
+
+Q_SIGNALS:
+    void countChanged();
+    void updatingChanged(const QString &collection);
+
+private:
+    void removeCollectionIf(std::function<bool(CollectionItem)> const &predicate);
+    QList<CollectionItem> m_collectionList;
+};
+
+#endif // LOCALDOCSMODEL_H

gpt4all-chat/src/logger.cpp

@@ -0,0 +1,71 @@
+#include "logger.h"
+
+#include <QDateTime>
+#include <QDebug>
+#include <QGlobalStatic>
+#include <QIODevice>
+#include <QStandardPaths>
+
+#include <cstdio>
+#include <iostream>
+#include <string>
+
+using namespace Qt::Literals::StringLiterals;
+
+class MyLogger: public Logger { };
+Q_GLOBAL_STATIC(MyLogger, loggerInstance)
+Logger *Logger::globalInstance()
+{
+    return loggerInstance();
+}
+
+Logger::Logger()
+{
+    // Get log file dir
+    auto dir = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
+    // Remove old log file
+    QFile::remove(dir+"/log-prev.txt");
+    QFile::rename(dir+"/log.txt", dir+"/log-prev.txt");
+    // Open new log file
+    m_file.setFileName(dir+"/log.txt");
+    if (!m_file.open(QIODevice::NewOnly | QIODevice::WriteOnly | QIODevice::Text)) {
+        qWarning() << "Failed to open log file, logging to stdout...";
+        m_file.open(stdout, QIODevice::WriteOnly | QIODevice::Text);
+    }
+    // On success, install message handler
+    qInstallMessageHandler(Logger::messageHandler);
+}
+
+void Logger::messageHandler(QtMsgType type, const QMessageLogContext &, const QString &msg)
+{
+    auto logger = globalInstance();
+    // Get message type as string
+    QString typeString;
+    switch (type) {
+    case QtDebugMsg:
+        typeString = "Debug";
+        break;
+    case QtInfoMsg:
+        typeString = "Info";
+        break;
+    case QtWarningMsg:
+        typeString = "Warning";
+        break;
+    case QtCriticalMsg:
+        typeString = "Critical";
+        break;
+    case QtFatalMsg:
+        typeString = "Fatal";
+        break;
+    default:
+        typeString = "???";
+    }
+    // Get time and date
+    auto timestamp = QDateTime::currentDateTime().toString();
+    // Write message
+    const std::string out = u"[%1] (%2): %3\n"_s.arg(typeString, timestamp, msg).toStdString();
+    logger->m_file.write(out.c_str());
+    logger->m_file.flush();
+    std::cerr << out;
+    fflush(stderr);
+}

gpt4all-chat/src/logger.h

@@ -0,0 +1,21 @@
+#ifndef LOGGER_H
+#define LOGGER_H
+
+#include <QFile>
+#include <QString>
+#include <QtLogging>
+
+class Logger
+{
+    QFile m_file;
+
+    static void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg);
+
+public:
+    static Logger *globalInstance();
+
+    explicit Logger();
+    friend class MyLogger;
+};
+
+#endif // LOGGER_H

gpt4all-chat/src/main.cpp

@@ -0,0 +1,103 @@
+#include "chatlistmodel.h"
+#include "config.h"
+#include "download.h"
+#include "llm.h"
+#include "localdocs.h"
+#include "logger.h"
+#include "modellist.h"
+#include "mysettings.h"
+#include "network.h"
+
+#include <gpt4all-backend/llmodel.h>
+
+#include <QCoreApplication>
+#include <QGuiApplication>
+#include <QObject>
+#include <QQmlApplicationEngine>
+#include <QQmlEngine>
+#include <QSettings>
+#include <QString>
+#include <QTranslator>
+#include <QUrl>
+#include <Qt>
+
+#ifdef Q_OS_LINUX
+#   include <QIcon>
+#endif
+
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication::setOrganizationName("nomic.ai");
+    QCoreApplication::setOrganizationDomain("gpt4all.io");
+    QCoreApplication::setApplicationName("GPT4All");
+    QCoreApplication::setApplicationVersion(APP_VERSION);
+    QSettings::setDefaultFormat(QSettings::IniFormat);
+
+    Logger::globalInstance();
+
+    QGuiApplication app(argc, argv);
+#ifdef Q_OS_LINUX
+    app.setWindowIcon(QIcon(":/gpt4all/icons/gpt4all.svg"));
+#endif
+
+    // set search path before constructing the MySettings instance, which relies on this
+    QString llmodelSearchPaths = QCoreApplication::applicationDirPath();
+    const QString libDir = QCoreApplication::applicationDirPath() + "/../lib/";
+    if (LLM::directoryExists(libDir))
+        llmodelSearchPaths += ";" + libDir;
+#if defined(Q_OS_MAC)
+    const QString binDir = QCoreApplication::applicationDirPath() + "/../../../";
+    if (LLM::directoryExists(binDir))
+        llmodelSearchPaths += ";" + binDir;
+    const QString frameworksDir = QCoreApplication::applicationDirPath() + "/../Frameworks/";
+    if (LLM::directoryExists(frameworksDir))
+        llmodelSearchPaths += ";" + frameworksDir;
+#endif
+    LLModel::Implementation::setImplementationsSearchPath(llmodelSearchPaths.toStdString());
+
+    // Set the local and language translation before the qml engine has even been started. This will
+    // use the default system locale unless the user has explicitly set it to use a different one.
+    MySettings::globalInstance()->setLanguageAndLocale();
+
+    QQmlApplicationEngine engine;
+
+    // Add a connection here from MySettings::languageAndLocaleChanged signal to a lambda slot where I can call
+    // engine.uiLanguage property
+    QObject::connect(MySettings::globalInstance(), &MySettings::languageAndLocaleChanged, [&engine]() {
+        engine.setUiLanguage(MySettings::globalInstance()->languageAndLocale());
+    });
+
+    qmlRegisterSingletonInstance("mysettings", 1, 0, "MySettings", MySettings::globalInstance());
+    qmlRegisterSingletonInstance("modellist", 1, 0, "ModelList", ModelList::globalInstance());
+    qmlRegisterSingletonInstance("chatlistmodel", 1, 0, "ChatListModel", ChatListModel::globalInstance());
+    qmlRegisterSingletonInstance("llm", 1, 0, "LLM", LLM::globalInstance());
+    qmlRegisterSingletonInstance("download", 1, 0, "Download", Download::globalInstance());
+    qmlRegisterSingletonInstance("network", 1, 0, "Network", Network::globalInstance());
+    qmlRegisterSingletonInstance("localdocs", 1, 0, "LocalDocs", LocalDocs::globalInstance());
+    qmlRegisterUncreatableMetaObject(MySettingsEnums::staticMetaObject, "mysettingsenums", 1, 0, "MySettingsEnums", "Error: only enums");
+
+    const QUrl url(u"qrc:/gpt4all/main.qml"_qs);
+
+    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
+        &app, [url](QObject *obj, const QUrl &objUrl) {
+            if (!obj && url == objUrl)
+                QCoreApplication::exit(-1);
+        }, Qt::QueuedConnection);
+    engine.load(url);
+
+#if 0
+    QDirIterator it("qrc:", QDirIterator::Subdirectories);
+    while (it.hasNext()) {
+        qDebug() << it.next();
+    }
+#endif
+
+    int res = app.exec();
+
+    // Make sure ChatLLM threads are joined before global destructors run.
+    // Otherwise, we can get a heap-use-after-free inside of llama.cpp.
+    ChatListModel::globalInstance()->destroyChats();
+
+    return res;
+}

gpt4all-chat/src/main.qml

@@ -0,0 +1,728 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import Qt5Compat.GraphicalEffects
+import llm
+import chatlistmodel
+import download
+import modellist
+import network
+import gpt4all
+import localdocs
+import mysettings
+
+Window {
+    id: window
+    width: 1920
+    height: 1080
+    minimumWidth: 1280
+    minimumHeight: 720
+    visible: true
+    title: qsTr("GPT4All v%1").arg(Qt.application.version)
+
+    Settings {
+        property alias x: window.x
+        property alias y: window.y
+        property alias width: window.width
+        property alias height: window.height
+    }
+
+    Theme {
+        id: theme
+    }
+
+    Item {
+        Accessible.role: Accessible.Window
+        Accessible.name: title
+    }
+
+    // Startup code
+    Component.onCompleted: {
+        startupDialogs();
+    }
+
+    Component.onDestruction: {
+        Network.trackEvent("session_end")
+    }
+
+    Connections {
+        target: firstStartDialog
+        function onClosed() {
+            startupDialogs();
+        }
+    }
+
+    Connections {
+        target: Download
+        function onHasNewerReleaseChanged() {
+            startupDialogs();
+        }
+    }
+
+    property bool hasCheckedFirstStart: false
+    property bool hasShownSettingsAccess: false
+    property var currentChat: ChatListModel.currentChat
+
+    function startupDialogs() {
+        if (!LLM.compatHardware()) {
+            Network.trackEvent("noncompat_hardware")
+            errorCompatHardware.open();
+            return;
+        }
+
+        // check if we have access to settings and if not show an error
+        if (!hasShownSettingsAccess && !LLM.hasSettingsAccess()) {
+            errorSettingsAccess.open();
+            hasShownSettingsAccess = true;
+            return;
+        }
+
+        // check for first time start of this version
+        if (!hasCheckedFirstStart) {
+            if (Download.isFirstStart(/*writeVersion*/ true)) {
+                firstStartDialog.open();
+                return;
+            }
+
+            // send startup or opt-out now that the user has made their choice
+            Network.sendStartup()
+            // start localdocs
+            LocalDocs.requestStart()
+
+            hasCheckedFirstStart = true
+        }
+
+        // check for new version
+        if (Download.hasNewerRelease && !firstStartDialog.opened) {
+            newVersionDialog.open();
+            return;
+        }
+    }
+
+    PopupDialog {
+        id: errorCompatHardware
+        anchors.centerIn: parent
+        shouldTimeOut: false
+        shouldShowBusy: false
+        closePolicy: Popup.NoAutoClose
+        modal: true
+        text: qsTr("<h3>Encountered an error starting up:</h3><br>"
+              + "<i>\"Incompatible hardware detected.\"</i>"
+              + "<br><br>Unfortunately, your CPU does not meet the minimal requirements to run "
+              + "this program. In particular, it does not support AVX intrinsics which this "
+              + "program requires to successfully run a modern large language model. "
+              + "The only solution at this time is to upgrade your hardware to a more modern CPU."
+              + "<br><br>See here for more information: <a href=\"https://en.wikipedia.org/wiki/Advanced_Vector_Extensions\">"
+              + "https://en.wikipedia.org/wiki/Advanced_Vector_Extensions</a>");
+    }
+
+    PopupDialog {
+        id: errorSettingsAccess
+        anchors.centerIn: parent
+        shouldTimeOut: false
+        shouldShowBusy: false
+        modal: true
+        text: qsTr("<h3>Encountered an error starting up:</h3><br>"
+              + "<i>\"Inability to access settings file.\"</i>"
+              + "<br><br>Unfortunately, something is preventing the program from accessing "
+              + "the settings file. This could be caused by incorrect permissions in the local "
+              + "app config directory where the settings file is located. "
+              + "Check out our <a href=\"https://discord.gg/4M2QFmTt2k\">discord channel</a> for help.")
+    }
+
+    StartupDialog {
+        id: firstStartDialog
+        anchors.centerIn: parent
+    }
+
+    NewVersionDialog {
+        id: newVersionDialog
+        anchors.centerIn: parent
+    }
+
+    Connections {
+        target: Network
+        function onHealthCheckFailed(code) {
+            healthCheckFailed.open();
+        }
+    }
+
+    PopupDialog {
+        id: healthCheckFailed
+        anchors.centerIn: parent
+        text: qsTr("Connection to datalake failed.")
+        font.pixelSize: theme.fontSizeLarge
+    }
+
+    property bool hasSaved: false
+
+    PopupDialog {
+        id: savingPopup
+        anchors.centerIn: parent
+        shouldTimeOut: false
+        shouldShowBusy: true
+        text: qsTr("Saving chats.")
+        font.pixelSize: theme.fontSizeLarge
+    }
+
+    NetworkDialog {
+        id: networkDialog
+        anchors.centerIn: parent
+        width: Math.min(1024, window.width - (window.width * .2))
+        height: Math.min(600, window.height - (window.height * .2))
+        Item {
+            Accessible.role: Accessible.Dialog
+            Accessible.name: qsTr("Network dialog")
+            Accessible.description: qsTr("opt-in to share feedback/conversations")
+        }
+    }
+
+    onClosing: function(close) {
+        if (window.hasSaved)
+            return;
+
+        savingPopup.open();
+        ChatListModel.saveChats();
+        close.accepted = false
+    }
+
+    Connections {
+        target: ChatListModel
+        function onSaveChatsFinished() {
+            window.hasSaved = true;
+            savingPopup.close();
+            window.close()
+        }
+    }
+
+    color: theme.viewBarBackground
+
+    Rectangle {
+        id: viewBar
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        width: 68 * theme.fontScale
+        color: theme.viewBarBackground
+
+        ColumnLayout {
+            id: viewsLayout
+            anchors.top: parent.top
+            anchors.topMargin: 30
+            anchors.horizontalCenter: parent.horizontalCenter
+            Layout.margins: 0
+            spacing: 16
+
+            MyToolButton {
+                id: homeButton
+                backgroundColor: toggled ? theme.iconBackgroundViewBarHovered : theme.iconBackgroundViewBar
+                backgroundColorHovered: theme.iconBackgroundViewBarHovered
+                Layout.preferredWidth: 38 * theme.fontScale
+                Layout.preferredHeight: 38 * theme.fontScale
+                Layout.alignment: Qt.AlignCenter
+                toggledWidth: 0
+                toggled: homeView.isShown()
+                toggledColor: theme.iconBackgroundViewBarToggled
+                imageWidth: 25 * theme.fontScale
+                imageHeight: 25 * theme.fontScale
+                source: "qrc:/gpt4all/icons/home.svg"
+                Accessible.name: qsTr("Home view")
+                Accessible.description: qsTr("Home view of application")
+                onClicked: {
+                    homeView.show()
+                }
+            }
+
+            Text {
+                Layout.topMargin: -20
+                text: qsTr("Home")
+                font.pixelSize: theme.fontSizeMedium
+                font.bold: true
+                color: homeButton.hovered ? homeButton.backgroundColorHovered : homeButton.backgroundColor
+                Layout.preferredWidth: 38 * theme.fontScale
+                horizontalAlignment: Text.AlignHCenter
+                TapHandler {
+                    onTapped: function(eventPoint, button) {
+                        homeView.show()
+                    }
+                }
+            }
+
+            MyToolButton {
+                id: chatButton
+                backgroundColor: toggled ? theme.iconBackgroundViewBarHovered : theme.iconBackgroundViewBar
+                backgroundColorHovered: theme.iconBackgroundViewBarHovered
+                Layout.preferredWidth: 38 * theme.fontScale
+                Layout.preferredHeight: 38 * theme.fontScale
+                Layout.alignment: Qt.AlignCenter
+                toggledWidth: 0
+                toggled: chatView.isShown()
+                toggledColor: theme.iconBackgroundViewBarToggled
+                imageWidth: 25 * theme.fontScale
+                imageHeight: 25 * theme.fontScale
+                source: "qrc:/gpt4all/icons/chat.svg"
+                Accessible.name: qsTr("Chat view")
+                Accessible.description: qsTr("Chat view to interact with models")
+                onClicked: {
+                    chatView.show()
+                }
+            }
+
+            Text {
+                Layout.topMargin: -20
+                text: qsTr("Chats")
+                font.pixelSize: theme.fontSizeMedium
+                font.bold: true
+                color: chatButton.hovered ? chatButton.backgroundColorHovered : chatButton.backgroundColor
+                Layout.preferredWidth: 38 * theme.fontScale
+                horizontalAlignment: Text.AlignHCenter
+                TapHandler {
+                    onTapped: function(eventPoint, button) {
+                        chatView.show()
+                    }
+                }
+            }
+
+            MyToolButton {
+                id: modelsButton
+                backgroundColor: toggled ? theme.iconBackgroundViewBarHovered : theme.iconBackgroundViewBar
+                backgroundColorHovered: theme.iconBackgroundViewBarHovered
+                Layout.preferredWidth: 38 * theme.fontScale
+                Layout.preferredHeight: 38 * theme.fontScale
+                toggledWidth: 0
+                toggled: modelsView.isShown()
+                toggledColor: theme.iconBackgroundViewBarToggled
+                imageWidth: 25 * theme.fontScale
+                imageHeight: 25 * theme.fontScale
+                source: "qrc:/gpt4all/icons/models.svg"
+                Accessible.name: qsTr("Models")
+                Accessible.description: qsTr("Models view for installed models")
+                onClicked: {
+                    modelsView.show()
+                }
+            }
+
+            Text {
+                Layout.topMargin: -20
+                text: qsTr("Models")
+                font.pixelSize: theme.fontSizeMedium
+                font.bold: true
+                color: modelsButton.hovered ? modelsButton.backgroundColorHovered : modelsButton.backgroundColor
+                Layout.preferredWidth: 38 * theme.fontScale
+                horizontalAlignment: Text.AlignHCenter
+                TapHandler {
+                    onTapped: function(eventPoint, button) {
+                        modelsView.show()
+                    }
+                }
+            }
+
+            MyToolButton {
+                id: localdocsButton
+                backgroundColor: toggled ? theme.iconBackgroundViewBarHovered : theme.iconBackgroundViewBar
+                backgroundColorHovered: theme.iconBackgroundViewBarHovered
+                Layout.preferredWidth: 38 * theme.fontScale
+                Layout.preferredHeight: 38 * theme.fontScale
+                toggledWidth: 0
+                toggledColor: theme.iconBackgroundViewBarToggled
+                toggled: localDocsView.isShown()
+                imageWidth: 25 * theme.fontScale
+                imageHeight: 25 * theme.fontScale
+                source: "qrc:/gpt4all/icons/db.svg"
+                Accessible.name: qsTr("LocalDocs")
+                Accessible.description: qsTr("LocalDocs view to configure and use local docs")
+                onClicked: {
+                    localDocsView.show()
+                }
+            }
+
+            Text {
+                Layout.topMargin: -20
+                text: qsTr("LocalDocs")
+                font.pixelSize: theme.fontSizeMedium
+                font.bold: true
+                color: localdocsButton.hovered ? localdocsButton.backgroundColorHovered : localdocsButton.backgroundColor
+                Layout.preferredWidth: 38 * theme.fontScale
+                horizontalAlignment: Text.AlignHCenter
+                TapHandler {
+                    onTapped: function(eventPoint, button) {
+                        localDocsView.show()
+                    }
+                }
+            }
+
+            MyToolButton {
+                id: settingsButton
+                backgroundColor: toggled ? theme.iconBackgroundViewBarHovered : theme.iconBackgroundViewBar
+                backgroundColorHovered: theme.iconBackgroundViewBarHovered
+                Layout.preferredWidth: 38 * theme.fontScale
+                Layout.preferredHeight: 38 * theme.fontScale
+                toggledWidth: 0
+                toggledColor: theme.iconBackgroundViewBarToggled
+                toggled: settingsView.isShown()
+                imageWidth: 25 * theme.fontScale
+                imageHeight: 25 * theme.fontScale
+                source: "qrc:/gpt4all/icons/settings.svg"
+                Accessible.name: qsTr("Settings")
+                Accessible.description: qsTr("Settings view for application configuration")
+                onClicked: {
+                    settingsView.show(0 /*pageToDisplay*/)
+                }
+            }
+
+            Text {
+                Layout.topMargin: -20
+                text: qsTr("Settings")
+                font.pixelSize: theme.fontSizeMedium
+                font.bold: true
+                color: settingsButton.hovered ? settingsButton.backgroundColorHovered : settingsButton.backgroundColor
+                Layout.preferredWidth: 38 * theme.fontScale
+                horizontalAlignment: Text.AlignHCenter
+                TapHandler {
+                    onTapped: function(eventPoint, button) {
+                        settingsView.show(0 /*pageToDisplay*/)
+                    }
+                }
+            }
+        }
+
+        ColumnLayout {
+            id: buttonsLayout
+            anchors.bottom: parent.bottom
+            anchors.margins: 0
+            anchors.bottomMargin: 25
+            anchors.horizontalCenter: parent.horizontalCenter
+            Layout.margins: 0
+            spacing: 22
+
+            Item {
+                id: antennaItem
+                Layout.alignment: Qt.AlignCenter
+                Layout.preferredWidth: antennaImage.width
+                Layout.preferredHeight: antennaImage.height
+                Image {
+                    id: antennaImage
+                    sourceSize.width: 32
+                    sourceSize.height: 32
+                    visible: false
+                    fillMode: Image.PreserveAspectFit
+                    source: "qrc:/gpt4all/icons/antenna_3.svg"
+                }
+
+                ColorOverlay {
+                    id: antennaColored
+                    visible: ModelList.selectableModels.count !== 0 && (currentChat.isServer || currentChat.modelInfo.isOnline || MySettings.networkIsActive)
+                    anchors.fill: antennaImage
+                    source: antennaImage
+                    color: theme.styledTextColor
+                    ToolTip.text: {
+                        if (MySettings.networkIsActive)
+                            return qsTr("The datalake is enabled")
+                        else if (currentChat.modelInfo.isOnline)
+                            return qsTr("Using a network model")
+                        else if (currentChat.modelInfo.isOnline)
+                            return qsTr("Server mode is enabled")
+                        return ""
+                    }
+                    ToolTip.visible: maAntenna.containsMouse
+                    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+                    MouseArea {
+                        id: maAntenna
+                        anchors.fill: antennaColored
+                        hoverEnabled: true
+                    }
+                }
+
+                SequentialAnimation {
+                    running: true
+                    loops: Animation.Infinite
+
+                    PropertyAnimation {
+                        target: antennaImage
+                        property: "source"
+                        duration: 500
+                        from: "qrc:/gpt4all/icons/antenna_1.svg"
+                        to: "qrc:/gpt4all/icons/antenna_2.svg"
+                    }
+
+                    PauseAnimation {
+                        duration: 1500
+                    }
+
+                    PropertyAnimation {
+                        target: antennaImage
+                        property: "source"
+                        duration: 500
+                        from: "qrc:/gpt4all/icons/antenna_2.svg"
+                        to: "qrc:/gpt4all/icons/antenna_3.svg"
+                    }
+
+                    PauseAnimation {
+                        duration: 1500
+                    }
+
+                    PropertyAnimation {
+                        target: antennaImage
+                        property: "source"
+                        duration: 500
+                        from: "qrc:/gpt4all/icons/antenna_3.svg"
+                        to: "qrc:/gpt4all/icons/antenna_2.svg"
+                    }
+
+                    PauseAnimation {
+                        duration: 1500
+                    }
+
+                    PropertyAnimation {
+                        target: antennaImage
+                        property: "source"
+                        duration: 1500
+                        from: "qrc:/gpt4all/icons/antenna_2.svg"
+                        to: "qrc:/gpt4all/icons/antenna_1.svg"
+                    }
+
+                    PauseAnimation {
+                        duration: 500
+                    }
+                }
+            }
+
+            Rectangle {
+                Layout.alignment: Qt.AlignCenter
+                Layout.preferredWidth: image.width
+                Layout.preferredHeight: image.height
+                color: "transparent"
+
+                Image {
+                    id: image
+                    anchors.centerIn: parent
+                    sourceSize: Qt.size(48 * theme.fontScale, 32 * theme.fontScale)
+                    fillMode: Image.PreserveAspectFit
+                    mipmap: true
+                    visible: false
+                    source: "qrc:/gpt4all/icons/nomic_logo.svg"
+                }
+
+                ColorOverlay {
+                    anchors.fill: image
+                    source: image
+                    color: image.hovered ? theme.mutedDarkTextColorHovered : theme.mutedDarkTextColor
+                    TapHandler {
+                        onTapped: function(eventPoint, button) {
+                            Qt.openUrlExternally("https://nomic.ai")
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Rectangle {
+        id: roundedFrame
+        z: 299
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.left: viewBar.right
+        anchors.right: parent.right
+        anchors.topMargin: 15
+        anchors.bottomMargin: 15
+        anchors.rightMargin: 15
+        radius: 15
+        border.width: 1
+        border.color: theme.dividerColor
+        color: "transparent"
+        clip: true
+    }
+
+    RectangularGlow {
+        id: effect
+        anchors.fill: roundedFrame
+        glowRadius: 15
+        spread: 0
+        color: theme.dividerColor
+        cornerRadius: 10
+        opacity: 0.5
+    }
+
+    StackLayout {
+        id: stackLayout
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.left: viewBar.right
+        anchors.right: parent.right
+        anchors.topMargin: 15
+        anchors.bottomMargin: 15
+        anchors.rightMargin: 15
+
+        layer.enabled: true
+        layer.effect: OpacityMask {
+            maskSource: Rectangle {
+                width: roundedFrame.width
+                height: roundedFrame.height
+                radius: 15
+            }
+        }
+
+        HomeView {
+            id: homeView
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            shouldShowFirstStart: !hasCheckedFirstStart
+
+            function show() {
+                stackLayout.currentIndex = 0;
+            }
+
+            function isShown() {
+                return stackLayout.currentIndex === 0
+            }
+
+            Connections {
+                target: homeView
+                function onChatViewRequested() {
+                    chatView.show();
+                }
+                function onLocalDocsViewRequested() {
+                    localDocsView.show();
+                }
+                function onAddModelViewRequested() {
+                    addModelView.show();
+                }
+                function onSettingsViewRequested(page) {
+                    settingsView.show(page);
+                }
+            }
+        }
+
+        ChatView {
+            id: chatView
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            function show() {
+                stackLayout.currentIndex = 1;
+            }
+
+            function isShown() {
+                return stackLayout.currentIndex === 1
+            }
+
+            Connections {
+                target: chatView
+                function onAddCollectionViewRequested() {
+                    addCollectionView.show();
+                }
+                function onAddModelViewRequested() {
+                    addModelView.show();
+                }
+            }
+        }
+
+        ModelsView {
+            id: modelsView
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            function show() {
+                stackLayout.currentIndex = 2;
+                // FIXME This expanded code should be removed and we should be changing the names of
+                // the classes here in ModelList for the proxy/filter models
+                ModelList.downloadableModels.expanded = true
+            }
+
+            function isShown() {
+                return stackLayout.currentIndex === 2
+            }
+
+            Item {
+                Accessible.name: qsTr("Installed models")
+                Accessible.description: qsTr("View of installed models")
+            }
+
+            Connections {
+                target: modelsView
+                function onAddModelViewRequested() {
+                    addModelView.show();
+                }
+            }
+        }
+
+        LocalDocsView {
+            id: localDocsView
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            function show() {
+                stackLayout.currentIndex = 3;
+            }
+
+            function isShown() {
+                return stackLayout.currentIndex === 3
+            }
+
+            Connections {
+                target: localDocsView
+                function onAddCollectionViewRequested() {
+                    addCollectionView.show();
+                }
+            }
+        }
+
+        SettingsView {
+            id: settingsView
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            function show(page) {
+                settingsView.pageToDisplay = page;
+                stackLayout.currentIndex = 4;
+            }
+
+            function isShown() {
+                return stackLayout.currentIndex === 4
+            }
+        }
+
+        AddCollectionView {
+            id: addCollectionView
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            function show() {
+                stackLayout.currentIndex = 5;
+            }
+            function isShown() {
+                return stackLayout.currentIndex === 5
+            }
+
+            Connections {
+                target: addCollectionView
+                function onLocalDocsViewRequested() {
+                    localDocsView.show();
+                }
+            }
+        }
+
+        AddModelView {
+            id: addModelView
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            function show() {
+                stackLayout.currentIndex = 6;
+            }
+            function isShown() {
+                return stackLayout.currentIndex === 6
+            }
+
+            Connections {
+                target: addModelView
+                function onModelsViewRequested() {
+                    modelsView.show();
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/modellist.h

@@ -0,0 +1,528 @@
+#ifndef MODELLIST_H
+#define MODELLIST_H
+
+#include <QAbstractListModel>
+#include <QByteArray>
+#include <QDateTime>
+#include <QHash>
+#include <QList>
+#include <QMutex>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QObject>
+#include <QPair>
+#include <QSortFilterProxyModel>
+#include <QSslError>
+#include <QString>
+#include <QVariant>
+#include <QVector>
+#include <Qt>
+#include <QtGlobal>
+#include <QtQml>
+
+using namespace Qt::Literals::StringLiterals;
+
+struct ModelInfo {
+    Q_GADGET
+    Q_PROPERTY(QString id READ id WRITE setId)
+    Q_PROPERTY(QString name READ name WRITE setName)
+    Q_PROPERTY(QString filename READ filename WRITE setFilename)
+    Q_PROPERTY(QString dirpath MEMBER dirpath)
+    Q_PROPERTY(QString filesize MEMBER filesize)
+    Q_PROPERTY(QByteArray hash MEMBER hash)
+    Q_PROPERTY(HashAlgorithm hashAlgorithm MEMBER hashAlgorithm)
+    Q_PROPERTY(bool calcHash MEMBER calcHash)
+    Q_PROPERTY(bool installed MEMBER installed)
+    Q_PROPERTY(bool isDefault MEMBER isDefault)
+    Q_PROPERTY(bool isOnline MEMBER isOnline)
+    Q_PROPERTY(bool isCompatibleApi MEMBER isCompatibleApi)
+    Q_PROPERTY(QString description READ description WRITE setDescription)
+    Q_PROPERTY(QString requiresVersion MEMBER requiresVersion)
+    Q_PROPERTY(QString versionRemoved MEMBER versionRemoved)
+    Q_PROPERTY(QString url READ url WRITE setUrl)
+    Q_PROPERTY(qint64 bytesReceived MEMBER bytesReceived)
+    Q_PROPERTY(qint64 bytesTotal MEMBER bytesTotal)
+    Q_PROPERTY(qint64 timestamp MEMBER timestamp)
+    Q_PROPERTY(QString speed MEMBER speed)
+    Q_PROPERTY(bool isDownloading MEMBER isDownloading)
+    Q_PROPERTY(bool isIncomplete MEMBER isIncomplete)
+    Q_PROPERTY(QString downloadError MEMBER downloadError)
+    Q_PROPERTY(QString order MEMBER order)
+    Q_PROPERTY(int ramrequired MEMBER ramrequired)
+    Q_PROPERTY(QString parameters MEMBER parameters)
+    Q_PROPERTY(QString quant READ quant WRITE setQuant)
+    Q_PROPERTY(QString type READ type WRITE setType)
+    Q_PROPERTY(bool isClone READ isClone WRITE setIsClone)
+    Q_PROPERTY(bool isDiscovered READ isDiscovered WRITE setIsDiscovered)
+    Q_PROPERTY(bool isEmbeddingModel MEMBER isEmbeddingModel)
+    Q_PROPERTY(double temperature READ temperature WRITE setTemperature)
+    Q_PROPERTY(double topP READ topP WRITE setTopP)
+    Q_PROPERTY(double minP READ minP WRITE setMinP)
+    Q_PROPERTY(int topK READ topK WRITE setTopK)
+    Q_PROPERTY(int maxLength READ maxLength WRITE setMaxLength)
+    Q_PROPERTY(int promptBatchSize READ promptBatchSize WRITE setPromptBatchSize)
+    Q_PROPERTY(int contextLength READ contextLength WRITE setContextLength)
+    Q_PROPERTY(int maxContextLength READ maxContextLength)
+    Q_PROPERTY(int gpuLayers READ gpuLayers WRITE setGpuLayers)
+    Q_PROPERTY(int maxGpuLayers READ maxGpuLayers)
+    Q_PROPERTY(double repeatPenalty READ repeatPenalty WRITE setRepeatPenalty)
+    Q_PROPERTY(int repeatPenaltyTokens READ repeatPenaltyTokens WRITE setRepeatPenaltyTokens)
+    Q_PROPERTY(QString promptTemplate READ promptTemplate WRITE setPromptTemplate)
+    Q_PROPERTY(QString systemPrompt READ systemPrompt WRITE setSystemPrompt)
+    Q_PROPERTY(QString chatNamePrompt READ chatNamePrompt WRITE setChatNamePrompt)
+    Q_PROPERTY(QString suggestedFollowUpPrompt READ suggestedFollowUpPrompt WRITE setSuggestedFollowUpPrompt)
+    Q_PROPERTY(int likes READ likes WRITE setLikes)
+    Q_PROPERTY(int downloads READ downloads WRITE setDownloads)
+    Q_PROPERTY(QDateTime recency READ recency WRITE setRecency)
+
+public:
+    enum HashAlgorithm {
+        Md5,
+        Sha256
+    };
+
+    QString id() const;
+    void setId(const QString &id);
+
+    QString name() const;
+    void setName(const QString &name);
+
+    QString filename() const;
+    void setFilename(const QString &name);
+
+    QString description() const;
+    void setDescription(const QString &d);
+
+    QString url() const;
+    void setUrl(const QString &u);
+
+    QString quant() const;
+    void setQuant(const QString &q);
+
+    QString type() const;
+    void setType(const QString &t);
+
+    bool isClone() const;
+    void setIsClone(bool b);
+
+    bool isDiscovered() const;
+    void setIsDiscovered(bool b);
+
+    int likes() const;
+    void setLikes(int l);
+
+    int downloads() const;
+    void setDownloads(int d);
+
+    QDateTime recency() const;
+    void setRecency(const QDateTime &r);
+
+    QString dirpath;
+    QString filesize;
+    QByteArray hash;
+    HashAlgorithm hashAlgorithm;
+    bool calcHash = false;
+    bool installed = false;
+    bool isDefault = false;
+    // Differences between 'isOnline' and 'isCompatibleApi' in ModelInfo:
+    // 'isOnline':
+    // - Indicates whether this is a online model.
+    // - Linked with the ModelList, fetching info from it.
+    bool isOnline = false;
+    // 'isCompatibleApi':
+    // - Indicates whether the model is using the OpenAI-compatible API which user custom.
+    // - When the property is true, 'isOnline' should also be true.
+    // - Does not link to the ModelList directly; instead, fetches info from the *-capi.rmodel file and works standalone.
+    // - Still needs to copy data from gpt4all.ini and *-capi.rmodel to the ModelList in memory while application getting started(as custom .gguf models do).
+    bool isCompatibleApi = false;
+    QString requiresVersion;
+    QString versionRemoved;
+    qint64 bytesReceived = 0;
+    qint64 bytesTotal = 0;
+    qint64 timestamp = 0;
+    QString speed;
+    bool isDownloading = false;
+    bool isIncomplete = false;
+    QString downloadError;
+    QString order;
+    int ramrequired = -1;
+    QString parameters;
+    bool isEmbeddingModel = false;
+    bool checkedEmbeddingModel = false;
+
+    bool operator==(const ModelInfo &other) const {
+        return  m_id == other.m_id;
+    }
+
+    double temperature() const;
+    void setTemperature(double t);
+    double topP() const;
+    void setTopP(double p);
+    double minP() const;
+    void setMinP(double p);
+    int topK() const;
+    void setTopK(int k);
+    int maxLength() const;
+    void setMaxLength(int l);
+    int promptBatchSize() const;
+    void setPromptBatchSize(int s);
+    int contextLength() const;
+    void setContextLength(int l);
+    int maxContextLength() const;
+    int gpuLayers() const;
+    void setGpuLayers(int l);
+    int maxGpuLayers() const;
+    double repeatPenalty() const;
+    void setRepeatPenalty(double p);
+    int repeatPenaltyTokens() const;
+    void setRepeatPenaltyTokens(int t);
+    QString promptTemplate() const;
+    void setPromptTemplate(const QString &t);
+    QString systemPrompt() const;
+    void setSystemPrompt(const QString &p);
+    QString chatNamePrompt() const;
+    void setChatNamePrompt(const QString &p);
+    QString suggestedFollowUpPrompt() const;
+    void setSuggestedFollowUpPrompt(const QString &p);
+
+    bool shouldSaveMetadata() const;
+
+private:
+    QVariantMap getFields() const;
+
+    QString m_id;
+    QString m_name;
+    QString m_filename;
+    QString m_description;
+    QString m_url;
+    QString m_quant;
+    QString m_type;
+    bool    m_isClone                 = false;
+    bool    m_isDiscovered            = false;
+    int     m_likes                   = -1;
+    int     m_downloads               = -1;
+    QDateTime m_recency;
+    double  m_temperature             = 0.7;
+    double  m_topP                    = 0.4;
+    double  m_minP                    = 0.0;
+    int     m_topK                    = 40;
+    int     m_maxLength               = 4096;
+    int     m_promptBatchSize         = 128;
+    int     m_contextLength           = 2048;
+    mutable int m_maxContextLength    = -1;
+    int     m_gpuLayers               = 100;
+    mutable int m_maxGpuLayers        = -1;
+    double  m_repeatPenalty           = 1.18;
+    int     m_repeatPenaltyTokens     = 64;
+    QString m_promptTemplate          = "### Human:\n%1\n\n### Assistant:\n";
+    QString m_systemPrompt            = "### System:\nYou are an AI assistant who gives a quality response to whatever humans ask of you.\n\n";
+    QString m_chatNamePrompt          = "Describe the above conversation in seven words or less.";
+    QString m_suggestedFollowUpPrompt = "Suggest three very short factual follow-up questions that have not been answered yet or cannot be found inspired by the previous conversation and excerpts.";
+    friend class MySettings;
+};
+Q_DECLARE_METATYPE(ModelInfo)
+
+class InstalledModels : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+public:
+    explicit InstalledModels(QObject *parent, bool selectable = false);
+    int count() const { return rowCount(); }
+
+Q_SIGNALS:
+    void countChanged();
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+
+private:
+    bool m_selectable;
+};
+
+class DownloadableModels : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(bool expanded READ isExpanded WRITE setExpanded NOTIFY expandedChanged)
+public:
+    explicit DownloadableModels(QObject *parent);
+    int count() const;
+
+    bool isExpanded() const;
+    void setExpanded(bool expanded);
+
+    Q_INVOKABLE void discoverAndFilter(const QString &discover);
+
+Q_SIGNALS:
+    void countChanged();
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+
+Q_SIGNALS:
+    void expandedChanged(bool expanded);
+
+private:
+    bool m_expanded;
+    int m_limit;
+    QString m_discoverFilter;
+};
+
+class ModelList : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(InstalledModels* installedModels READ installedModels NOTIFY installedModelsChanged)
+    Q_PROPERTY(InstalledModels* selectableModels READ selectableModels NOTIFY selectableModelsChanged)
+    Q_PROPERTY(DownloadableModels* downloadableModels READ downloadableModels NOTIFY downloadableModelsChanged)
+    Q_PROPERTY(QList<ModelInfo> selectableModelList READ selectableModelList NOTIFY  selectableModelListChanged)
+    Q_PROPERTY(bool asyncModelRequestOngoing READ asyncModelRequestOngoing NOTIFY asyncModelRequestOngoingChanged)
+    Q_PROPERTY(int discoverLimit READ discoverLimit WRITE setDiscoverLimit NOTIFY discoverLimitChanged)
+    Q_PROPERTY(int discoverSortDirection READ discoverSortDirection WRITE setDiscoverSortDirection NOTIFY discoverSortDirectionChanged)
+    Q_PROPERTY(DiscoverSort discoverSort READ discoverSort WRITE setDiscoverSort NOTIFY discoverSortChanged)
+    Q_PROPERTY(float discoverProgress READ discoverProgress NOTIFY discoverProgressChanged)
+    Q_PROPERTY(bool discoverInProgress READ discoverInProgress NOTIFY discoverInProgressChanged)
+
+public:
+    static ModelList *globalInstance();
+
+    static QString compatibleModelNameHash(QUrl baseUrl, QString modelName);
+    static QString compatibleModelFilename(QUrl baseUrl, QString modelName);
+
+    enum DiscoverSort {
+        Default,
+        Likes,
+        Downloads,
+        Recent
+    };
+
+    enum Roles {
+        IdRole = Qt::UserRole + 1,
+        NameRole,
+        FilenameRole,
+        DirpathRole,
+        FilesizeRole,
+        HashRole,
+        HashAlgorithmRole,
+        CalcHashRole,
+        InstalledRole,
+        DefaultRole,
+        OnlineRole,
+        CompatibleApiRole,
+        DescriptionRole,
+        RequiresVersionRole,
+        VersionRemovedRole,
+        UrlRole,
+        BytesReceivedRole,
+        BytesTotalRole,
+        TimestampRole,
+        SpeedRole,
+        DownloadingRole,
+        IncompleteRole,
+        DownloadErrorRole,
+        OrderRole,
+        RamrequiredRole,
+        ParametersRole,
+        QuantRole,
+        TypeRole,
+        IsCloneRole,
+        IsDiscoveredRole,
+        IsEmbeddingModelRole,
+        TemperatureRole,
+        TopPRole,
+        TopKRole,
+        MaxLengthRole,
+        PromptBatchSizeRole,
+        ContextLengthRole,
+        GpuLayersRole,
+        RepeatPenaltyRole,
+        RepeatPenaltyTokensRole,
+        PromptTemplateRole,
+        SystemPromptRole,
+        ChatNamePromptRole,
+        SuggestedFollowUpPromptRole,
+        MinPRole,
+        LikesRole,
+        DownloadsRole,
+        RecencyRole
+    };
+
+    QHash<int, QByteArray> roleNames() const override
+    {
+        QHash<int, QByteArray> roles;
+        roles[IdRole] = "id";
+        roles[NameRole] = "name";
+        roles[FilenameRole] = "filename";
+        roles[DirpathRole] = "dirpath";
+        roles[FilesizeRole] = "filesize";
+        roles[HashRole] = "hash";
+        roles[HashAlgorithmRole] = "hashAlgorithm";
+        roles[CalcHashRole] = "calcHash";
+        roles[InstalledRole] = "installed";
+        roles[DefaultRole] = "isDefault";
+        roles[OnlineRole] = "isOnline";
+        roles[CompatibleApiRole] = "isCompatibleApi";
+        roles[DescriptionRole] = "description";
+        roles[RequiresVersionRole] = "requiresVersion";
+        roles[VersionRemovedRole] = "versionRemoved";
+        roles[UrlRole] = "url";
+        roles[BytesReceivedRole] = "bytesReceived";
+        roles[BytesTotalRole] = "bytesTotal";
+        roles[TimestampRole] = "timestamp";
+        roles[SpeedRole] = "speed";
+        roles[DownloadingRole] = "isDownloading";
+        roles[IncompleteRole] = "isIncomplete";
+        roles[DownloadErrorRole] = "downloadError";
+        roles[OrderRole] = "order";
+        roles[RamrequiredRole] = "ramrequired";
+        roles[ParametersRole] = "parameters";
+        roles[QuantRole] = "quant";
+        roles[TypeRole] = "type";
+        roles[IsCloneRole] = "isClone";
+        roles[IsDiscoveredRole] = "isDiscovered";
+        roles[IsEmbeddingModelRole] = "isEmbeddingModel";
+        roles[TemperatureRole] = "temperature";
+        roles[TopPRole] = "topP";
+        roles[MinPRole] = "minP";
+        roles[TopKRole] = "topK";
+        roles[MaxLengthRole] = "maxLength";
+        roles[PromptBatchSizeRole] = "promptBatchSize";
+        roles[ContextLengthRole] = "contextLength";
+        roles[GpuLayersRole] = "gpuLayers";
+        roles[RepeatPenaltyRole] = "repeatPenalty";
+        roles[RepeatPenaltyTokensRole] = "repeatPenaltyTokens";
+        roles[PromptTemplateRole] = "promptTemplate";
+        roles[SystemPromptRole] = "systemPrompt";
+        roles[ChatNamePromptRole] = "chatNamePrompt";
+        roles[SuggestedFollowUpPromptRole] = "suggestedFollowUpPrompt";
+        roles[LikesRole] = "likes";
+        roles[DownloadsRole] = "downloads";
+        roles[RecencyRole] = "recency";
+        return roles;
+    }
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QVariant data(const QString &id, int role) const;
+    QVariant dataByFilename(const QString &filename, int role) const;
+    void updateDataByFilename(const QString &filename, QVector<QPair<int, QVariant>> data);
+    void updateData(const QString &id, const QVector<QPair<int, QVariant>> &data);
+
+    int count() const { return m_models.size(); }
+
+    bool contains(const QString &id) const;
+    bool containsByFilename(const QString &filename) const;
+    Q_INVOKABLE ModelInfo modelInfo(const QString &id) const;
+    Q_INVOKABLE ModelInfo modelInfoByFilename(const QString &filename) const;
+    Q_INVOKABLE bool isUniqueName(const QString &name) const;
+    Q_INVOKABLE QString clone(const ModelInfo &model);
+    Q_INVOKABLE void removeClone(const ModelInfo &model);
+    Q_INVOKABLE void removeInstalled(const ModelInfo &model);
+    ModelInfo defaultModelInfo() const;
+
+    void addModel(const QString &id);
+    void changeId(const QString &oldId, const QString &newId);
+
+    const QList<ModelInfo> selectableModelList() const;
+
+    InstalledModels *installedModels() const { return m_installedModels; }
+    InstalledModels *selectableModels() const { return m_selectableModels; }
+    DownloadableModels *downloadableModels() const { return m_downloadableModels; }
+
+    static inline QString toFileSize(quint64 sz) {
+        if (sz < 1024) {
+            return u"%1 bytes"_s.arg(sz);
+        } else if (sz < 1024 * 1024) {
+            return u"%1 KB"_s.arg(qreal(sz) / 1024, 0, 'g', 3);
+        } else if (sz < 1024 * 1024 * 1024) {
+            return u"%1 MB"_s.arg(qreal(sz) / (1024 * 1024), 0, 'g', 3);
+        } else {
+            return u"%1 GB"_s.arg(qreal(sz) / (1024 * 1024 * 1024), 0, 'g', 3);
+        }
+    }
+
+    QString incompleteDownloadPath(const QString &modelFile);
+    bool asyncModelRequestOngoing() const { return m_asyncModelRequestOngoing; }
+
+    void updateModelsFromDirectory();
+    void updateDiscoveredInstalled(const ModelInfo &info);
+
+    int discoverLimit() const;
+    void setDiscoverLimit(int limit);
+
+    int discoverSortDirection() const;
+    void setDiscoverSortDirection(int direction); // -1 or 1
+
+    DiscoverSort discoverSort() const;
+    void setDiscoverSort(DiscoverSort sort);
+
+    float discoverProgress() const;
+    bool discoverInProgress() const;
+
+    Q_INVOKABLE void discoverSearch(const QString &discover);
+
+Q_SIGNALS:
+    void countChanged();
+    void installedModelsChanged();
+    void selectableModelsChanged();
+    void downloadableModelsChanged();
+    void selectableModelListChanged();
+    void asyncModelRequestOngoingChanged();
+    void discoverLimitChanged();
+    void discoverSortDirectionChanged();
+    void discoverSortChanged();
+    void discoverProgressChanged();
+    void discoverInProgressChanged();
+
+protected:
+    bool eventFilter(QObject *obj, QEvent *ev) override;
+
+private Q_SLOTS:
+    void resortModel();
+    void updateModelsFromJson();
+    void updateModelsFromJsonAsync();
+    void updateModelsFromSettings();
+    void updateDataForSettings();
+    void handleModelsJsonDownloadFinished();
+    void handleModelsJsonDownloadErrorOccurred(QNetworkReply::NetworkError code);
+    void handleDiscoveryFinished();
+    void handleDiscoveryErrorOccurred(QNetworkReply::NetworkError code);
+    void handleDiscoveryItemFinished();
+    void handleDiscoveryItemErrorOccurred(QNetworkReply::NetworkError code);
+    void handleSslErrors(QNetworkReply *reply, const QList<QSslError> &errors);
+
+private:
+    void removeInternal(const ModelInfo &model);
+    void clearDiscoveredModels();
+    bool modelExists(const QString &fileName) const;
+    int indexForModel(ModelInfo *model);
+    QVariant dataInternal(const ModelInfo *info, int role) const;
+    static bool lessThan(const ModelInfo* a, const ModelInfo* b, DiscoverSort s, int d);
+    void parseModelsJsonFile(const QByteArray &jsonData, bool save);
+    void parseDiscoveryJsonFile(const QByteArray &jsonData);
+    QString uniqueModelName(const ModelInfo &model) const;
+
+private:
+    mutable QMutex m_mutex;
+    QNetworkAccessManager m_networkManager;
+    InstalledModels *m_installedModels;
+    InstalledModels *m_selectableModels;
+    DownloadableModels *m_downloadableModels;
+    QList<ModelInfo*> m_models;
+    QHash<QString, ModelInfo*> m_modelMap;
+    bool m_asyncModelRequestOngoing;
+    int m_discoverLimit;
+    int m_discoverSortDirection;
+    DiscoverSort m_discoverSort;
+    int m_discoverNumberOfResults;
+    int m_discoverResultsCompleted;
+    bool m_discoverInProgress;
+
+protected:
+    explicit ModelList();
+    ~ModelList() { for (auto *model: m_models) { delete model; } }
+    friend class MyModelList;
+};
+
+#endif // MODELLIST_H

gpt4all-chat/src/mysettings.cpp

@@ -0,0 +1,669 @@
+#include "mysettings.h"
+
+#include <gpt4all-backend/llmodel.h>
+
+#include <QDebug>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QGlobalStatic>
+#include <QGuiApplication>
+#include <QIODevice>
+#include <QMap>
+#include <QMetaObject>
+#include <QStandardPaths>
+#include <QThread>
+#include <QUrl>
+#include <QVariant>
+#include <QtLogging>
+
+#include <algorithm>
+#include <string>
+#include <thread>
+#include <vector>
+
+using namespace Qt::Literals::StringLiterals;
+
+// used only for settings serialization, do not translate
+static const QStringList suggestionModeNames { "LocalDocsOnly", "On", "Off" };
+static const QStringList chatThemeNames      { "Light", "Dark", "LegacyDark" };
+static const QStringList fontSizeNames       { "Small", "Medium", "Large" };
+
+// FIXME: All of these default strings that are shown in the UI for settings need to be marked as
+// translatable
+
+namespace defaults {
+
+static const int     threadCount             = std::min(4, (int32_t) std::thread::hardware_concurrency());
+static const bool    forceMetal              = false;
+static const bool    networkIsActive         = false;
+static const bool    networkUsageStatsActive = false;
+static const QString device                  = "Auto";
+static const QString languageAndLocale       = "System Locale";
+
+} // namespace defaults
+
+static const QVariantMap basicDefaults {
+    { "chatTheme",                QVariant::fromValue(ChatTheme::Light) },
+    { "fontSize",                 QVariant::fromValue(FontSize::Small) },
+    { "lastVersionStarted",       "" },
+    { "networkPort",              4891, },
+    { "saveChatsContext",         false },
+    { "serverChat",               false },
+    { "userDefaultModel",         "Application default" },
+    { "suggestionMode",           QVariant::fromValue(SuggestionMode::LocalDocsOnly) },
+    { "localdocs/chunkSize",      512 },
+    { "localdocs/retrievalSize",  3 },
+    { "localdocs/showReferences", true },
+    { "localdocs/fileExtensions", QStringList { "txt", "pdf", "md", "rst" } },
+    { "localdocs/useRemoteEmbed", false },
+    { "localdocs/nomicAPIKey",    "" },
+    { "localdocs/embedDevice",    "Auto" },
+    { "network/attribution",      "" },
+};
+
+static QString defaultLocalModelsPath()
+{
+    QString localPath = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation)
+        + "/";
+    QString testWritePath = localPath + u"test_write.txt"_s;
+    QString canonicalLocalPath = QFileInfo(localPath).canonicalFilePath() + "/";
+    QDir localDir(localPath);
+    if (!localDir.exists()) {
+        if (!localDir.mkpath(localPath)) {
+            qWarning() << "ERROR: Local download directory can't be created:" << canonicalLocalPath;
+            return canonicalLocalPath;
+        }
+    }
+
+    if (QFileInfo::exists(testWritePath))
+        return canonicalLocalPath;
+
+    QFile testWriteFile(testWritePath);
+    if (testWriteFile.open(QIODeviceBase::ReadWrite)) {
+        testWriteFile.close();
+        return canonicalLocalPath;
+    }
+
+    qWarning() << "ERROR: Local download path appears not writeable:" << canonicalLocalPath;
+    return canonicalLocalPath;
+}
+
+static QStringList getDevices(bool skipKompute = false)
+{
+    QStringList deviceList;
+#if defined(Q_OS_MAC) && defined(__aarch64__)
+    deviceList << "Metal";
+#else
+    std::vector<LLModel::GPUDevice> devices = LLModel::Implementation::availableGPUDevices();
+    for (LLModel::GPUDevice &d : devices) {
+        if (!skipKompute || strcmp(d.backend, "kompute"))
+            deviceList << QString::fromStdString(d.selectionName());
+    }
+#endif
+    deviceList << "CPU";
+    return deviceList;
+}
+
+static QString getUiLanguage(const QString directory, const QString fileName)
+{
+    QTranslator translator;
+    const QString filePath = directory + QDir::separator() + fileName;
+    if (translator.load(filePath)) {
+        const QString lang = fileName.mid(fileName.indexOf('_') + 1,
+            fileName.lastIndexOf('.') - fileName.indexOf('_') - 1);
+        return lang;
+    }
+
+    qDebug() << "ERROR: Failed to load translation file:" << filePath;
+    return QString();
+}
+
+static QStringList getUiLanguages(const QString &modelPath)
+{
+    QStringList languageList;
+    static const QStringList releasedLanguages = { "en_US", "it_IT", "zh_CN", "zh_TW", "es_MX", "pt_BR", "ro_RO" };
+
+    // Add the language translations from model path files first which is used by translation developers
+    // to load translations in progress without having to rebuild all of GPT4All from source
+    {
+        const QDir dir(modelPath);
+        const QStringList qmFiles = dir.entryList({"*.qm"}, QDir::Files);
+        for (const QString &fileName : qmFiles)
+            languageList << getUiLanguage(modelPath, fileName);
+    }
+
+    // Now add the internal language translations
+    {
+        const QDir dir(":/i18n");
+        const QStringList qmFiles = dir.entryList({"*.qm"}, QDir::Files);
+        for (const QString &fileName : qmFiles) {
+            const QString lang = getUiLanguage(":/i18n", fileName);
+            if (!languageList.contains(lang) && releasedLanguages.contains(lang))
+                languageList.append(lang);
+        }
+    }
+    return languageList;
+}
+
+class MyPrivateSettings: public MySettings { };
+Q_GLOBAL_STATIC(MyPrivateSettings, settingsInstance)
+MySettings *MySettings::globalInstance()
+{
+    return settingsInstance();
+}
+
+MySettings::MySettings()
+    : QObject(nullptr)
+    , m_deviceList(getDevices())
+    , m_embeddingsDeviceList(getDevices(/*skipKompute*/ true))
+    , m_uiLanguages(getUiLanguages(modelPath()))
+{
+}
+
+QVariant MySettings::getBasicSetting(const QString &name) const
+{
+    return m_settings.value(name, basicDefaults.value(name));
+}
+
+void MySettings::setBasicSetting(const QString &name, const QVariant &value, std::optional<QString> signal)
+{
+    if (getBasicSetting(name) == value)
+        return;
+
+    m_settings.setValue(name, value);
+    QMetaObject::invokeMethod(this, u"%1Changed"_s.arg(signal.value_or(name)).toLatin1().constData());
+}
+
+int MySettings::getEnumSetting(const QString &setting, const QStringList &valueNames) const
+{
+    int idx = valueNames.indexOf(getBasicSetting(setting).toString());
+    return idx != -1 ? idx : *reinterpret_cast<const int *>(basicDefaults.value(setting).constData());
+}
+
+void MySettings::restoreModelDefaults(const ModelInfo &info)
+{
+    setModelTemperature(info, info.m_temperature);
+    setModelTopP(info, info.m_topP);
+    setModelMinP(info, info.m_minP);
+    setModelTopK(info, info.m_topK);;
+    setModelMaxLength(info, info.m_maxLength);
+    setModelPromptBatchSize(info, info.m_promptBatchSize);
+    setModelContextLength(info, info.m_contextLength);
+    setModelGpuLayers(info, info.m_gpuLayers);
+    setModelRepeatPenalty(info, info.m_repeatPenalty);
+    setModelRepeatPenaltyTokens(info, info.m_repeatPenaltyTokens);
+    setModelPromptTemplate(info, info.m_promptTemplate);
+    setModelSystemPrompt(info, info.m_systemPrompt);
+    setModelChatNamePrompt(info, info.m_chatNamePrompt);
+    setModelSuggestedFollowUpPrompt(info, info.m_suggestedFollowUpPrompt);
+}
+
+void MySettings::restoreApplicationDefaults()
+{
+    setChatTheme(basicDefaults.value("chatTheme").value<ChatTheme>());
+    setFontSize(basicDefaults.value("fontSize").value<FontSize>());
+    setDevice(defaults::device);
+    setThreadCount(defaults::threadCount);
+    setSaveChatsContext(basicDefaults.value("saveChatsContext").toBool());
+    setServerChat(basicDefaults.value("serverChat").toBool());
+    setNetworkPort(basicDefaults.value("networkPort").toInt());
+    setModelPath(defaultLocalModelsPath());
+    setUserDefaultModel(basicDefaults.value("userDefaultModel").toString());
+    setForceMetal(defaults::forceMetal);
+    setSuggestionMode(basicDefaults.value("suggestionMode").value<SuggestionMode>());
+    setLanguageAndLocale(defaults::languageAndLocale);
+}
+
+void MySettings::restoreLocalDocsDefaults()
+{
+    setLocalDocsChunkSize(basicDefaults.value("localdocs/chunkSize").toInt());
+    setLocalDocsRetrievalSize(basicDefaults.value("localdocs/retrievalSize").toInt());
+    setLocalDocsShowReferences(basicDefaults.value("localdocs/showReferences").toBool());
+    setLocalDocsFileExtensions(basicDefaults.value("localdocs/fileExtensions").toStringList());
+    setLocalDocsUseRemoteEmbed(basicDefaults.value("localdocs/useRemoteEmbed").toBool());
+    setLocalDocsNomicAPIKey(basicDefaults.value("localdocs/nomicAPIKey").toString());
+    setLocalDocsEmbedDevice(basicDefaults.value("localdocs/embedDevice").toString());
+}
+
+void MySettings::eraseModel(const ModelInfo &info)
+{
+    m_settings.remove(u"model-%1"_s.arg(info.id()));
+}
+
+QString MySettings::modelName(const ModelInfo &info) const
+{
+    return m_settings.value(u"model-%1/name"_s.arg(info.id()),
+        !info.m_name.isEmpty() ? info.m_name : info.m_filename).toString();
+}
+
+void MySettings::setModelName(const ModelInfo &info, const QString &value, bool force)
+{
+    if ((modelName(info) == value || info.id().isEmpty()) && !force)
+        return;
+
+    if ((info.m_name == value || info.m_filename == value) && !info.shouldSaveMetadata())
+        m_settings.remove(u"model-%1/name"_s.arg(info.id()));
+    else
+        m_settings.setValue(u"model-%1/name"_s.arg(info.id()), value);
+    if (!force)
+        emit nameChanged(info);
+}
+
+static QString modelSettingName(const ModelInfo &info, const QString &name)
+{
+    return u"model-%1/%2"_s.arg(info.id(), name);
+}
+
+QVariant MySettings::getModelSetting(const QString &name, const ModelInfo &info) const
+{
+    return m_settings.value(modelSettingName(info, name), info.getFields().value(name));
+}
+
+void MySettings::setModelSetting(const QString &name, const ModelInfo &info, const QVariant &value, bool force,
+                                 bool signal)
+{
+    if (!force && (info.id().isEmpty() || getModelSetting(name, info) == value))
+        return;
+
+    QString settingName = modelSettingName(info, name);
+    if (info.getFields().value(name) == value && !info.shouldSaveMetadata())
+        m_settings.remove(settingName);
+    else
+        m_settings.setValue(settingName, value);
+    if (signal && !force)
+        QMetaObject::invokeMethod(this, u"%1Changed"_s.arg(name).toLatin1().constData(), Q_ARG(ModelInfo, info));
+}
+
+QString   MySettings::modelFilename               (const ModelInfo &info) const { return getModelSetting("filename",                info).toString(); }
+QString   MySettings::modelDescription            (const ModelInfo &info) const { return getModelSetting("description",             info).toString(); }
+QString   MySettings::modelUrl                    (const ModelInfo &info) const { return getModelSetting("url",                     info).toString(); }
+QString   MySettings::modelQuant                  (const ModelInfo &info) const { return getModelSetting("quant",                   info).toString(); }
+QString   MySettings::modelType                   (const ModelInfo &info) const { return getModelSetting("type",                    info).toString(); }
+bool      MySettings::modelIsClone                (const ModelInfo &info) const { return getModelSetting("isClone",                 info).toBool(); }
+bool      MySettings::modelIsDiscovered           (const ModelInfo &info) const { return getModelSetting("isDiscovered",            info).toBool(); }
+int       MySettings::modelLikes                  (const ModelInfo &info) const { return getModelSetting("likes",                   info).toInt(); }
+int       MySettings::modelDownloads              (const ModelInfo &info) const { return getModelSetting("downloads",               info).toInt(); }
+QDateTime MySettings::modelRecency                (const ModelInfo &info) const { return getModelSetting("recency",                 info).toDateTime(); }
+double    MySettings::modelTemperature            (const ModelInfo &info) const { return getModelSetting("temperature",             info).toDouble(); }
+double    MySettings::modelTopP                   (const ModelInfo &info) const { return getModelSetting("topP",                    info).toDouble(); }
+double    MySettings::modelMinP                   (const ModelInfo &info) const { return getModelSetting("minP",                    info).toDouble(); }
+int       MySettings::modelTopK                   (const ModelInfo &info) const { return getModelSetting("topK",                    info).toInt(); }
+int       MySettings::modelMaxLength              (const ModelInfo &info) const { return getModelSetting("maxLength",               info).toInt(); }
+int       MySettings::modelPromptBatchSize        (const ModelInfo &info) const { return getModelSetting("promptBatchSize",         info).toInt(); }
+int       MySettings::modelContextLength          (const ModelInfo &info) const { return getModelSetting("contextLength",           info).toInt(); }
+int       MySettings::modelGpuLayers              (const ModelInfo &info) const { return getModelSetting("gpuLayers",               info).toInt(); }
+double    MySettings::modelRepeatPenalty          (const ModelInfo &info) const { return getModelSetting("repeatPenalty",           info).toDouble(); }
+int       MySettings::modelRepeatPenaltyTokens    (const ModelInfo &info) const { return getModelSetting("repeatPenaltyTokens",     info).toInt(); }
+QString   MySettings::modelPromptTemplate         (const ModelInfo &info) const { return getModelSetting("promptTemplate",          info).toString(); }
+QString   MySettings::modelSystemPrompt           (const ModelInfo &info) const { return getModelSetting("systemPrompt",            info).toString(); }
+QString   MySettings::modelChatNamePrompt         (const ModelInfo &info) const { return getModelSetting("chatNamePrompt",          info).toString(); }
+QString   MySettings::modelSuggestedFollowUpPrompt(const ModelInfo &info) const { return getModelSetting("suggestedFollowUpPrompt", info).toString(); }
+
+void MySettings::setModelFilename(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("filename", info, value, force, true);
+}
+
+void MySettings::setModelDescription(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("description", info, value, force, true);
+}
+
+void MySettings::setModelUrl(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("url", info, value, force);
+}
+
+void MySettings::setModelQuant(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("quant", info, value, force);
+}
+
+void MySettings::setModelType(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("type", info, value, force);
+}
+
+void MySettings::setModelIsClone(const ModelInfo &info, bool value, bool force)
+{
+    setModelSetting("isClone", info, value, force);
+}
+
+void MySettings::setModelIsDiscovered(const ModelInfo &info, bool value, bool force)
+{
+    setModelSetting("isDiscovered", info, value, force);
+}
+
+void MySettings::setModelLikes(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("likes", info, value, force);
+}
+
+void MySettings::setModelDownloads(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("downloads", info, value, force);
+}
+
+void MySettings::setModelRecency(const ModelInfo &info, const QDateTime &value, bool force)
+{
+    setModelSetting("recency", info, value, force);
+}
+
+void MySettings::setModelTemperature(const ModelInfo &info, double value, bool force)
+{
+    setModelSetting("temperature", info, value, force, true);
+}
+
+void MySettings::setModelTopP(const ModelInfo &info, double value, bool force)
+{
+    setModelSetting("topP", info, value, force, true);
+}
+
+void MySettings::setModelMinP(const ModelInfo &info, double value, bool force)
+{
+    setModelSetting("minP", info, value, force, true);
+}
+
+void MySettings::setModelTopK(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("topK", info, value, force, true);
+}
+
+void MySettings::setModelMaxLength(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("maxLength", info, value, force, true);
+}
+
+void MySettings::setModelPromptBatchSize(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("promptBatchSize", info, value, force, true);
+}
+
+void MySettings::setModelContextLength(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("contextLength", info, value, force, true);
+}
+
+void MySettings::setModelGpuLayers(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("gpuLayers", info, value, force, true);
+}
+
+void MySettings::setModelRepeatPenalty(const ModelInfo &info, double value, bool force)
+{
+    setModelSetting("repeatPenalty", info, value, force, true);
+}
+
+void MySettings::setModelRepeatPenaltyTokens(const ModelInfo &info, int value, bool force)
+{
+    setModelSetting("repeatPenaltyTokens", info, value, force, true);
+}
+
+void MySettings::setModelPromptTemplate(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("promptTemplate", info, value, force, true);
+}
+
+void MySettings::setModelSystemPrompt(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("systemPrompt", info, value, force, true);
+}
+
+void MySettings::setModelChatNamePrompt(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("chatNamePrompt", info, value, force, true);
+}
+
+void MySettings::setModelSuggestedFollowUpPrompt(const ModelInfo &info, const QString &value, bool force)
+{
+    setModelSetting("suggestedFollowUpPrompt", info, value, force, true);
+}
+
+int MySettings::threadCount() const
+{
+    int c = m_settings.value("threadCount", defaults::threadCount).toInt();
+    // The old thread setting likely left many people with 0 in settings config file, which means
+    // we should reset it to the default going forward
+    if (c <= 0)
+        c = defaults::threadCount;
+    c = std::max(c, 1);
+    c = std::min(c, QThread::idealThreadCount());
+    return c;
+}
+
+void MySettings::setThreadCount(int value)
+{
+    if (threadCount() == value)
+        return;
+
+    value = std::max(value, 1);
+    value = std::min(value, QThread::idealThreadCount());
+    m_settings.setValue("threadCount", value);
+    emit threadCountChanged();
+}
+
+bool        MySettings::saveChatsContext() const        { return getBasicSetting("saveChatsContext"        ).toBool(); }
+bool        MySettings::serverChat() const              { return getBasicSetting("serverChat"              ).toBool(); }
+int         MySettings::networkPort() const             { return getBasicSetting("networkPort"             ).toInt(); }
+QString     MySettings::userDefaultModel() const        { return getBasicSetting("userDefaultModel"        ).toString(); }
+QString     MySettings::lastVersionStarted() const      { return getBasicSetting("lastVersionStarted"      ).toString(); }
+int         MySettings::localDocsChunkSize() const      { return getBasicSetting("localdocs/chunkSize"     ).toInt(); }
+int         MySettings::localDocsRetrievalSize() const  { return getBasicSetting("localdocs/retrievalSize" ).toInt(); }
+bool        MySettings::localDocsShowReferences() const { return getBasicSetting("localdocs/showReferences").toBool(); }
+QStringList MySettings::localDocsFileExtensions() const { return getBasicSetting("localdocs/fileExtensions").toStringList(); }
+bool        MySettings::localDocsUseRemoteEmbed() const { return getBasicSetting("localdocs/useRemoteEmbed").toBool(); }
+QString     MySettings::localDocsNomicAPIKey() const    { return getBasicSetting("localdocs/nomicAPIKey"   ).toString(); }
+QString     MySettings::localDocsEmbedDevice() const    { return getBasicSetting("localdocs/embedDevice"   ).toString(); }
+QString     MySettings::networkAttribution() const      { return getBasicSetting("network/attribution"     ).toString(); }
+
+ChatTheme      MySettings::chatTheme() const      { return ChatTheme     (getEnumSetting("chatTheme", chatThemeNames)); }
+FontSize       MySettings::fontSize() const       { return FontSize      (getEnumSetting("fontSize",  fontSizeNames)); }
+SuggestionMode MySettings::suggestionMode() const { return SuggestionMode(getEnumSetting("suggestionMode", suggestionModeNames)); }
+
+void MySettings::setSaveChatsContext(bool value)                      { setBasicSetting("saveChatsContext",         value); }
+void MySettings::setServerChat(bool value)                            { setBasicSetting("serverChat",               value); }
+void MySettings::setNetworkPort(int value)                            { setBasicSetting("networkPort",              value); }
+void MySettings::setUserDefaultModel(const QString &value)            { setBasicSetting("userDefaultModel",         value); }
+void MySettings::setLastVersionStarted(const QString &value)          { setBasicSetting("lastVersionStarted",       value); }
+void MySettings::setLocalDocsChunkSize(int value)                     { setBasicSetting("localdocs/chunkSize",      value, "localDocsChunkSize"); }
+void MySettings::setLocalDocsRetrievalSize(int value)                 { setBasicSetting("localdocs/retrievalSize",  value, "localDocsRetrievalSize"); }
+void MySettings::setLocalDocsShowReferences(bool value)               { setBasicSetting("localdocs/showReferences", value, "localDocsShowReferences"); }
+void MySettings::setLocalDocsFileExtensions(const QStringList &value) { setBasicSetting("localdocs/fileExtensions", value, "localDocsFileExtensions"); }
+void MySettings::setLocalDocsUseRemoteEmbed(bool value)               { setBasicSetting("localdocs/useRemoteEmbed", value, "localDocsUseRemoteEmbed"); }
+void MySettings::setLocalDocsNomicAPIKey(const QString &value)        { setBasicSetting("localdocs/nomicAPIKey",    value, "localDocsNomicAPIKey"); }
+void MySettings::setLocalDocsEmbedDevice(const QString &value)        { setBasicSetting("localdocs/embedDevice",    value, "localDocsEmbedDevice"); }
+void MySettings::setNetworkAttribution(const QString &value)          { setBasicSetting("network/attribution",      value, "networkAttribution"); }
+
+void MySettings::setChatTheme(ChatTheme value)           { setBasicSetting("chatTheme",      chatThemeNames     .value(int(value))); }
+void MySettings::setFontSize(FontSize value)             { setBasicSetting("fontSize",       fontSizeNames      .value(int(value))); }
+void MySettings::setSuggestionMode(SuggestionMode value) { setBasicSetting("suggestionMode", suggestionModeNames.value(int(value))); }
+
+QString MySettings::modelPath()
+{
+    // We have to migrate the old setting because I changed the setting key recklessly in v2.4.11
+    // which broke a lot of existing installs
+    const bool containsOldSetting = m_settings.contains("modelPaths");
+    if (containsOldSetting) {
+        const bool containsNewSetting = m_settings.contains("modelPath");
+        if (!containsNewSetting)
+            m_settings.setValue("modelPath", m_settings.value("modelPaths"));
+        m_settings.remove("modelPaths");
+    }
+    return m_settings.value("modelPath", defaultLocalModelsPath()).toString();
+}
+
+void MySettings::setModelPath(const QString &value)
+{
+    QString filePath = (value.startsWith("file://") ?
+                        QUrl(value).toLocalFile() : value);
+    QString canonical = QFileInfo(filePath).canonicalFilePath() + "/";
+    if (modelPath() == canonical)
+        return;
+    m_settings.setValue("modelPath", canonical);
+    emit modelPathChanged();
+}
+
+QString MySettings::device()
+{
+    auto value = m_settings.value("device");
+    if (!value.isValid())
+        return defaults::device;
+
+    auto device = value.toString();
+    if (!device.isEmpty()) {
+        auto deviceStr = device.toStdString();
+        auto newNameStr = LLModel::GPUDevice::updateSelectionName(deviceStr);
+        if (newNameStr != deviceStr) {
+            auto newName = QString::fromStdString(newNameStr);
+            qWarning() << "updating device name:" << device << "->" << newName;
+            device = newName;
+            m_settings.setValue("device", device);
+        }
+    }
+    return device;
+}
+
+void MySettings::setDevice(const QString &value)
+{
+    if (device() != value) {
+        m_settings.setValue("device", value);
+        emit deviceChanged();
+    }
+}
+
+bool MySettings::forceMetal() const
+{
+    return m_forceMetal;
+}
+
+void MySettings::setForceMetal(bool value)
+{
+    if (m_forceMetal != value) {
+        m_forceMetal = value;
+        emit forceMetalChanged(value);
+    }
+}
+
+bool MySettings::networkIsActive() const
+{
+    return m_settings.value("network/isActive", defaults::networkIsActive).toBool();
+}
+
+bool MySettings::isNetworkIsActiveSet() const
+{
+    return m_settings.value("network/isActive").isValid();
+}
+
+void MySettings::setNetworkIsActive(bool value)
+{
+    auto cur = m_settings.value("network/isActive");
+    if (!cur.isValid() || cur.toBool() != value) {
+        m_settings.setValue("network/isActive", value);
+        emit networkIsActiveChanged();
+    }
+}
+
+bool MySettings::networkUsageStatsActive() const
+{
+    return m_settings.value("network/usageStatsActive", defaults::networkUsageStatsActive).toBool();
+}
+
+bool MySettings::isNetworkUsageStatsActiveSet() const
+{
+    return m_settings.value("network/usageStatsActive").isValid();
+}
+
+void MySettings::setNetworkUsageStatsActive(bool value)
+{
+    auto cur = m_settings.value("network/usageStatsActive");
+    if (!cur.isValid() || cur.toBool() != value) {
+        m_settings.setValue("network/usageStatsActive", value);
+        emit networkUsageStatsActiveChanged();
+    }
+}
+
+QString MySettings::languageAndLocale() const
+{
+    auto value = m_settings.value("languageAndLocale");
+    if (!value.isValid())
+        return defaults::languageAndLocale;
+    return value.toString();
+}
+
+QString MySettings::filePathForLocale(const QLocale &locale)
+{
+    // Check and see if we have a translation for the chosen locale and set it if possible otherwise
+    // we return the filepath for the 'en_US' translation
+    QStringList uiLanguages = locale.uiLanguages();
+    for (int i = 0; i < uiLanguages.size(); ++i)
+        uiLanguages[i].replace('-', '_');
+
+    // Scan this directory for files named like gpt4all_%1.qm that match and if so return them first
+    // this is the model download directory and it can be used by translation developers who are
+    // trying to test their translations by just compiling the translation with the lrelease tool
+    // rather than having to recompile all of GPT4All
+    QString directory = modelPath();
+    for (const QString &bcp47Name : uiLanguages) {
+        QString filePath = u"%1/gpt4all_%2.qm"_s.arg(directory, bcp47Name);
+        QFileInfo filePathInfo(filePath);
+        if (filePathInfo.exists()) return filePath;
+    }
+
+    // Now scan the internal built-in translations
+    for (QString bcp47Name : uiLanguages) {
+        QString filePath = u":/i18n/gpt4all_%1.qm"_s.arg(bcp47Name);
+        QFileInfo filePathInfo(filePath);
+        if (filePathInfo.exists()) return filePath;
+    }
+    return u":/i18n/gpt4all_en_US.qm"_s;
+}
+
+void MySettings::setLanguageAndLocale(const QString &bcp47Name)
+{
+    if (!bcp47Name.isEmpty() && languageAndLocale() != bcp47Name)
+        m_settings.setValue("languageAndLocale", bcp47Name);
+
+    // When the app is started this method is called with no bcp47Name given which sets the translation
+    // to either the default which is the system locale or the one explicitly set by the user previously.
+    QLocale locale;
+    const QString l = languageAndLocale();
+    if (l == "System Locale")
+        locale = QLocale::system();
+    else
+        locale = QLocale(l);
+
+    // If we previously installed a translator, then remove it
+    if (m_translator) {
+        if (!qGuiApp->removeTranslator(m_translator.get())) {
+            qDebug() << "ERROR: Failed to remove the previous translator";
+        } else {
+            m_translator.reset();
+        }
+    }
+
+    // We expect that the translator was removed and is now a nullptr
+    Q_ASSERT(!m_translator);
+
+    const QString filePath = filePathForLocale(locale);
+    if (!m_translator) {
+        // Create a new translator object on the heap
+        m_translator = std::make_unique<QTranslator>(this);
+        bool success = m_translator->load(filePath);
+        Q_ASSERT(success);
+        if (!success) {
+            qDebug() << "ERROR: Failed to load translation file:" << filePath;
+            m_translator.reset();
+        }
+
+        // If we've successfully loaded it, then try and install it
+        if (!qGuiApp->installTranslator(m_translator.get())) {
+            qDebug() << "ERROR: Failed to install the translator:" << filePath;
+            m_translator.reset();
+        }
+    }
+
+    // Finally, set the locale whether we have a translation or not
+    QLocale::setDefault(locale);
+    emit languageAndLocaleChanged();
+}

gpt4all-chat/src/mysettings.h

@@ -0,0 +1,265 @@
+#ifndef MYSETTINGS_H
+#define MYSETTINGS_H
+
+#include "modellist.h" // IWYU pragma: keep
+
+#include <QDateTime>
+#include <QObject>
+#include <QSettings>
+#include <QString>
+#include <QStringList>
+#include <QVector>
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+namespace MySettingsEnums {
+    Q_NAMESPACE
+
+    /* NOTE: values of these enums are used as indices for the corresponding combo boxes in
+     *       ApplicationSettings.qml, as well as the corresponding name lists in mysettings.cpp */
+
+    enum class SuggestionMode {
+        LocalDocsOnly = 0,
+        On            = 1,
+        Off           = 2,
+    };
+    Q_ENUM_NS(SuggestionMode)
+
+    enum class ChatTheme {
+        Light      = 0,
+        Dark       = 1,
+        LegacyDark = 2,
+    };
+    Q_ENUM_NS(ChatTheme)
+
+    enum class FontSize {
+        Small  = 0,
+        Medium = 1,
+        Large  = 2,
+    };
+    Q_ENUM_NS(FontSize)
+}
+using namespace MySettingsEnums;
+
+class MySettings : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int threadCount READ threadCount WRITE setThreadCount NOTIFY threadCountChanged)
+    Q_PROPERTY(bool saveChatsContext READ saveChatsContext WRITE setSaveChatsContext NOTIFY saveChatsContextChanged)
+    Q_PROPERTY(bool serverChat READ serverChat WRITE setServerChat NOTIFY serverChatChanged)
+    Q_PROPERTY(QString modelPath READ modelPath WRITE setModelPath NOTIFY modelPathChanged)
+    Q_PROPERTY(QString userDefaultModel READ userDefaultModel WRITE setUserDefaultModel NOTIFY userDefaultModelChanged)
+    Q_PROPERTY(ChatTheme chatTheme READ chatTheme WRITE setChatTheme NOTIFY chatThemeChanged)
+    Q_PROPERTY(FontSize fontSize READ fontSize WRITE setFontSize NOTIFY fontSizeChanged)
+    Q_PROPERTY(QString languageAndLocale READ languageAndLocale WRITE setLanguageAndLocale NOTIFY languageAndLocaleChanged)
+    Q_PROPERTY(bool forceMetal READ forceMetal WRITE setForceMetal NOTIFY forceMetalChanged)
+    Q_PROPERTY(QString lastVersionStarted READ lastVersionStarted WRITE setLastVersionStarted NOTIFY lastVersionStartedChanged)
+    Q_PROPERTY(int localDocsChunkSize READ localDocsChunkSize WRITE setLocalDocsChunkSize NOTIFY localDocsChunkSizeChanged)
+    Q_PROPERTY(int localDocsRetrievalSize READ localDocsRetrievalSize WRITE setLocalDocsRetrievalSize NOTIFY localDocsRetrievalSizeChanged)
+    Q_PROPERTY(bool localDocsShowReferences READ localDocsShowReferences WRITE setLocalDocsShowReferences NOTIFY localDocsShowReferencesChanged)
+    Q_PROPERTY(QStringList localDocsFileExtensions READ localDocsFileExtensions WRITE setLocalDocsFileExtensions NOTIFY localDocsFileExtensionsChanged)
+    Q_PROPERTY(bool localDocsUseRemoteEmbed READ localDocsUseRemoteEmbed WRITE setLocalDocsUseRemoteEmbed NOTIFY localDocsUseRemoteEmbedChanged)
+    Q_PROPERTY(QString localDocsNomicAPIKey READ localDocsNomicAPIKey WRITE setLocalDocsNomicAPIKey NOTIFY localDocsNomicAPIKeyChanged)
+    Q_PROPERTY(QString localDocsEmbedDevice READ localDocsEmbedDevice WRITE setLocalDocsEmbedDevice NOTIFY localDocsEmbedDeviceChanged)
+    Q_PROPERTY(QString networkAttribution READ networkAttribution WRITE setNetworkAttribution NOTIFY networkAttributionChanged)
+    Q_PROPERTY(bool networkIsActive READ networkIsActive WRITE setNetworkIsActive NOTIFY networkIsActiveChanged)
+    Q_PROPERTY(bool networkUsageStatsActive READ networkUsageStatsActive WRITE setNetworkUsageStatsActive NOTIFY networkUsageStatsActiveChanged)
+    Q_PROPERTY(QString device READ device WRITE setDevice NOTIFY deviceChanged)
+    Q_PROPERTY(QStringList deviceList MEMBER m_deviceList CONSTANT)
+    Q_PROPERTY(QStringList embeddingsDeviceList MEMBER m_embeddingsDeviceList CONSTANT)
+    Q_PROPERTY(int networkPort READ networkPort WRITE setNetworkPort NOTIFY networkPortChanged)
+    Q_PROPERTY(SuggestionMode suggestionMode READ suggestionMode WRITE setSuggestionMode NOTIFY suggestionModeChanged)
+    Q_PROPERTY(QStringList uiLanguages MEMBER m_uiLanguages CONSTANT)
+
+public:
+    static MySettings *globalInstance();
+
+    // Restore methods
+    Q_INVOKABLE void restoreModelDefaults(const ModelInfo &info);
+    Q_INVOKABLE void restoreApplicationDefaults();
+    Q_INVOKABLE void restoreLocalDocsDefaults();
+
+    // Model/Character settings
+    void eraseModel(const ModelInfo &info);
+    QString modelName(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelName(const ModelInfo &info, const QString &name, bool force = false);
+    QString modelFilename(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelFilename(const ModelInfo &info, const QString &filename, bool force = false);
+
+    QString modelDescription(const ModelInfo &info) const;
+    void setModelDescription(const ModelInfo &info, const QString &value, bool force = false);
+    QString modelUrl(const ModelInfo &info) const;
+    void setModelUrl(const ModelInfo &info, const QString &value, bool force = false);
+    QString modelQuant(const ModelInfo &info) const;
+    void setModelQuant(const ModelInfo &info, const QString &value, bool force = false);
+    QString modelType(const ModelInfo &info) const;
+    void setModelType(const ModelInfo &info, const QString &value, bool force = false);
+    bool modelIsClone(const ModelInfo &info) const;
+    void setModelIsClone(const ModelInfo &info, bool value, bool force = false);
+    bool modelIsDiscovered(const ModelInfo &info) const;
+    void setModelIsDiscovered(const ModelInfo &info, bool value, bool force = false);
+    int modelLikes(const ModelInfo &info) const;
+    void setModelLikes(const ModelInfo &info, int value, bool force = false);
+    int modelDownloads(const ModelInfo &info) const;
+    void setModelDownloads(const ModelInfo &info, int value, bool force = false);
+    QDateTime modelRecency(const ModelInfo &info) const;
+    void setModelRecency(const ModelInfo &info, const QDateTime &value, bool force = false);
+
+    double modelTemperature(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelTemperature(const ModelInfo &info, double value, bool force = false);
+    double modelTopP(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelTopP(const ModelInfo &info, double value, bool force = false);
+    double modelMinP(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelMinP(const ModelInfo &info, double value, bool force = false);
+    int modelTopK(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelTopK(const ModelInfo &info, int value, bool force = false);
+    int modelMaxLength(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelMaxLength(const ModelInfo &info, int value, bool force = false);
+    int modelPromptBatchSize(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelPromptBatchSize(const ModelInfo &info, int value, bool force = false);
+    double modelRepeatPenalty(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelRepeatPenalty(const ModelInfo &info, double value, bool force = false);
+    int modelRepeatPenaltyTokens(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelRepeatPenaltyTokens(const ModelInfo &info, int value, bool force = false);
+    QString modelPromptTemplate(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelPromptTemplate(const ModelInfo &info, const QString &value, bool force = false);
+    QString modelSystemPrompt(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelSystemPrompt(const ModelInfo &info, const QString &value, bool force = false);
+    int modelContextLength(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelContextLength(const ModelInfo &info, int value, bool force = false);
+    int modelGpuLayers(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelGpuLayers(const ModelInfo &info, int value, bool force = false);
+    QString modelChatNamePrompt(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelChatNamePrompt(const ModelInfo &info, const QString &value, bool force = false);
+    QString modelSuggestedFollowUpPrompt(const ModelInfo &info) const;
+    Q_INVOKABLE void setModelSuggestedFollowUpPrompt(const ModelInfo &info, const QString &value, bool force = false);
+
+    // Application settings
+    int threadCount() const;
+    void setThreadCount(int value);
+    bool saveChatsContext() const;
+    void setSaveChatsContext(bool value);
+    bool serverChat() const;
+    void setServerChat(bool value);
+    QString modelPath();
+    void setModelPath(const QString &value);
+    QString userDefaultModel() const;
+    void setUserDefaultModel(const QString &value);
+    ChatTheme chatTheme() const;
+    void setChatTheme(ChatTheme value);
+    FontSize fontSize() const;
+    void setFontSize(FontSize value);
+    bool forceMetal() const;
+    void setForceMetal(bool value);
+    QString device();
+    void setDevice(const QString &value);
+    int32_t contextLength() const;
+    void setContextLength(int32_t value);
+    int32_t gpuLayers() const;
+    void setGpuLayers(int32_t value);
+    SuggestionMode suggestionMode() const;
+    void setSuggestionMode(SuggestionMode value);
+
+    QString languageAndLocale() const;
+    void setLanguageAndLocale(const QString &bcp47Name = QString()); // called on startup with QString()
+
+    // Release/Download settings
+    QString lastVersionStarted() const;
+    void setLastVersionStarted(const QString &value);
+
+    // Localdocs settings
+    int localDocsChunkSize() const;
+    void setLocalDocsChunkSize(int value);
+    int localDocsRetrievalSize() const;
+    void setLocalDocsRetrievalSize(int value);
+    bool localDocsShowReferences() const;
+    void setLocalDocsShowReferences(bool value);
+    QStringList localDocsFileExtensions() const;
+    void setLocalDocsFileExtensions(const QStringList &value);
+    bool localDocsUseRemoteEmbed() const;
+    void setLocalDocsUseRemoteEmbed(bool value);
+    QString localDocsNomicAPIKey() const;
+    void setLocalDocsNomicAPIKey(const QString &value);
+    QString localDocsEmbedDevice() const;
+    void setLocalDocsEmbedDevice(const QString &value);
+
+    // Network settings
+    QString networkAttribution() const;
+    void setNetworkAttribution(const QString &value);
+    bool networkIsActive() const;
+    Q_INVOKABLE bool isNetworkIsActiveSet() const;
+    void setNetworkIsActive(bool value);
+    bool networkUsageStatsActive() const;
+    Q_INVOKABLE bool isNetworkUsageStatsActiveSet() const;
+    void setNetworkUsageStatsActive(bool value);
+    int networkPort() const;
+    void setNetworkPort(int value);
+
+Q_SIGNALS:
+    void nameChanged(const ModelInfo &info);
+    void filenameChanged(const ModelInfo &info);
+    void descriptionChanged(const ModelInfo &info);
+    void temperatureChanged(const ModelInfo &info);
+    void topPChanged(const ModelInfo &info);
+    void minPChanged(const ModelInfo &info);
+    void topKChanged(const ModelInfo &info);
+    void maxLengthChanged(const ModelInfo &info);
+    void promptBatchSizeChanged(const ModelInfo &info);
+    void contextLengthChanged(const ModelInfo &info);
+    void gpuLayersChanged(const ModelInfo &info);
+    void repeatPenaltyChanged(const ModelInfo &info);
+    void repeatPenaltyTokensChanged(const ModelInfo &info);
+    void promptTemplateChanged(const ModelInfo &info);
+    void systemPromptChanged(const ModelInfo &info);
+    void chatNamePromptChanged(const ModelInfo &info);
+    void suggestedFollowUpPromptChanged(const ModelInfo &info);
+    void threadCountChanged();
+    void saveChatsContextChanged();
+    void serverChatChanged();
+    void modelPathChanged();
+    void userDefaultModelChanged();
+    void chatThemeChanged();
+    void fontSizeChanged();
+    void forceMetalChanged(bool);
+    void lastVersionStartedChanged();
+    void localDocsChunkSizeChanged();
+    void localDocsRetrievalSizeChanged();
+    void localDocsShowReferencesChanged();
+    void localDocsFileExtensionsChanged();
+    void localDocsUseRemoteEmbedChanged();
+    void localDocsNomicAPIKeyChanged();
+    void localDocsEmbedDeviceChanged();
+    void networkAttributionChanged();
+    void networkIsActiveChanged();
+    void networkPortChanged();
+    void networkUsageStatsActiveChanged();
+    void attemptModelLoadChanged();
+    void deviceChanged();
+    void suggestionModeChanged();
+    void languageAndLocaleChanged();
+
+private:
+    QSettings m_settings;
+    bool m_forceMetal;
+    const QStringList m_deviceList;
+    const QStringList m_embeddingsDeviceList;
+    const QStringList m_uiLanguages;
+    std::unique_ptr<QTranslator> m_translator;
+
+private:
+    explicit MySettings();
+    ~MySettings() {}
+    friend class MyPrivateSettings;
+
+    QVariant getBasicSetting(const QString &name) const;
+    void setBasicSetting(const QString &name, const QVariant &value, std::optional<QString> signal = std::nullopt);
+    int getEnumSetting(const QString &setting, const QStringList &valueNames) const;
+    QVariant getModelSetting(const QString &name, const ModelInfo &info) const;
+    void setModelSetting(const QString &name, const ModelInfo &info, const QVariant &value, bool force,
+                         bool signal = false);
+    QString filePathForLocale(const QLocale &locale);
+};
+
+#endif // MYSETTINGS_H

gpt4all-chat/src/network.cpp

@@ -0,0 +1,468 @@
+#include "network.h"
+
+#include "chat.h"
+#include "chatlistmodel.h"
+#include "download.h"
+#include "llm.h"
+#include "localdocs.h"
+#include "localdocsmodel.h"
+#include "modellist.h"
+#include "mysettings.h"
+
+#include <gpt4all-backend/llmodel.h>
+
+#include <QCoreApplication>
+#include <QDateTime>
+#include <QDebug>
+#include <QGlobalStatic>
+#include <QGuiApplication>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QNetworkRequest>
+#include <QScreen>
+#include <QSettings>
+#include <QSize>
+#include <QSslConfiguration>
+#include <QSslSocket>
+#include <QSysInfo>
+#include <Qt>
+#include <QtGlobal>
+#include <QtLogging>
+#include <QUrl>
+#include <QUuid>
+
+#include <cmath>
+#include <cstring>
+#include <utility>
+
+using namespace Qt::Literals::StringLiterals;
+
+//#define DEBUG
+
+static const char MIXPANEL_TOKEN[] = "ce362e568ddaee16ed243eaffb5860a2";
+
+#if defined(Q_OS_MAC)
+
+#include <sys/sysctl.h>
+static QString getCPUModel()
+{
+    char buffer[256];
+    size_t bufferlen = sizeof(buffer);
+    sysctlbyname("machdep.cpu.brand_string", &buffer, &bufferlen, NULL, 0);
+    return buffer;
+}
+
+#elif defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)
+
+#ifndef _MSC_VER
+static void get_cpuid(int level, int *regs)
+{
+    asm volatile("cpuid" : "=a" (regs[0]), "=b" (regs[1]), "=c" (regs[2]), "=d" (regs[3]) : "0" (level) : "memory");
+}
+#else
+#define get_cpuid(level, regs) __cpuid(regs, level)
+#endif
+
+static QString getCPUModel()
+{
+    int regs[12];
+
+    // EAX=800000000h: Get Highest Extended Function Implemented
+    get_cpuid(0x80000000, regs);
+    if (regs[0] < 0x80000004)
+        return "(unknown)";
+
+    // EAX=800000002h-800000004h: Processor Brand String
+    get_cpuid(0x80000002, regs);
+    get_cpuid(0x80000003, regs + 4);
+    get_cpuid(0x80000004, regs + 8);
+
+    char str[sizeof(regs) + 1];
+    memcpy(str, regs, sizeof(regs));
+    str[sizeof(regs)] = 0;
+
+    return QString(str).trimmed();
+}
+
+#else
+
+static QString getCPUModel() { return "(non-x86)"; }
+
+#endif
+
+
+class MyNetwork: public Network { };
+Q_GLOBAL_STATIC(MyNetwork, networkInstance)
+Network *Network::globalInstance()
+{
+    return networkInstance();
+}
+
+bool Network::isHttpUrlValid(QUrl url) {
+    if (!url.isValid())
+        return false;
+    QString scheme(url.scheme());
+    if (scheme != "http" && scheme != "https")
+        return false;
+    return true;
+}
+
+Network::Network()
+    : QObject{nullptr}
+{
+    QSettings settings;
+    m_uniqueId = settings.value("uniqueId", generateUniqueId()).toString();
+    settings.setValue("uniqueId", m_uniqueId);
+    m_sessionId = generateUniqueId();
+
+    // allow sendMixpanel to be called from any thread
+    connect(this, &Network::requestMixpanel, this, &Network::sendMixpanel, Qt::QueuedConnection);
+
+    const auto *mySettings = MySettings::globalInstance();
+    connect(mySettings, &MySettings::networkIsActiveChanged, this, &Network::handleIsActiveChanged);
+    connect(mySettings, &MySettings::networkUsageStatsActiveChanged, this, &Network::handleUsageStatsActiveChanged);
+
+    m_hasSentOptIn  = !Download::globalInstance()->isFirstStart() &&  mySettings->networkUsageStatsActive();
+    m_hasSentOptOut = !Download::globalInstance()->isFirstStart() && !mySettings->networkUsageStatsActive();
+
+    if (mySettings->networkIsActive())
+        sendHealth();
+    connect(&m_networkManager, &QNetworkAccessManager::sslErrors, this,
+        &Network::handleSslErrors);
+}
+
+// NOTE: this won't be useful until we make it possible to change this via the settings page
+void Network::handleUsageStatsActiveChanged()
+{
+    if (!MySettings::globalInstance()->networkUsageStatsActive())
+        m_sendUsageStats = false;
+}
+
+void Network::handleIsActiveChanged()
+{
+    if (MySettings::globalInstance()->networkUsageStatsActive())
+        sendHealth();
+}
+
+QString Network::generateUniqueId() const
+{
+    return QUuid::createUuid().toString(QUuid::WithoutBraces);
+}
+
+bool Network::packageAndSendJson(const QString &ingestId, const QString &json)
+{
+    if (!MySettings::globalInstance()->networkIsActive())
+        return false;
+
+    QJsonParseError err;
+    QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8(), &err);
+    if (err.error != QJsonParseError::NoError) {
+        qDebug() << "Couldn't parse: " << json << err.errorString();
+        return false;
+    }
+
+    Q_ASSERT(doc.isObject());
+    Q_ASSERT(ChatListModel::globalInstance()->currentChat());
+    QJsonObject object = doc.object();
+    object.insert("source", "gpt4all-chat");
+    object.insert("agent_id", ChatListModel::globalInstance()->currentChat()->modelInfo().filename());
+    object.insert("submitter_id", m_uniqueId);
+    object.insert("ingest_id", ingestId);
+
+    QString attribution = MySettings::globalInstance()->networkAttribution();
+    if (!attribution.isEmpty())
+        object.insert("network/attribution", attribution);
+
+    QString promptTemplate = ChatListModel::globalInstance()->currentChat()->modelInfo().promptTemplate();
+    object.insert("prompt_template", promptTemplate);
+
+    QJsonDocument newDoc;
+    newDoc.setObject(object);
+
+#if defined(DEBUG)
+    printf("%s\n", qPrintable(newDoc.toJson(QJsonDocument::Indented)));
+    fflush(stdout);
+#endif
+
+    QUrl jsonUrl("https://api.gpt4all.io/v1/ingest/chat");
+    QNetworkRequest request(jsonUrl);
+    QSslConfiguration conf = request.sslConfiguration();
+    conf.setPeerVerifyMode(QSslSocket::VerifyNone);
+    request.setSslConfiguration(conf);
+    QByteArray body(newDoc.toJson(QJsonDocument::Compact));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+    QNetworkReply *jsonReply = m_networkManager.post(request, body);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, jsonReply, &QNetworkReply::abort);
+    connect(jsonReply, &QNetworkReply::finished, this, &Network::handleJsonUploadFinished);
+    m_activeUploads.append(jsonReply);
+    return true;
+}
+
+void Network::handleJsonUploadFinished()
+{
+    QNetworkReply *jsonReply = qobject_cast<QNetworkReply *>(sender());
+    if (!jsonReply)
+        return;
+
+    m_activeUploads.removeAll(jsonReply);
+
+    QVariant response = jsonReply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    Q_ASSERT(response.isValid());
+    bool ok;
+    int code = response.toInt(&ok);
+    if (!ok)
+        qWarning() << "ERROR: ingest invalid response.";
+    if (code != 200) {
+        qWarning() << "ERROR: ingest response != 200 code:" << code;
+        sendHealth();
+    }
+
+#if defined(DEBUG)
+    QByteArray jsonData = jsonReply->readAll();
+    QJsonParseError err;
+
+    QJsonDocument document = QJsonDocument::fromJson(jsonData, &err);
+    if (err.error != QJsonParseError::NoError) {
+        qDebug() << "ERROR: Couldn't parse: " << jsonData << err.errorString();
+        return;
+    }
+
+    printf("%s\n", qPrintable(document.toJson(QJsonDocument::Indented)));
+    fflush(stdout);
+#endif
+
+    jsonReply->deleteLater();
+}
+
+void Network::handleSslErrors(QNetworkReply *reply, const QList<QSslError> &errors)
+{
+    QUrl url = reply->request().url();
+    for (const auto &e : errors)
+        qWarning() << "ERROR: Received ssl error:" << e.errorString() << "for" << url;
+}
+
+void Network::sendOptOut()
+{
+    QJsonObject properties;
+    properties.insert("token", MIXPANEL_TOKEN);
+    properties.insert("time", QDateTime::currentMSecsSinceEpoch());
+    properties.insert("distinct_id", m_uniqueId);
+    properties.insert("$insert_id", generateUniqueId());
+
+    QJsonObject event;
+    event.insert("event", "opt_out");
+    event.insert("properties", properties);
+
+    QJsonArray array;
+    array.append(event);
+
+    QJsonDocument doc;
+    doc.setArray(array);
+    emit requestMixpanel(doc.toJson(QJsonDocument::Compact));
+
+#if defined(DEBUG)
+    printf("%s %s\n", qPrintable("opt_out"), qPrintable(doc.toJson(QJsonDocument::Indented)));
+    fflush(stdout);
+#endif
+}
+
+void Network::sendStartup()
+{
+    const auto *mySettings = MySettings::globalInstance();
+    Q_ASSERT(mySettings->isNetworkUsageStatsActiveSet());
+    if (!mySettings->networkUsageStatsActive()) {
+        // send a single opt-out per session after the user has made their selections,
+        // unless this is a normal start (same version) and the user was already opted out
+        if (!m_hasSentOptOut) {
+            sendOptOut();
+            m_hasSentOptOut = true;
+        }
+        return;
+    }
+
+    // only chance to enable usage stats is at the start of a new session
+    m_sendUsageStats = true;
+
+    const auto *display = QGuiApplication::primaryScreen();
+    trackEvent("startup", {
+        {"$screen_dpi", std::round(display->physicalDotsPerInch())},
+        {"display", u"%1x%2"_s.arg(display->size().width()).arg(display->size().height())},
+        {"ram", LLM::globalInstance()->systemTotalRAMInGB()},
+        {"cpu", getCPUModel()},
+        {"cpu_supports_avx2", LLModel::Implementation::cpuSupportsAVX2()},
+        {"datalake_active", mySettings->networkIsActive()},
+    });
+    sendIpify();
+
+    // mirror opt-out logic so the ratio can be used to infer totals
+    if (!m_hasSentOptIn) {
+        trackEvent("opt_in");
+        m_hasSentOptIn = true;
+    }
+}
+
+void Network::trackChatEvent(const QString &ev, QVariantMap props)
+{
+    const auto &curChat = ChatListModel::globalInstance()->currentChat();
+    if (!props.contains("model"))
+        props.insert("model", curChat->modelInfo().filename());
+    props.insert("device_backend", curChat->deviceBackend());
+    props.insert("actualDevice", curChat->device());
+    props.insert("doc_collections_enabled", curChat->collectionList().count());
+    props.insert("doc_collections_total", LocalDocs::globalInstance()->localDocsModel()->rowCount());
+    props.insert("datalake_active", MySettings::globalInstance()->networkIsActive());
+    props.insert("using_server", ChatListModel::globalInstance()->currentChat()->isServer());
+    trackEvent(ev, props);
+}
+
+void Network::trackEvent(const QString &ev, const QVariantMap &props)
+{
+    if (!m_sendUsageStats)
+        return;
+
+    Q_ASSERT(ChatListModel::globalInstance()->currentChat());
+    QJsonObject properties;
+
+    properties.insert("token", MIXPANEL_TOKEN);
+    if (!props.contains("time"))
+        properties.insert("time", QDateTime::currentMSecsSinceEpoch());
+    properties.insert("distinct_id", m_uniqueId); // effectively a device ID
+    properties.insert("$insert_id", generateUniqueId());
+
+    if (!m_ipify.isEmpty())
+        properties.insert("ip", m_ipify);
+
+    properties.insert("$os", QSysInfo::prettyProductName());
+    properties.insert("session_id", m_sessionId);
+    properties.insert("name", QCoreApplication::applicationName() + " v" + QCoreApplication::applicationVersion());
+
+    for (const auto &[key, value]: props.asKeyValueRange())
+        properties.insert(key, QJsonValue::fromVariant(value));
+
+    QJsonObject event;
+    event.insert("event", ev);
+    event.insert("properties", properties);
+
+    QJsonArray array;
+    array.append(event);
+
+    QJsonDocument doc;
+    doc.setArray(array);
+    emit requestMixpanel(doc.toJson(QJsonDocument::Compact));
+
+#if defined(DEBUG)
+    printf("%s %s\n", qPrintable(ev), qPrintable(doc.toJson(QJsonDocument::Indented)));
+    fflush(stdout);
+#endif
+}
+
+void Network::sendIpify()
+{
+    if (!m_sendUsageStats || !m_ipify.isEmpty())
+        return;
+
+    QUrl ipifyUrl("https://api.ipify.org");
+    QNetworkRequest request(ipifyUrl);
+    QSslConfiguration conf = request.sslConfiguration();
+    conf.setPeerVerifyMode(QSslSocket::VerifyNone);
+    request.setSslConfiguration(conf);
+    QNetworkReply *reply = m_networkManager.get(request);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, reply, &QNetworkReply::abort);
+    connect(reply, &QNetworkReply::finished, this, &Network::handleIpifyFinished);
+}
+
+void Network::sendMixpanel(const QByteArray &json)
+{
+    QUrl trackUrl("https://api.mixpanel.com/track");
+    QNetworkRequest request(trackUrl);
+    QSslConfiguration conf = request.sslConfiguration();
+    conf.setPeerVerifyMode(QSslSocket::VerifyNone);
+    request.setSslConfiguration(conf);
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+    QNetworkReply *trackReply = m_networkManager.post(request, json);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, trackReply, &QNetworkReply::abort);
+    connect(trackReply, &QNetworkReply::finished, this, &Network::handleMixpanelFinished);
+}
+
+void Network::handleIpifyFinished()
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply)
+        return;
+
+    QVariant response = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    Q_ASSERT(response.isValid());
+    bool ok;
+    int code = response.toInt(&ok);
+    if (!ok)
+        qWarning() << "ERROR: ipify invalid response.";
+    if (code != 200)
+        qWarning() << "ERROR: ipify response != 200 code:" << code;
+    m_ipify = reply->readAll();
+#if defined(DEBUG)
+    printf("ipify finished %s\n", qPrintable(m_ipify));
+    fflush(stdout);
+#endif
+    reply->deleteLater();
+
+    trackEvent("ipify_complete");
+}
+
+void Network::handleMixpanelFinished()
+{
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    if (!reply)
+        return;
+
+    QVariant response = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    Q_ASSERT(response.isValid());
+    bool ok;
+    int code = response.toInt(&ok);
+    if (!ok)
+        qWarning() << "ERROR: track invalid response.";
+    if (code != 200)
+        qWarning() << "ERROR: track response != 200 code:" << code;
+#if defined(DEBUG)
+    printf("mixpanel finished %s\n", qPrintable(reply->readAll()));
+    fflush(stdout);
+#endif
+    reply->deleteLater();
+}
+
+bool Network::sendConversation(const QString &ingestId, const QString &conversation)
+{
+    return packageAndSendJson(ingestId, conversation);
+}
+
+void Network::sendHealth()
+{
+    QUrl healthUrl("https://api.gpt4all.io/v1/health");
+    QNetworkRequest request(healthUrl);
+    QSslConfiguration conf = request.sslConfiguration();
+    conf.setPeerVerifyMode(QSslSocket::VerifyNone);
+    request.setSslConfiguration(conf);
+    QNetworkReply *healthReply = m_networkManager.get(request);
+    connect(qGuiApp, &QCoreApplication::aboutToQuit, healthReply, &QNetworkReply::abort);
+    connect(healthReply, &QNetworkReply::finished, this, &Network::handleHealthFinished);
+}
+
+void Network::handleHealthFinished()
+{
+    QNetworkReply *healthReply = qobject_cast<QNetworkReply *>(sender());
+    if (!healthReply)
+        return;
+
+    QVariant response = healthReply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    Q_ASSERT(response.isValid());
+    bool ok;
+    int code = response.toInt(&ok);
+    if (!ok)
+        qWarning() << "ERROR: health invalid response.";
+    if (code != 200) {
+        qWarning() << "ERROR: health response != 200 code:" << code;
+        emit healthCheckFailed(code);
+        MySettings::globalInstance()->setNetworkIsActive(false);
+    }
+    healthReply->deleteLater();
+}

gpt4all-chat/src/network.h

@@ -0,0 +1,72 @@
+#ifndef NETWORK_H
+#define NETWORK_H
+
+#include <QByteArray>
+#include <QJsonValue>
+#include <QList>
+#include <QMap>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QObject>
+#include <QSslError>
+#include <QString>
+#include <QVariant>
+#include <QVector>
+
+struct KeyValue {
+    QString key;
+    QJsonValue value;
+};
+
+class Network : public QObject
+{
+    Q_OBJECT
+public:
+    static Network *globalInstance();
+    static bool isHttpUrlValid(const QUrl url);
+
+    Q_INVOKABLE QString generateUniqueId() const;
+    Q_INVOKABLE bool sendConversation(const QString &ingestId, const QString &conversation);
+    Q_INVOKABLE void trackChatEvent(const QString &event, QVariantMap props = QVariantMap());
+    Q_INVOKABLE void trackEvent(const QString &event, const QVariantMap &props = QVariantMap());
+
+Q_SIGNALS:
+    void healthCheckFailed(int code);
+    void requestMixpanel(const QByteArray &json, bool isOptOut = false);
+
+public Q_SLOTS:
+    void sendStartup();
+
+private Q_SLOTS:
+    void handleIpifyFinished();
+    void handleHealthFinished();
+    void handleJsonUploadFinished();
+    void handleSslErrors(QNetworkReply *reply, const QList<QSslError> &errors);
+    void handleMixpanelFinished();
+    void handleIsActiveChanged();
+    void handleUsageStatsActiveChanged();
+    void sendMixpanel(const QByteArray &json);
+
+private:
+    void sendOptOut();
+    void sendHealth();
+    void sendIpify();
+    bool packageAndSendJson(const QString &ingestId, const QString &json);
+
+private:
+    bool m_sendUsageStats = false;
+    bool m_hasSentOptIn;
+    bool m_hasSentOptOut;
+    QString m_ipify;
+    QString m_uniqueId;
+    QString m_sessionId;
+    QNetworkAccessManager m_networkManager;
+    QVector<QNetworkReply*> m_activeUploads;
+
+private:
+    explicit Network();
+    ~Network() {}
+    friend class MyNetwork;
+};
+
+#endif // LLM_H

gpt4all-chat/src/qml/AddCollectionView.qml

@@ -0,0 +1,206 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import QtQuick.Dialogs
+import Qt.labs.folderlistmodel
+import Qt5Compat.GraphicalEffects
+import llm
+import chatlistmodel
+import download
+import modellist
+import network
+import gpt4all
+import mysettings
+import localdocs
+
+Rectangle {
+    id: addCollectionView
+
+    Theme {
+        id: theme
+    }
+
+    color: theme.viewBackground
+    signal localDocsViewRequested()
+
+    ColumnLayout {
+        id: mainArea
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.margins: 30
+        spacing: 20
+
+        RowLayout {
+            Layout.fillWidth: true
+            Layout.alignment: Qt.AlignTop
+            spacing: 50
+
+            MyButton {
+                id: backButton
+                Layout.alignment: Qt.AlignTop | Qt.AlignLeft
+                text: qsTr("\u2190 Existing Collections")
+
+                borderWidth: 0
+                backgroundColor: theme.lighterButtonBackground
+                backgroundColorHovered: theme.lighterButtonBackgroundHovered
+                backgroundRadius: 5
+                padding: 15
+                topPadding: 8
+                bottomPadding: 8
+                textColor: theme.lighterButtonForeground
+                fontPixelSize: theme.fontSizeLarge
+                fontPixelBold: true
+
+                onClicked: {
+                    localDocsViewRequested()
+                }
+            }
+        }
+
+        Text {
+            id: addDocBanner
+            Layout.alignment: Qt.AlignBottom | Qt.AlignHCenter
+            horizontalAlignment: Qt.AlignHCenter
+            text: qsTr("Add Document Collection")
+            font.pixelSize: theme.fontSizeBanner
+            color: theme.titleTextColor
+        }
+
+        Text {
+            Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+            Layout.maximumWidth: addDocBanner.width
+            wrapMode: Text.WordWrap
+            horizontalAlignment: Text.AlignJustify
+            text: qsTr("Add a folder containing plain text files, PDFs, or Markdown. Configure additional extensions in Settings.")
+            font.pixelSize: theme.fontSizeLarger
+            color: theme.titleInfoTextColor
+        }
+
+        GridLayout {
+            id: root
+            Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+            rowSpacing: 50
+            columnSpacing: 20
+
+            property alias collection: collection.text
+            property alias folder_path: folderEdit.text
+
+            FolderDialog {
+                id: folderDialog
+                title: qsTr("Please choose a directory")
+            }
+
+            function openFolderDialog(currentFolder, onAccepted) {
+                folderDialog.currentFolder = currentFolder;
+                folderDialog.accepted.connect(function() { onAccepted(folderDialog.selectedFolder); });
+                folderDialog.open();
+            }
+
+            Label {
+                Layout.row: 2
+                Layout.column: 0
+                text: qsTr("Name")
+                font.bold: true
+                font.pixelSize: theme.fontSizeLarger
+                color: theme.settingsTitleTextColor
+            }
+
+            MyTextField {
+                id: collection
+                Layout.row: 2
+                Layout.column: 1
+                Layout.minimumWidth: 400
+                Layout.alignment: Qt.AlignRight
+                horizontalAlignment: Text.AlignJustify
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                placeholderText: qsTr("Collection name...")
+                placeholderTextColor: theme.mutedTextColor
+                ToolTip.text: qsTr("Name of the collection to add (Required)")
+                ToolTip.visible: hovered
+                Accessible.role: Accessible.EditableText
+                Accessible.name: collection.text
+                Accessible.description: ToolTip.text
+                function showError() {
+                    collection.placeholderTextColor = theme.textErrorColor
+                }
+                onTextChanged: {
+                    collection.placeholderTextColor = theme.mutedTextColor
+                }
+            }
+
+            Label {
+                Layout.row: 3
+                Layout.column: 0
+                text: qsTr("Folder")
+                font.bold: true
+                font.pixelSize: theme.fontSizeLarger
+                color: theme.settingsTitleTextColor
+            }
+
+            RowLayout {
+                Layout.row: 3
+                Layout.column: 1
+                Layout.minimumWidth: 400
+                Layout.maximumWidth: 400
+                Layout.alignment: Qt.AlignRight
+                spacing: 10
+                MyDirectoryField {
+                    id: folderEdit
+                    Layout.fillWidth: true
+                    text: root.folder_path
+                    placeholderText: qsTr("Folder path...")
+                    font.pixelSize: theme.fontSizeLarge
+                    placeholderTextColor: theme.mutedTextColor
+                    ToolTip.text: qsTr("Folder path to documents (Required)")
+                    ToolTip.visible: hovered
+                    function showError() {
+                        folderEdit.placeholderTextColor = theme.textErrorColor
+                    }
+                    onTextChanged: {
+                        folderEdit.placeholderTextColor = theme.mutedTextColor
+                    }
+                }
+
+                MySettingsButton {
+                    id: browseButton
+                    text: qsTr("Browse")
+                    onClicked: {
+                        root.openFolderDialog(StandardPaths.writableLocation(StandardPaths.HomeLocation), function(selectedFolder) {
+                            root.folder_path = selectedFolder
+                        })
+                    }
+                }
+            }
+
+            MyButton {
+                Layout.row: 4
+                Layout.column: 1
+                Layout.alignment: Qt.AlignRight
+                text: qsTr("Create Collection")
+                onClicked: {
+                    var isError = false;
+                    if (root.collection === "") {
+                        isError = true;
+                        collection.showError();
+                    }
+                    if (root.folder_path === "" || !folderEdit.isValid) {
+                        isError = true;
+                        folderEdit.showError();
+                    }
+                    if (isError)
+                        return;
+                    LocalDocs.addFolder(root.collection, root.folder_path)
+                    root.collection = ""
+                    root.folder_path = ""
+                    collection.clear()
+                    localDocsViewRequested()
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/AddModelView.qml

@@ -0,0 +1,816 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import QtQuick.Dialogs
+import Qt.labs.folderlistmodel
+import Qt5Compat.GraphicalEffects
+import llm
+import chatlistmodel
+import download
+import modellist
+import network
+import gpt4all
+import mysettings
+import localdocs
+
+Rectangle {
+    id: addModelView
+
+    Theme {
+        id: theme
+    }
+
+    color: theme.viewBackground
+    signal modelsViewRequested()
+
+    ToastManager {
+        id: messageToast
+    }
+
+    PopupDialog {
+        id: downloadingErrorPopup
+        anchors.centerIn: parent
+        shouldTimeOut: false
+    }
+
+    ColumnLayout {
+        id: mainArea
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.margins: 30
+        spacing: 30
+
+        ColumnLayout {
+            Layout.fillWidth: true
+            Layout.alignment: Qt.AlignTop
+            spacing: 30
+
+            MyButton {
+                id: backButton
+                Layout.alignment: Qt.AlignTop | Qt.AlignLeft
+                text: qsTr("\u2190 Existing Models")
+
+                borderWidth: 0
+                backgroundColor: theme.lighterButtonBackground
+                backgroundColorHovered: theme.lighterButtonBackgroundHovered
+                backgroundRadius: 5
+                padding: 15
+                topPadding: 8
+                bottomPadding: 8
+                textColor: theme.lighterButtonForeground
+                fontPixelSize: theme.fontSizeLarge
+                fontPixelBold: true
+
+                onClicked: {
+                    modelsViewRequested()
+                }
+            }
+
+            Text {
+                id: welcome
+                text: qsTr("Explore Models")
+                font.pixelSize: theme.fontSizeBanner
+                color: theme.titleTextColor
+            }
+
+            RowLayout {
+                Layout.fillWidth: true
+                Layout.alignment: Qt.AlignCenter
+                Layout.margins: 0
+                spacing: 10
+                MyTextField {
+                    id: discoverField
+                    property string textBeingSearched: ""
+                    readOnly: ModelList.discoverInProgress
+                    Layout.alignment: Qt.AlignCenter
+                    Layout.fillWidth: true
+                    font.pixelSize: theme.fontSizeLarger
+                    placeholderText: qsTr("Discover and download models by keyword search...")
+                    Accessible.role: Accessible.EditableText
+                    Accessible.name: placeholderText
+                    Accessible.description: qsTr("Text field for discovering and filtering downloadable models")
+                    Connections {
+                        target: ModelList
+                        function onDiscoverInProgressChanged() {
+                            if (ModelList.discoverInProgress) {
+                                discoverField.textBeingSearched = discoverField.text;
+                                discoverField.text = qsTr("Searching \u00B7 %1").arg(discoverField.textBeingSearched);
+                            } else {
+                                discoverField.text = discoverField.textBeingSearched;
+                                discoverField.textBeingSearched = "";
+                            }
+                        }
+                    }
+                    background: ProgressBar {
+                        id: discoverProgressBar
+                        indeterminate: ModelList.discoverInProgress && ModelList.discoverProgress === 0.0
+                        value: ModelList.discoverProgress
+                        background: Rectangle {
+                            color: theme.controlBackground
+                            border.color: theme.controlBorder
+                            radius: 10
+                        }
+                        contentItem: Item {
+                            Rectangle {
+                                visible: ModelList.discoverInProgress
+                                anchors.bottom: parent.bottom
+                                width: discoverProgressBar.visualPosition * parent.width
+                                height: 10
+                                radius: 2
+                                color: theme.progressForeground
+                            }
+                        }
+                    }
+
+                    Keys.onReturnPressed: (event)=> {
+                                              if (event.modifiers & Qt.ControlModifier || event.modifiers & Qt.ShiftModifier)
+                                              event.accepted = false;
+                                              else {
+                                                  editingFinished();
+                                                  sendDiscovery()
+                                              }
+                                          }
+                    function sendDiscovery() {
+                        ModelList.downloadableModels.discoverAndFilter(discoverField.text);
+                    }
+                    RowLayout {
+                        spacing: 0
+                        anchors.right: discoverField.right
+                        anchors.verticalCenter: discoverField.verticalCenter
+                        anchors.rightMargin: 15
+                        visible: !ModelList.discoverInProgress
+                        MyMiniButton {
+                            id: clearDiscoverButton
+                            backgroundColor: theme.textColor
+                            backgroundColorHovered: theme.iconBackgroundDark
+                            visible: discoverField.text !== ""
+                            source: "qrc:/gpt4all/icons/close.svg"
+                            onClicked: {
+                                discoverField.text = ""
+                                discoverField.sendDiscovery() // should clear results
+                            }
+                        }
+                        MyMiniButton {
+                            backgroundColor: theme.textColor
+                            backgroundColorHovered: theme.iconBackgroundDark
+                            source: "qrc:/gpt4all/icons/settings.svg"
+                            onClicked: {
+                                discoveryTools.visible = !discoveryTools.visible
+                            }
+                        }
+                        MyMiniButton {
+                            id: sendButton
+                            enabled: !ModelList.discoverInProgress
+                            backgroundColor: theme.textColor
+                            backgroundColorHovered: theme.iconBackgroundDark
+                            source: "qrc:/gpt4all/icons/send_message.svg"
+                            Accessible.name: qsTr("Initiate model discovery and filtering")
+                            Accessible.description: qsTr("Triggers discovery and filtering of models")
+                            onClicked: {
+                                discoverField.sendDiscovery()
+                            }
+                        }
+                    }
+                }
+            }
+
+            RowLayout {
+                id: discoveryTools
+                Layout.fillWidth: true
+                Layout.alignment: Qt.AlignCenter
+                Layout.margins: 0
+                spacing: 20
+                visible: false
+                MyComboBox {
+                    id: comboSort
+                    model: ListModel {
+                        ListElement { name: qsTr("Default") }
+                        ListElement { name: qsTr("Likes") }
+                        ListElement { name: qsTr("Downloads") }
+                        ListElement { name: qsTr("Recent") }
+                    }
+                    currentIndex: ModelList.discoverSort
+                    contentItem: Text {
+                        anchors.horizontalCenter: parent.horizontalCenter
+                        rightPadding: 30
+                        color: theme.textColor
+                        text: {
+                            return qsTr("Sort by: %1").arg(comboSort.displayText)
+                        }
+                        font.pixelSize: theme.fontSizeLarger
+                        verticalAlignment: Text.AlignVCenter
+                        horizontalAlignment: Text.AlignHCenter
+                        elide: Text.ElideRight
+                    }
+                    onActivated: function (index) {
+                        ModelList.discoverSort = index;
+                    }
+                }
+                MyComboBox {
+                    id: comboSortDirection
+                    model: ListModel {
+                        ListElement { name: qsTr("Asc") }
+                        ListElement { name: qsTr("Desc") }
+                    }
+                    currentIndex: {
+                        if (ModelList.discoverSortDirection === 1)
+                            return 0
+                        else
+                            return 1;
+                    }
+                    contentItem: Text {
+                        anchors.horizontalCenter: parent.horizontalCenter
+                        rightPadding: 30
+                        color: theme.textColor
+                        text: {
+                            return qsTr("Sort dir: %1").arg(comboSortDirection.displayText)
+                        }
+                        font.pixelSize: theme.fontSizeLarger
+                        verticalAlignment: Text.AlignVCenter
+                        horizontalAlignment: Text.AlignHCenter
+                        elide: Text.ElideRight
+                    }
+                    onActivated: function (index) {
+                        if (index === 0)
+                            ModelList.discoverSortDirection = 1;
+                        else
+                            ModelList.discoverSortDirection = -1;
+                    }
+                }
+                MyComboBox {
+                    id: comboLimit
+                    model: ListModel {
+                        ListElement { name: "5" }
+                        ListElement { name: "10" }
+                        ListElement { name: "20" }
+                        ListElement { name: "50" }
+                        ListElement { name: "100" }
+                        ListElement { name: qsTr("None") }
+                    }
+
+                    currentIndex: {
+                        if (ModelList.discoverLimit === 5)
+                            return 0;
+                        else if (ModelList.discoverLimit === 10)
+                            return 1;
+                        else if (ModelList.discoverLimit === 20)
+                            return 2;
+                        else if (ModelList.discoverLimit === 50)
+                            return 3;
+                        else if (ModelList.discoverLimit === 100)
+                            return 4;
+                        else if (ModelList.discoverLimit === -1)
+                            return 5;
+                    }
+                    contentItem: Text {
+                        anchors.horizontalCenter: parent.horizontalCenter
+                        rightPadding: 30
+                        color: theme.textColor
+                        text: {
+                            return qsTr("Limit: %1").arg(comboLimit.displayText)
+                        }
+                        font.pixelSize: theme.fontSizeLarger
+                        verticalAlignment: Text.AlignVCenter
+                        horizontalAlignment: Text.AlignHCenter
+                        elide: Text.ElideRight
+                    }
+                    onActivated: function (index) {
+                        switch (index) {
+                        case 0:
+                            ModelList.discoverLimit = 5; break;
+                        case 1:
+                            ModelList.discoverLimit = 10; break;
+                        case 2:
+                            ModelList.discoverLimit = 20; break;
+                        case 3:
+                            ModelList.discoverLimit = 50; break;
+                        case 4:
+                            ModelList.discoverLimit = 100; break;
+                        case 5:
+                            ModelList.discoverLimit = -1; break;
+                        }
+                    }
+                }
+            }
+        }
+
+        Label {
+            visible: !ModelList.downloadableModels.count && !ModelList.asyncModelRequestOngoing
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            horizontalAlignment: Qt.AlignHCenter
+            verticalAlignment: Qt.AlignVCenter
+            text: qsTr("Network error: could not retrieve %1").arg("http://gpt4all.io/models/models3.json")
+            font.pixelSize: theme.fontSizeLarge
+            color: theme.mutedTextColor
+        }
+
+        MyBusyIndicator {
+            visible: !ModelList.downloadableModels.count && ModelList.asyncModelRequestOngoing
+            running: ModelList.asyncModelRequestOngoing
+            Accessible.role: Accessible.Animation
+            Layout.alignment: Qt.AlignCenter
+            Accessible.name: qsTr("Busy indicator")
+            Accessible.description: qsTr("Displayed when the models request is ongoing")
+        }
+
+        ScrollView {
+            id: scrollView
+            ScrollBar.vertical.policy: ScrollBar.AsNeeded
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            clip: true
+
+            ListView {
+                id: modelListView
+                model: ModelList.downloadableModels
+                boundsBehavior: Flickable.StopAtBounds
+                spacing: 30
+
+                delegate: Rectangle {
+                    id: delegateItem
+                    width: modelListView.width
+                    height: childrenRect.height + 60
+                    color: theme.conversationBackground
+                    radius: 10
+                    border.width: 1
+                    border.color: theme.controlBorder
+
+                    ColumnLayout {
+                        anchors.top: parent.top
+                        anchors.left: parent.left
+                        anchors.right: parent.right
+                        anchors.margins: 30
+
+                        Text {
+                            Layout.fillWidth: true
+                            Layout.alignment: Qt.AlignLeft
+                            text: name
+                            elide: Text.ElideRight
+                            color: theme.titleTextColor
+                            font.pixelSize: theme.fontSizeLargest
+                            font.bold: true
+                            Accessible.role: Accessible.Paragraph
+                            Accessible.name: qsTr("Model file")
+                            Accessible.description: qsTr("Model file to be downloaded")
+                        }
+
+
+                        Rectangle {
+                            Layout.fillWidth: true
+                            height: 1
+                            color: theme.dividerColor
+                        }
+
+                        RowLayout {
+                            Layout.topMargin: 10
+                            Layout.fillWidth: true
+                            Text {
+                                id: descriptionText
+                                text: description
+                                font.pixelSize: theme.fontSizeLarge
+                                Layout.fillWidth: true
+                                wrapMode: Text.WordWrap
+                                textFormat: Text.StyledText
+                                color: theme.textColor
+                                linkColor: theme.textColor
+                                Accessible.role: Accessible.Paragraph
+                                Accessible.name: qsTr("Description")
+                                Accessible.description: qsTr("File description")
+                                onLinkActivated: function(link) { Qt.openUrlExternally(link); }
+                                MouseArea {
+                                    anchors.fill: parent
+                                    acceptedButtons: Qt.NoButton // pass clicks to parent
+                                    cursorShape: parent.hoveredLink ? Qt.PointingHandCursor : Qt.ArrowCursor
+                                }
+                            }
+
+                            // FIXME Need to overhaul design here which must take into account
+                            // features not present in current figma including:
+                            // * Ability to cancel a current download
+                            // * Ability to resume a download
+                            // * The presentation of an error if encountered
+                            // * Whether to show already installed models
+                            // * Install of remote models with API keys
+                            // * The presentation of the progress bar
+                            Rectangle {
+                                id: actionBox
+                                width: childrenRect.width + 20
+                                color: "transparent"
+                                border.width: 1
+                                border.color: theme.dividerColor
+                                radius: 10
+                                Layout.rightMargin: 20
+                                Layout.bottomMargin: 20
+                                Layout.minimumHeight: childrenRect.height + 20
+                                Layout.alignment: Qt.AlignRight | Qt.AlignTop
+
+                                ColumnLayout {
+                                    spacing: 0
+                                    MySettingsButton {
+                                        id: downloadButton
+                                        text: isDownloading ? qsTr("Cancel") : isIncomplete ? qsTr("Resume") : qsTr("Download")
+                                        font.pixelSize: theme.fontSizeLarge
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        visible: !isOnline && !installed && !calcHash && downloadError === ""
+                                        Accessible.description: qsTr("Stop/restart/start the download")
+                                        onClicked: {
+                                            if (!isDownloading) {
+                                                Download.downloadModel(filename);
+                                            } else {
+                                                Download.cancelDownload(filename);
+                                            }
+                                        }
+                                    }
+
+                                    MySettingsDestructiveButton {
+                                        id: removeButton
+                                        text: qsTr("Remove")
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        visible: !isDownloading && (installed || isIncomplete)
+                                        Accessible.description: qsTr("Remove model from filesystem")
+                                        onClicked: {
+                                            Download.removeModel(filename);
+                                        }
+                                    }
+
+                                    MySettingsButton {
+                                        id: installButton
+                                        visible: !installed && isOnline
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        text: qsTr("Install")
+                                        font.pixelSize: theme.fontSizeLarge
+                                        onClicked: {
+                                            var apiKeyText = apiKey.text.trim(),
+                                                baseUrlText = baseUrl.text.trim(),
+                                                modelNameText = modelName.text.trim();
+
+                                            var apiKeyOk = apiKeyText !== "",
+                                                baseUrlOk = !isCompatibleApi || baseUrlText !== "",
+                                                modelNameOk = !isCompatibleApi || modelNameText !== "";
+
+                                            if (!apiKeyOk)
+                                                apiKey.showError();
+                                            if (!baseUrlOk)
+                                                baseUrl.showError();
+                                            if (!modelNameOk)
+                                                modelName.showError();
+
+                                            if (!apiKeyOk || !baseUrlOk || !modelNameOk)
+                                                return;
+
+                                            if (!isCompatibleApi)
+                                                Download.installModel(
+                                                    filename,
+                                                    apiKeyText,
+                                                );
+                                            else
+                                                Download.installCompatibleModel(
+                                                    modelNameText,
+                                                    apiKeyText,
+                                                    baseUrlText,
+                                                );
+                                        }
+                                        Accessible.role: Accessible.Button
+                                        Accessible.name: qsTr("Install")
+                                        Accessible.description: qsTr("Install online model")
+                                    }
+
+                                    ColumnLayout {
+                                        spacing: 0
+                                        Label {
+                                            Layout.topMargin: 20
+                                            Layout.leftMargin: 20
+                                            visible: downloadError !== ""
+                                            textFormat: Text.StyledText
+                                            text: qsTr("<strong><font size=\"1\"><a href=\"#error\">Error</a></strong></font>")
+                                            color: theme.textColor
+                                            font.pixelSize: theme.fontSizeLarge
+                                            linkColor: theme.textErrorColor
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: text
+                                            Accessible.description: qsTr("Describes an error that occurred when downloading")
+                                            onLinkActivated: {
+                                                downloadingErrorPopup.text = downloadError;
+                                                downloadingErrorPopup.open();
+                                            }
+                                        }
+
+                                        Label {
+                                            visible: LLM.systemTotalRAMInGB() < ramrequired
+                                            Layout.topMargin: 20
+                                            Layout.leftMargin: 20
+                                            Layout.maximumWidth: 300
+                                            textFormat: Text.StyledText
+                                            text: qsTr("<strong><font size=\"2\">WARNING: Not recommended for your hardware. Model requires more memory (%1 GB) than your system has available (%2).</strong></font>").arg(ramrequired).arg(LLM.systemTotalRAMInGBString())
+                                            color: theme.textErrorColor
+                                            font.pixelSize: theme.fontSizeLarge
+                                            wrapMode: Text.WordWrap
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: text
+                                            Accessible.description: qsTr("Error for incompatible hardware")
+                                            onLinkActivated: {
+                                                downloadingErrorPopup.text = downloadError;
+                                                downloadingErrorPopup.open();
+                                            }
+                                        }
+                                    }
+
+                                    ColumnLayout {
+                                        visible: isDownloading && !calcHash
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        spacing: 20
+
+                                        ProgressBar {
+                                            id: itemProgressBar
+                                            Layout.fillWidth: true
+                                            width: 200
+                                            value: bytesReceived / bytesTotal
+                                            background: Rectangle {
+                                                implicitHeight: 45
+                                                color: theme.progressBackground
+                                                radius: 3
+                                            }
+                                            contentItem: Item {
+                                                implicitHeight: 40
+
+                                                Rectangle {
+                                                    width: itemProgressBar.visualPosition * parent.width
+                                                    height: parent.height
+                                                    radius: 2
+                                                    color: theme.progressForeground
+                                                }
+                                            }
+                                            Accessible.role: Accessible.ProgressBar
+                                            Accessible.name: qsTr("Download progressBar")
+                                            Accessible.description: qsTr("Shows the progress made in the download")
+                                        }
+
+                                        Label {
+                                            id: speedLabel
+                                            color: theme.textColor
+                                            Layout.alignment: Qt.AlignRight
+                                            text: speed
+                                            font.pixelSize: theme.fontSizeLarge
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: qsTr("Download speed")
+                                            Accessible.description: qsTr("Download speed in bytes/kilobytes/megabytes per second")
+                                        }
+                                    }
+
+                                    RowLayout {
+                                        visible: calcHash
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.maximumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        clip: true
+
+                                        Label {
+                                            id: calcHashLabel
+                                            color: theme.textColor
+                                            text: qsTr("Calculating...")
+                                            font.pixelSize: theme.fontSizeLarge
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: text
+                                            Accessible.description: qsTr("Whether the file hash is being calculated")
+                                        }
+
+                                        MyBusyIndicator {
+                                            id: busyCalcHash
+                                            running: calcHash
+                                            Accessible.role: Accessible.Animation
+                                            Accessible.name: qsTr("Busy indicator")
+                                            Accessible.description: qsTr("Displayed when the file hash is being calculated")
+                                        }
+                                    }
+
+                                    MyTextField {
+                                        id: apiKey
+                                        visible: !installed && isOnline
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        wrapMode: Text.WrapAnywhere
+                                        function showError() {
+                                            messageToast.show(qsTr("ERROR: $API_KEY is empty."));
+                                            apiKey.placeholderTextColor = theme.textErrorColor;
+                                        }
+                                        onTextChanged: {
+                                            apiKey.placeholderTextColor = theme.mutedTextColor;
+                                        }
+                                        placeholderText: qsTr("enter $API_KEY")
+                                        Accessible.role: Accessible.EditableText
+                                        Accessible.name: placeholderText
+                                        Accessible.description: qsTr("Whether the file hash is being calculated")
+                                    }
+
+                                    MyTextField {
+                                        id: baseUrl
+                                        visible: !installed && isOnline && isCompatibleApi
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        wrapMode: Text.WrapAnywhere
+                                        function showError() {
+                                            messageToast.show(qsTr("ERROR: $BASE_URL is empty."));
+                                            baseUrl.placeholderTextColor = theme.textErrorColor;
+                                        }
+                                        onTextChanged: {
+                                            baseUrl.placeholderTextColor = theme.mutedTextColor;
+                                        }
+                                        placeholderText: qsTr("enter $BASE_URL")
+                                        Accessible.role: Accessible.EditableText
+                                        Accessible.name: placeholderText
+                                        Accessible.description: qsTr("Whether the file hash is being calculated")
+                                    }
+
+                                    MyTextField {
+                                        id: modelName
+                                        visible: !installed && isOnline && isCompatibleApi
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        wrapMode: Text.WrapAnywhere
+                                        function showError() {
+                                            messageToast.show(qsTr("ERROR: $MODEL_NAME is empty."))
+                                            modelName.placeholderTextColor = theme.textErrorColor;
+                                        }
+                                        onTextChanged: {
+                                            modelName.placeholderTextColor = theme.mutedTextColor;
+                                        }
+                                        placeholderText: qsTr("enter $MODEL_NAME")
+                                        Accessible.role: Accessible.EditableText
+                                        Accessible.name: placeholderText
+                                        Accessible.description: qsTr("Whether the file hash is being calculated")
+                                    }
+                                }
+                            }
+                        }
+
+                        Item  {
+                            Layout.minimumWidth: childrenRect.width
+                            Layout.minimumHeight: childrenRect.height
+                            Layout.bottomMargin: 10
+                            RowLayout {
+                                id: paramRow
+                                anchors.centerIn: parent
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("File size")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: filesize
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("RAM required")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: ramrequired >= 0 ? qsTr("%1 GB").arg(ramrequired) : qsTr("?")
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("Parameters")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: parameters !== "" ? parameters : qsTr("?")
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("Quant")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: quant
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("Type")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: type
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                            }
+
+                            Rectangle {
+                                color: "transparent"
+                                anchors.fill: paramRow
+                                border.color: theme.dividerColor
+                                border.width: 1
+                                radius: 10
+                            }
+                        }
+
+                        Rectangle {
+                            Layout.fillWidth: true
+                            height: 1
+                            color: theme.dividerColor
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Connections {
+        target: Download
+        function onToastMessage(message) {
+            messageToast.show(message);
+        }
+    }
+}

gpt4all-chat/src/qml/ApplicationSettings.qml

@@ -0,0 +1,602 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import QtQuick.Dialogs
+import modellist
+import mysettings
+import network
+import llm
+
+MySettingsTab {
+    onRestoreDefaultsClicked: {
+        MySettings.restoreApplicationDefaults();
+    }
+    title: qsTr("Application")
+
+    NetworkDialog {
+        id: networkDialog
+        anchors.centerIn: parent
+        width: Math.min(1024, window.width - (window.width * .2))
+        height: Math.min(600, window.height - (window.height * .2))
+        Item {
+            Accessible.role: Accessible.Dialog
+            Accessible.name: qsTr("Network dialog")
+            Accessible.description: qsTr("opt-in to share feedback/conversations")
+        }
+    }
+
+    Dialog {
+        id: checkForUpdatesError
+        anchors.centerIn: parent
+        modal: false
+        padding: 20
+        Text {
+            horizontalAlignment: Text.AlignJustify
+            text: qsTr("ERROR: Update system could not find the MaintenanceTool used<br>
+                   to check for updates!<br><br>
+                   Did you install this application using the online installer? If so,<br>
+                   the MaintenanceTool executable should be located one directory<br>
+                   above where this application resides on your filesystem.<br><br>
+                   If you can't start it manually, then I'm afraid you'll have to<br>
+                   reinstall.")
+            color: theme.textErrorColor
+            font.pixelSize: theme.fontSizeLarge
+            Accessible.role: Accessible.Dialog
+            Accessible.name: text
+            Accessible.description: qsTr("Error dialog")
+        }
+        background: Rectangle {
+            anchors.fill: parent
+            color: theme.containerBackground
+            border.width: 1
+            border.color: theme.dialogBorder
+            radius: 10
+        }
+    }
+
+    contentItem: GridLayout {
+        id: applicationSettingsTabInner
+        columns: 3
+        rowSpacing: 30
+        columnSpacing: 10
+
+        Label {
+            Layout.row: 0
+            Layout.column: 0
+            Layout.bottomMargin: 10
+            color: theme.settingsTitleTextColor
+            font.pixelSize: theme.fontSizeBannerSmall
+            font.bold: true
+            text: qsTr("Application Settings")
+        }
+
+        ColumnLayout {
+            Layout.row: 1
+            Layout.column: 0
+            Layout.columnSpan: 3
+            Layout.fillWidth: true
+            spacing: 10
+            Label {
+                color: theme.styledTextColor
+                font.pixelSize: theme.fontSizeLarge
+                font.bold: true
+                text: qsTr("General")
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 1
+                color: theme.settingsDivider
+            }
+        }
+
+        MySettingsLabel {
+            id: themeLabel
+            text: qsTr("Theme")
+            helpText: qsTr("The application color scheme.")
+            Layout.row: 2
+            Layout.column: 0
+        }
+        MyComboBox {
+            id: themeBox
+            Layout.row: 2
+            Layout.column: 2
+            Layout.minimumWidth: 200
+            Layout.maximumWidth: 200
+            Layout.fillWidth: false
+            Layout.alignment: Qt.AlignRight
+            // NOTE: indices match values of ChatTheme enum, keep them in sync
+            model: ListModel {
+                ListElement { name: qsTr("Light") }
+                ListElement { name: qsTr("Dark") }
+                ListElement { name: qsTr("LegacyDark") }
+            }
+            Accessible.name: themeLabel.text
+            Accessible.description: themeLabel.helpText
+            function updateModel() {
+                themeBox.currentIndex = MySettings.chatTheme;
+            }
+            Component.onCompleted: {
+                themeBox.updateModel()
+            }
+            Connections {
+                target: MySettings
+                function onChatThemeChanged() {
+                    themeBox.updateModel()
+                }
+            }
+            onActivated: {
+                MySettings.chatTheme = themeBox.currentIndex
+            }
+        }
+        MySettingsLabel {
+            id: fontLabel
+            text: qsTr("Font Size")
+            helpText: qsTr("The size of text in the application.")
+            Layout.row: 3
+            Layout.column: 0
+        }
+        MyComboBox {
+            id: fontBox
+            Layout.row: 3
+            Layout.column: 2
+            Layout.minimumWidth: 200
+            Layout.maximumWidth: 200
+            Layout.fillWidth: false
+            Layout.alignment: Qt.AlignRight
+            // NOTE: indices match values of FontSize enum, keep them in sync
+            model: ListModel {
+                ListElement { name: qsTr("Small") }
+                ListElement { name: qsTr("Medium") }
+                ListElement { name: qsTr("Large") }
+            }
+            Accessible.name: fontLabel.text
+            Accessible.description: fontLabel.helpText
+            function updateModel() {
+                fontBox.currentIndex = MySettings.fontSize;
+            }
+            Component.onCompleted: {
+                fontBox.updateModel()
+            }
+            Connections {
+                target: MySettings
+                function onFontSizeChanged() {
+                    fontBox.updateModel()
+                }
+            }
+            onActivated: {
+                MySettings.fontSize = fontBox.currentIndex
+            }
+        }
+        MySettingsLabel {
+            id: languageLabel
+            visible: MySettings.uiLanguages.length > 1
+            text: qsTr("Language and Locale")
+            helpText: qsTr("The language and locale you wish to use.")
+            Layout.row: 4
+            Layout.column: 0
+        }
+        MyComboBox {
+            id: languageBox
+            visible: MySettings.uiLanguages.length > 1
+            Layout.row: 4
+            Layout.column: 2
+            Layout.minimumWidth: 200
+            Layout.maximumWidth: 200
+            Layout.fillWidth: false
+            Layout.alignment: Qt.AlignRight
+            model: ListModel {
+                Component.onCompleted: {
+                    for (var i = 0; i < MySettings.uiLanguages.length; ++i)
+                        append({"text": MySettings.uiLanguages[i]});
+                    languageBox.updateModel();
+                }
+                ListElement { text: qsTr("System Locale") }
+            }
+
+            Accessible.name: languageLabel.text
+            Accessible.description: languageLabel.helpText
+            function updateModel() {
+                // This usage of 'System Locale' should not be translated
+                // FIXME: Make this refer to a string literal variable accessed by both QML and C++
+                if (MySettings.languageAndLocale === "System Locale")
+                    languageBox.currentIndex = 0
+                else
+                    languageBox.currentIndex = languageBox.indexOfValue(MySettings.languageAndLocale);
+            }
+            Component.onCompleted: {
+                languageBox.updateModel()
+            }
+            onActivated: {
+                // This usage of 'System Locale' should not be translated
+                // FIXME: Make this refer to a string literal variable accessed by both QML and C++
+                if (languageBox.currentIndex === 0)
+                    MySettings.languageAndLocale = "System Locale";
+                else
+                    MySettings.languageAndLocale = languageBox.currentText;
+            }
+        }
+        MySettingsLabel {
+            id: deviceLabel
+            text: qsTr("Device")
+            helpText: qsTr('The compute device used for text generation.')
+            Layout.row: 5
+            Layout.column: 0
+        }
+        MyComboBox {
+            id: deviceBox
+            Layout.row: 5
+            Layout.column: 2
+            Layout.minimumWidth: 400
+            Layout.maximumWidth: 400
+            Layout.fillWidth: false
+            Layout.alignment: Qt.AlignRight
+            model: ListModel {
+                Component.onCompleted: {
+                    for (var i = 0; i < MySettings.deviceList.length; ++i)
+                        append({"text": MySettings.deviceList[i]});
+                    deviceBox.updateModel();
+                }
+                ListElement { text: qsTr("Application default") }
+            }
+
+            Accessible.name: deviceLabel.text
+            Accessible.description: deviceLabel.helpText
+            function updateModel() {
+                // This usage of 'Auto' should not be translated
+                // FIXME: Make this refer to a string literal variable accessed by both QML and C++
+                if (MySettings.device === "Auto")
+                    deviceBox.currentIndex = 0
+                else
+                    deviceBox.currentIndex = deviceBox.indexOfValue(MySettings.device);
+            }
+            Component.onCompleted: {
+                deviceBox.updateModel();
+            }
+            Connections {
+                target: MySettings
+                function onDeviceChanged() {
+                    deviceBox.updateModel();
+                }
+            }
+            onActivated: {
+                // This usage of 'Auto' should not be translated
+                // FIXME: Make this refer to a string literal variable accessed by both QML and C++
+                if (deviceBox.currentIndex === 0)
+                    MySettings.device = "Auto";
+                else
+                    MySettings.device = deviceBox.currentText;
+            }
+        }
+        MySettingsLabel {
+            id: defaultModelLabel
+            text: qsTr("Default Model")
+            helpText: qsTr("The preferred model for new chats. Also used as the local server fallback.")
+            Layout.row: 6
+            Layout.column: 0
+        }
+        MyComboBox {
+            id: defaultModelBox
+            Layout.row: 6
+            Layout.column: 2
+            Layout.minimumWidth: 400
+            Layout.maximumWidth: 400
+            Layout.alignment: Qt.AlignRight
+            model: ListModel {
+                id: defaultModelBoxModel
+                Component.onCompleted: {
+                    defaultModelBox.rebuildModel()
+                }
+            }
+            Accessible.name: defaultModelLabel.text
+            Accessible.description: defaultModelLabel.helpText
+            function rebuildModel() {
+                defaultModelBoxModel.clear();
+                defaultModelBoxModel.append({"text": qsTr("Application default")});
+                for (var i = 0; i < ModelList.selectableModelList.length; ++i)
+                    defaultModelBoxModel.append({"text": ModelList.selectableModelList[i].name});
+                defaultModelBox.updateModel();
+            }
+            function updateModel() {
+                // This usage of 'Application default' should not be translated
+                // FIXME: Make this refer to a string literal variable accessed by both QML and C++
+                if (MySettings.userDefaultModel === "Application default")
+                    defaultModelBox.currentIndex = 0
+                else
+                    defaultModelBox.currentIndex = defaultModelBox.indexOfValue(MySettings.userDefaultModel);
+            }
+            onActivated: {
+                // This usage of 'Application default' should not be translated
+                // FIXME: Make this refer to a string literal variable accessed by both QML and C++
+                if (defaultModelBox.currentIndex === 0)
+                    MySettings.userDefaultModel = "Application default";
+                else
+                    MySettings.userDefaultModel = defaultModelBox.currentText;
+            }
+            Connections {
+                target: MySettings
+                function onUserDefaultModelChanged() {
+                    defaultModelBox.updateModel()
+                }
+            }
+            Connections {
+                target: MySettings
+                function onLanguageAndLocaleChanged() {
+                    defaultModelBox.rebuildModel()
+                }
+            }
+            Connections {
+                target: ModelList
+                function onSelectableModelListChanged() {
+                    defaultModelBox.rebuildModel()
+                }
+            }
+        }
+        MySettingsLabel {
+            id: suggestionModeLabel
+            text: qsTr("Suggestion Mode")
+            helpText: qsTr("Generate suggested follow-up questions at the end of responses.")
+            Layout.row: 7
+            Layout.column: 0
+        }
+        MyComboBox {
+            id: suggestionModeBox
+            Layout.row: 7
+            Layout.column: 2
+            Layout.minimumWidth: 400
+            Layout.maximumWidth: 400
+            Layout.alignment: Qt.AlignRight
+            // NOTE: indices match values of SuggestionMode enum, keep them in sync
+            model: ListModel {
+                ListElement { name: qsTr("When chatting with LocalDocs") }
+                ListElement { name: qsTr("Whenever possible") }
+                ListElement { name: qsTr("Never") }
+            }
+            Accessible.name: suggestionModeLabel.text
+            Accessible.description: suggestionModeLabel.helpText
+            onActivated: {
+                MySettings.suggestionMode = suggestionModeBox.currentIndex;
+            }
+            Component.onCompleted: {
+                suggestionModeBox.currentIndex = MySettings.suggestionMode;
+            }
+        }
+        MySettingsLabel {
+            id: modelPathLabel
+            text: qsTr("Download Path")
+            helpText: qsTr("Where to store local models and the LocalDocs database.")
+            Layout.row: 8
+            Layout.column: 0
+        }
+
+        RowLayout {
+            Layout.row: 8
+            Layout.column: 2
+            Layout.alignment: Qt.AlignRight
+            Layout.minimumWidth: 400
+            Layout.maximumWidth: 400
+            spacing: 10
+            MyDirectoryField {
+                id: modelPathDisplayField
+                text: MySettings.modelPath
+                font.pixelSize: theme.fontSizeLarge
+                implicitWidth: 300
+                Layout.fillWidth: true
+                Accessible.name: modelPathLabel.text
+                Accessible.description: modelPathLabel.helpText
+                onEditingFinished: {
+                    if (isValid) {
+                        MySettings.modelPath = modelPathDisplayField.text
+                    } else {
+                        text = MySettings.modelPath
+                    }
+                }
+            }
+            MySettingsButton {
+                text: qsTr("Browse")
+                Accessible.description: qsTr("Choose where to save model files")
+                onClicked: {
+                    openFolderDialog("file://" + MySettings.modelPath, function(selectedFolder) {
+                        MySettings.modelPath = selectedFolder
+                    })
+                }
+            }
+        }
+
+        MySettingsLabel {
+            id: dataLakeLabel
+            text: qsTr("Enable Datalake")
+            helpText: qsTr("Send chats and feedback to the GPT4All Open-Source Datalake.")
+            Layout.row: 9
+            Layout.column: 0
+        }
+        MyCheckBox {
+            id: dataLakeBox
+            Layout.row: 9
+            Layout.column: 2
+            Layout.alignment: Qt.AlignRight
+            Component.onCompleted: { dataLakeBox.checked = MySettings.networkIsActive; }
+            Connections {
+                target: MySettings
+                function onNetworkIsActiveChanged() { dataLakeBox.checked = MySettings.networkIsActive; }
+            }
+            onClicked: {
+                if (MySettings.networkIsActive)
+                    MySettings.networkIsActive = false;
+                else
+                    networkDialog.open();
+                dataLakeBox.checked = MySettings.networkIsActive;
+            }
+        }
+
+        ColumnLayout {
+            Layout.row: 10
+            Layout.column: 0
+            Layout.columnSpan: 3
+            Layout.fillWidth: true
+            spacing: 10
+            Label {
+                color: theme.styledTextColor
+                font.pixelSize: theme.fontSizeLarge
+                font.bold: true
+                text: qsTr("Advanced")
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 1
+                color: theme.settingsDivider
+            }
+        }
+
+        MySettingsLabel {
+            id: nThreadsLabel
+            text: qsTr("CPU Threads")
+            helpText: qsTr("The number of CPU threads used for inference and embedding.")
+            Layout.row: 11
+            Layout.column: 0
+        }
+        MyTextField {
+            text: MySettings.threadCount
+            color: theme.textColor
+            font.pixelSize: theme.fontSizeLarge
+            Layout.alignment: Qt.AlignRight
+            Layout.row: 11
+            Layout.column: 2
+            Layout.minimumWidth: 200
+            Layout.maximumWidth: 200
+            validator: IntValidator {
+                bottom: 1
+            }
+            onEditingFinished: {
+                var val = parseInt(text)
+                if (!isNaN(val)) {
+                    MySettings.threadCount = val
+                    focus = false
+                } else {
+                    text = MySettings.threadCount
+                }
+            }
+            Accessible.role: Accessible.EditableText
+            Accessible.name: nThreadsLabel.text
+            Accessible.description: ToolTip.text
+        }
+        MySettingsLabel {
+            id: saveChatsContextLabel
+            text: qsTr("Save Chat Context")
+            helpText: qsTr("Save the chat model's state to disk for faster loading. WARNING: Uses ~2GB per chat.")
+            Layout.row: 12
+            Layout.column: 0
+        }
+        MyCheckBox {
+            id: saveChatsContextBox
+            Layout.row: 12
+            Layout.column: 2
+            Layout.alignment: Qt.AlignRight
+            checked: MySettings.saveChatsContext
+            onClicked: {
+                MySettings.saveChatsContext = !MySettings.saveChatsContext
+            }
+        }
+        MySettingsLabel {
+            id: serverChatLabel
+            text: qsTr("Enable Local Server")
+            helpText: qsTr("Expose an OpenAI-Compatible server to localhost. WARNING: Results in increased resource usage.")
+            Layout.row: 13
+            Layout.column: 0
+        }
+        MyCheckBox {
+            id: serverChatBox
+            Layout.row: 13
+            Layout.column: 2
+            Layout.alignment: Qt.AlignRight
+            checked: MySettings.serverChat
+            onClicked: {
+                MySettings.serverChat = !MySettings.serverChat
+            }
+        }
+        MySettingsLabel {
+            id: serverPortLabel
+            text: qsTr("API Server Port")
+            helpText: qsTr("The port to use for the local server. Requires restart.")
+            Layout.row: 14
+            Layout.column: 0
+        }
+        MyTextField {
+            id: serverPortField
+            text: MySettings.networkPort
+            color: theme.textColor
+            font.pixelSize: theme.fontSizeLarge
+            Layout.row: 14
+            Layout.column: 2
+            Layout.minimumWidth: 200
+            Layout.maximumWidth: 200
+            Layout.alignment: Qt.AlignRight
+            validator: IntValidator {
+                bottom: 1
+            }
+            onEditingFinished: {
+                var val = parseInt(text)
+                if (!isNaN(val)) {
+                    MySettings.networkPort = val
+                    focus = false
+                } else {
+                    text = MySettings.networkPort
+                }
+            }
+            Accessible.role: Accessible.EditableText
+            Accessible.name: serverPortLabel.text
+            Accessible.description: serverPortLabel.helpText
+        }
+
+        /*MySettingsLabel {
+            id: gpuOverrideLabel
+            text: qsTr("Force Metal (macOS+arm)")
+            Layout.row: 13
+            Layout.column: 0
+        }
+        MyCheckBox {
+            id: gpuOverrideBox
+            Layout.row: 13
+            Layout.column: 2
+            Layout.alignment: Qt.AlignRight
+            checked: MySettings.forceMetal
+            onClicked: {
+                MySettings.forceMetal = !MySettings.forceMetal
+            }
+            ToolTip.text: qsTr("WARNING: On macOS with arm (M1+) this setting forces usage of the GPU. Can cause crashes if the model requires more RAM than the system supports. Because of crash possibility the setting will not persist across restarts of the application. This has no effect on non-macs or intel.")
+            ToolTip.visible: hovered
+        }*/
+
+        MySettingsLabel {
+            id: updatesLabel
+            text: qsTr("Check For Updates")
+            helpText: qsTr("Manually check for an update to GPT4All.");
+            Layout.row: 15
+            Layout.column: 0
+        }
+
+        MySettingsButton {
+            Layout.row: 15
+            Layout.column: 2
+            Layout.alignment: Qt.AlignRight
+            text: qsTr("Updates");
+            onClicked: {
+                if (!LLM.checkForUpdates())
+                    checkForUpdatesError.open()
+            }
+        }
+
+        Rectangle {
+            Layout.row: 16
+            Layout.column: 0
+            Layout.columnSpan: 3
+            Layout.fillWidth: true
+            height: 1
+            color: theme.settingsDivider
+        }
+    }
+}
+

gpt4all-chat/src/qml/ChatDrawer.qml

@@ -0,0 +1,322 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import chatlistmodel
+import llm
+import download
+import network
+import mysettings
+
+Rectangle {
+    id: chatDrawer
+
+    Theme {
+        id: theme
+    }
+
+    color: theme.viewBackground
+
+    Rectangle {
+        id: borderRight
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.right: parent.right
+        width: 1
+        color: theme.dividerColor
+    }
+
+    Item {
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        anchors.right: borderRight.left
+
+        Accessible.role: Accessible.Pane
+        Accessible.name: qsTr("Drawer")
+        Accessible.description: qsTr("Main navigation drawer")
+
+        MySettingsButton {
+            id: newChat
+            anchors.top: parent.top
+            anchors.left: parent.left
+            anchors.right: parent.right
+            anchors.margins: 20
+            font.pixelSize: theme.fontSizeLarger
+            topPadding: 24
+            bottomPadding: 24
+            text: qsTr("\uFF0B New Chat")
+            Accessible.description: qsTr("Create a new chat")
+            onClicked: {
+                ChatListModel.addChat()
+                conversationList.positionViewAtIndex(0, ListView.Beginning)
+                Network.trackEvent("new_chat", {"number_of_chats": ChatListModel.count})
+            }
+        }
+
+        Rectangle {
+            id: divider
+            anchors.top: newChat.bottom
+            anchors.margins: 20
+            anchors.topMargin: 14
+            anchors.left: parent.left
+            anchors.right: parent.right
+            height: 1
+            color: theme.dividerColor
+        }
+
+        ScrollView {
+            anchors.left: parent.left
+            anchors.right: parent.right
+            anchors.topMargin: 15
+            anchors.top: divider.bottom
+            anchors.bottom: parent.bottom
+            anchors.bottomMargin: 15
+            ScrollBar.vertical.policy: ScrollBar.AlwaysOff
+            clip: true
+
+            ListView {
+                id: conversationList
+                anchors.fill: parent
+                anchors.leftMargin: 10
+                anchors.rightMargin: 10
+                model: ChatListModel
+
+                Component.onCompleted: ChatListModel.loadChats()
+
+                ScrollBar.vertical: ScrollBar {
+                    parent: conversationList.parent
+                    anchors.top: conversationList.top
+                    anchors.left: conversationList.right
+                    anchors.bottom: conversationList.bottom
+                }
+
+                Component {
+                    id: sectionHeading
+                    Rectangle {
+                        width: ListView.view.width
+                        height: childrenRect.height
+                        color: "transparent"
+                        property bool isServer: ChatListModel.get(parent.index) && ChatListModel.get(parent.index).isServer
+                        visible: !isServer || MySettings.serverChat
+
+                        required property string section
+
+                        Text {
+                            leftPadding: 10
+                            rightPadding: 10
+                            topPadding: 15
+                            bottomPadding: 5
+                            text: parent.section
+                            color: theme.chatDrawerSectionHeader
+                            font.pixelSize: theme.fontSizeSmallest
+                        }
+                    }
+                }
+
+                section.property: "section"
+                section.criteria: ViewSection.FullString
+                section.delegate: sectionHeading
+
+                delegate: Rectangle {
+                    id: chatRectangle
+                    width: conversationList.width
+                    height: chatNameBox.height + 20
+                    property bool isCurrent: ChatListModel.currentChat === ChatListModel.get(index)
+                    property bool isServer: ChatListModel.get(index) && ChatListModel.get(index).isServer
+                    property bool trashQuestionDisplayed: false
+                    visible: !isServer || MySettings.serverChat
+                    z: isCurrent ? 199 : 1
+                    color: isCurrent ? theme.selectedBackground : "transparent"
+                    border.width: isCurrent
+                    border.color: theme.dividerColor
+                    radius: 10
+
+                    Rectangle {
+                        id: chatNameBox
+                        height: chatName.height
+                        anchors.left: parent.left
+                        anchors.right: trashButton.left
+                        anchors.verticalCenter: chatRectangle.verticalCenter
+                        anchors.leftMargin: 5
+                        anchors.rightMargin: 5
+                        radius: 5
+                        color: chatName.readOnly ? "transparent" : theme.chatNameEditBgColor
+
+                        TextField {
+                            id: chatName
+                            anchors.left: parent.left
+                            anchors.right: editButton.left
+                            anchors.verticalCenter: chatNameBox.verticalCenter
+                            topPadding: 5
+                            bottomPadding: 5
+                            color: theme.styledTextColor
+                            focus: false
+                            readOnly: true
+                            wrapMode: Text.NoWrap
+                            hoverEnabled: false // Disable hover events on the TextArea
+                            selectByMouse: false // Disable text selection in the TextArea
+                            font.pixelSize: theme.fontSizeLarge
+                            font.bold: true
+                            text: readOnly ? metrics.elidedText : name
+                            horizontalAlignment: TextInput.AlignLeft
+                            opacity: trashQuestionDisplayed ? 0.5 : 1.0
+                            TextMetrics {
+                                id: metrics
+                                font: chatName.font
+                                text: name
+                                elide: Text.ElideRight
+                                elideWidth: chatName.width - 15
+                            }
+                            background: Rectangle {
+                                color: "transparent"
+                            }
+                            onEditingFinished: {
+                                // Work around a bug in qml where we're losing focus when the whole window
+                                // goes out of focus even though this textfield should be marked as not
+                                // having focus
+                                if (chatName.readOnly)
+                                    return;
+                                changeName();
+                            }
+                            function changeName() {
+                                Network.trackChatEvent("rename_chat");
+                                ChatListModel.get(index).name = chatName.text;
+                                chatName.focus = false;
+                                chatName.readOnly = true;
+                                chatName.selectByMouse = false;
+                            }
+                            TapHandler {
+                                onTapped: {
+                                    if (isCurrent)
+                                        return;
+                                    ChatListModel.currentChat = ChatListModel.get(index);
+                                }
+                            }
+                            Accessible.role: Accessible.Button
+                            Accessible.name: text
+                            Accessible.description: qsTr("Select the current chat or edit the chat when in edit mode")
+                        }
+                        MyToolButton {
+                            id: editButton
+                            anchors.verticalCenter: parent.verticalCenter
+                            anchors.right: parent.right
+                            anchors.rightMargin: 5
+                            imageWidth: 24
+                            imageHeight: 24
+                            visible: isCurrent && !isServer && chatName.readOnly
+                            opacity: trashQuestionDisplayed ? 0.5 : 1.0
+                            source: "qrc:/gpt4all/icons/edit.svg"
+                            onClicked: {
+                                chatName.focus = true;
+                                chatName.readOnly = false;
+                                chatName.selectByMouse = true;
+                            }
+                            Accessible.name: qsTr("Edit chat name")
+                        }
+                        MyToolButton {
+                            id: okButton
+                            anchors.verticalCenter: parent.verticalCenter
+                            anchors.right: parent.right
+                            anchors.rightMargin: 5
+                            imageWidth: 24
+                            imageHeight: 24
+                            visible: isCurrent && !isServer && !chatName.readOnly
+                            opacity: trashQuestionDisplayed ? 0.5 : 1.0
+                            source: "qrc:/gpt4all/icons/check.svg"
+                            onClicked: chatName.changeName()
+                            Accessible.name: qsTr("Save chat name")
+                        }
+                    }
+
+                    MyToolButton {
+                        id: trashButton
+                        anchors.verticalCenter: chatNameBox.verticalCenter
+                        anchors.right: chatRectangle.right
+                        anchors.rightMargin: 10
+                        imageWidth: 24
+                        imageHeight: 24
+                        visible: isCurrent && !isServer
+                        source: "qrc:/gpt4all/icons/trash.svg"
+                        onClicked: {
+                            trashQuestionDisplayed = true
+                            timer.start()
+                        }
+                        Accessible.name: qsTr("Delete chat")
+                    }
+                    Rectangle {
+                        id: trashSureQuestion
+                        anchors.top: trashButton.bottom
+                        anchors.topMargin: 10
+                        anchors.right: trashButton.right
+                        width: childrenRect.width
+                        height: childrenRect.height
+                        color: chatRectangle.color
+                        visible: isCurrent && trashQuestionDisplayed
+                        opacity: 1.0
+                        radius: 10
+                        z: 200
+                        Row {
+                            spacing: 10
+                            Button {
+                                id: checkMark
+                                width: 30
+                                height: 30
+                                contentItem: Text {
+                                    color: theme.textErrorColor
+                                    text: "\u2713"
+                                    font.pixelSize: theme.fontSizeLarger
+                                    horizontalAlignment: Text.AlignHCenter
+                                    verticalAlignment: Text.AlignVCenter
+                                }
+                                background: Rectangle {
+                                    width: 30
+                                    height: 30
+                                    color: "transparent"
+                                }
+                                onClicked: {
+                                    Network.trackChatEvent("remove_chat")
+                                    ChatListModel.removeChat(ChatListModel.get(index))
+                                }
+                                Accessible.role: Accessible.Button
+                                Accessible.name: qsTr("Confirm chat deletion")
+                            }
+                            Button {
+                                id: cancel
+                                width: 30
+                                height: 30
+                                contentItem: Text {
+                                    color: theme.textColor
+                                    text: "\u2715"
+                                    font.pixelSize: theme.fontSizeLarger
+                                    horizontalAlignment: Text.AlignHCenter
+                                    verticalAlignment: Text.AlignVCenter
+                                }
+                                background: Rectangle {
+                                    width: 30
+                                    height: 30
+                                    color: "transparent"
+                                }
+                                onClicked: {
+                                    trashQuestionDisplayed = false
+                                }
+                                Accessible.role: Accessible.Button
+                                Accessible.name: qsTr("Cancel chat deletion")
+                            }
+                        }
+                    }
+                    Timer {
+                        id: timer
+                        interval: 3000; running: false; repeat: false
+                        onTriggered: trashQuestionDisplayed = false
+                    }
+                }
+
+                Accessible.role: Accessible.List
+                Accessible.name: qsTr("List of chats")
+                Accessible.description: qsTr("List of chats in the drawer dialog")
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/CollectionsDrawer.qml

@@ -0,0 +1,146 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import QtQuick.Dialogs
+import chatlistmodel
+import localdocs
+import llm
+
+Rectangle {
+    id: collectionsDrawer
+
+    color: "transparent"
+
+    signal addDocsClicked
+    property var currentChat: ChatListModel.currentChat
+
+    Rectangle {
+        id: borderLeft
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.left: parent.left
+        width: 1
+        color: theme.dividerColor
+    }
+
+    ScrollView {
+        id: scrollView
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.left: borderLeft.right
+        anchors.right: parent.right
+        anchors.margins: 2
+        anchors.bottomMargin: 10
+        clip: true
+        contentHeight: 300
+        ScrollBar.vertical.policy: ScrollBar.AsNeeded
+
+        ListView {
+            id: listView
+            model: LocalDocs.localDocsModel
+            anchors.fill: parent
+            anchors.margins: 13
+            anchors.bottomMargin: 5
+            boundsBehavior: Flickable.StopAtBounds
+            spacing: 15
+
+            delegate: Rectangle {
+                width: listView.width
+                height: childrenRect.height + 15
+                color: checkBox.checked ? theme.collectionsButtonBackground : "transparent"
+
+                RowLayout {
+                    anchors.top: parent.top
+                    anchors.left: parent.left
+                    anchors.right: parent.right
+                    anchors.margins: 7.5
+                    MyCheckBox {
+                        id: checkBox
+                        Layout.alignment: Qt.AlignLeft
+                        checked: currentChat.hasCollection(collection)
+                        onClicked: {
+                            if (checkBox.checked) {
+                                currentChat.addCollection(collection)
+                            } else {
+                                currentChat.removeCollection(collection)
+                            }
+                        }
+                        ToolTip.text: qsTr("Warning: searching collections while indexing can return incomplete results")
+                        ToolTip.visible: hovered && model.indexing
+                    }
+                    ColumnLayout {
+                        Layout.fillWidth: true
+                        Layout.alignment: Qt.AlignLeft
+                        Text {
+                            Layout.fillWidth: true
+                            Layout.alignment: Qt.AlignLeft
+                            text: collection
+                            font.pixelSize: theme.fontSizeLarger
+                            elide: Text.ElideRight
+                            color: theme.textColor
+                        }
+                        Text {
+                            Layout.fillWidth: true
+                            Layout.alignment: Qt.AlignLeft
+                            text: "%1 – %2".arg(qsTr("%n file(s)", "", model.totalDocs)).arg(qsTr("%n word(s)", "", model.totalWords))
+                            elide: Text.ElideRight
+                            color: theme.mutedTextColor
+                            font.pixelSize: theme.fontSizeSmall
+                        }
+                        RowLayout {
+                            visible: model.updating
+                            Layout.fillWidth: true
+                            Layout.alignment: Qt.AlignLeft
+                            MyBusyIndicator {
+                                color: theme.accentColor
+                                size: 24
+                                Layout.minimumWidth: 24
+                                Layout.minimumHeight: 24
+                            }
+                            Text {
+                                text: qsTr("Updating")
+                                elide: Text.ElideRight
+                                color: theme.accentColor
+                                font.pixelSize: theme.fontSizeSmall
+                                font.bold: true
+                            }
+                        }
+                    }
+                }
+            }
+
+            footer: ColumnLayout {
+                width: listView.width
+                spacing: 30
+                Rectangle {
+                    visible: listView.count !== 0
+                    Layout.topMargin: 30
+                    Layout.fillWidth: true
+                    height: 1
+                    color: theme.dividerColor
+                }
+                MySettingsButton {
+                    id: collectionSettings
+                    enabled: LocalDocs.databaseValid
+                    Layout.alignment: Qt.AlignCenter
+                    text: qsTr("\uFF0B Add Docs")
+                    font.pixelSize: theme.fontSizeLarger
+                    onClicked: {
+                        addDocsClicked()
+                    }
+                }
+                Text {
+                    Layout.fillWidth: true
+                    Layout.alignment: Qt.AlignLeft
+                    text: qsTr("Select a collection to make it available to the chat model.")
+                    font.pixelSize: theme.fontSizeLarger
+                    wrapMode: Text.WordWrap
+                    elide: Text.ElideRight
+                    color: theme.mutedTextColor
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/HomeView.qml

@@ -0,0 +1,288 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import Qt5Compat.GraphicalEffects
+import llm
+import chatlistmodel
+import download
+import modellist
+import network
+import gpt4all
+import mysettings
+
+Rectangle {
+    id: homeView
+
+    Theme {
+        id: theme
+    }
+
+    color: theme.viewBackground
+    signal chatViewRequested()
+    signal localDocsViewRequested()
+    signal settingsViewRequested(int page)
+    signal addModelViewRequested()
+    property bool shouldShowFirstStart: false
+
+    ColumnLayout {
+        id: mainArea
+        anchors.fill: parent
+        anchors.margins: 30
+        spacing: 30
+
+        ColumnLayout {
+            Layout.fillWidth: true
+            Layout.maximumWidth: 1530
+            Layout.alignment: Qt.AlignCenter
+            Layout.topMargin: 20
+            spacing: 30
+
+            ColumnLayout {
+                Layout.alignment: Qt.AlignHCenter
+                spacing: 5
+
+                Text {
+                    id: welcome
+                    Layout.alignment: Qt.AlignHCenter
+                    text: qsTr("Welcome to GPT4All")
+                    font.pixelSize: theme.fontSizeBanner
+                    color: theme.titleTextColor
+                }
+
+                Text {
+                    Layout.alignment: Qt.AlignHCenter
+                    text: qsTr("The privacy-first LLM chat application")
+                    font.pixelSize: theme.fontSizeLarge
+                    color: theme.titleInfoTextColor
+                }
+            }
+
+            MyButton {
+                id: startChat
+                visible: shouldShowFirstStart
+                Layout.alignment: Qt.AlignHCenter
+                text: qsTr("Start chatting")
+                onClicked: {
+                    chatViewRequested()
+                }
+            }
+
+            RowLayout {
+                spacing: 15
+                visible: !startChat.visible
+                Layout.alignment: Qt.AlignHCenter
+
+                MyWelcomeButton {
+                    Layout.fillWidth: true
+                    Layout.maximumWidth: 500
+                    Layout.preferredHeight: 150
+                    text: qsTr("Start Chatting")
+                    description: qsTr("Chat with any LLM")
+                    imageSource: "qrc:/gpt4all/icons/chat.svg"
+                    onClicked: {
+                        chatViewRequested()
+                    }
+                }
+                MyWelcomeButton {
+                    Layout.fillWidth: true
+                    Layout.maximumWidth: 500
+                    Layout.preferredHeight: 150
+                    text: qsTr("LocalDocs")
+                    description: qsTr("Chat with your local files")
+                    imageSource: "qrc:/gpt4all/icons/db.svg"
+                    onClicked: {
+                        localDocsViewRequested()
+                    }
+                }
+                MyWelcomeButton {
+                    Layout.fillWidth: true
+                    Layout.maximumWidth: 500
+                    Layout.preferredHeight: 150
+                    text: qsTr("Find Models")
+                    description: qsTr("Explore and download models")
+                    imageSource: "qrc:/gpt4all/icons/models.svg"
+                    onClicked: {
+                        addModelViewRequested()
+                    }
+                }
+            }
+
+            Item {
+                visible: !startChat.visible && Download.latestNews !== ""
+                Layout.fillWidth: true
+                Layout.fillHeight: true
+                Layout.minimumHeight: 120
+                Layout.maximumHeight: textAreaNews.height
+
+                Rectangle {
+                    id: roundedFrameNews // latest news
+                    anchors.fill: parent
+                    z: 299
+                    radius: 10
+                    border.width: 1
+                    border.color: theme.controlBorder
+                    color: "transparent"
+                    clip: true
+                }
+
+                Item {
+                    anchors.fill: parent
+                    layer.enabled: true
+                    layer.effect: OpacityMask {
+                        maskSource: Rectangle {
+                            width: roundedFrameNews.width
+                            height: roundedFrameNews.height
+                            radius: 10
+                        }
+                    }
+
+                    RowLayout {
+                        spacing: 0
+                        anchors.fill: parent
+                        Rectangle {
+                            color: "transparent"
+                            width: 82
+                            height: 100
+                            Image {
+                                id: newsImg
+                                anchors.centerIn: parent
+                                sourceSize: Qt.size(48, 48)
+                                mipmap: true
+                                visible: false
+                                source: "qrc:/gpt4all/icons/gpt4all_transparent.svg"
+                            }
+
+                            ColorOverlay {
+                                anchors.fill: newsImg
+                                source: newsImg
+                                color: theme.styledTextColor
+                            }
+                        }
+
+                        Item {
+                            id: myItem
+                            Layout.fillWidth: true
+                            Layout.fillHeight: true
+                            Rectangle {
+                                anchors.fill: parent
+                                color: theme.conversationBackground
+                            }
+
+                            ScrollView {
+                                id: newsScroll
+                                anchors.fill: parent
+                                clip: true
+                                ScrollBar.vertical.policy: ScrollBar.AsNeeded
+                                ScrollBar.horizontal.policy: ScrollBar.AlwaysOff
+                                Text {
+                                    id: textAreaNews
+                                    width: myItem.width
+                                    padding: 20
+                                    color: theme.styledTextColor
+                                    font.pixelSize: theme.fontSizeLarger
+                                    textFormat: TextEdit.MarkdownText
+                                    wrapMode: Text.WordWrap
+                                    text: Download.latestNews
+                                    focus: false
+                                    Accessible.role: Accessible.Paragraph
+                                    Accessible.name: qsTr("Latest news")
+                                    Accessible.description: qsTr("Latest news from GPT4All")
+                                    onLinkActivated: function(link) {
+                                        Qt.openUrlExternally(link);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Rectangle {
+            id: linkBar
+            Layout.alignment: Qt.AlignBottom
+            Layout.fillWidth: true
+            border.width: 1
+            border.color: theme.dividerColor
+            radius: 6
+            z: 200
+            height: 30
+            color: theme.conversationBackground
+
+            RowLayout {
+                anchors.fill: parent
+                spacing: 0
+                RowLayout {
+                    Layout.alignment: Qt.AlignLeft | Qt.AlignVCenter
+                    spacing: 4
+
+                    MyFancyLink {
+                        text: qsTr("Release Notes")
+                        imageSource: "qrc:/gpt4all/icons/notes.svg"
+                        onClicked: { Qt.openUrlExternally("https://github.com/nomic-ai/gpt4all/releases") }
+                    }
+
+                    MyFancyLink {
+                        text: qsTr("Documentation")
+                        imageSource: "qrc:/gpt4all/icons/info.svg"
+                        onClicked: { Qt.openUrlExternally("https://docs.gpt4all.io/") }
+                    }
+
+                    MyFancyLink {
+                        text: qsTr("Discord")
+                        imageSource: "qrc:/gpt4all/icons/discord.svg"
+                        onClicked: { Qt.openUrlExternally("https://discord.gg/4M2QFmTt2k") }
+                    }
+
+                    MyFancyLink {
+                        text: qsTr("X (Twitter)")
+                        imageSource: "qrc:/gpt4all/icons/twitter.svg"
+                        onClicked: { Qt.openUrlExternally("https://twitter.com/nomic_ai") }
+                    }
+
+                    MyFancyLink {
+                        text: qsTr("Github")
+                        imageSource: "qrc:/gpt4all/icons/github.svg"
+                        onClicked: { Qt.openUrlExternally("https://github.com/nomic-ai/gpt4all") }
+                    }
+                }
+
+                RowLayout {
+                    Layout.alignment: Qt.AlignRight | Qt.AlignVCenter
+                    spacing: 40
+
+                    MyFancyLink {
+                        text: qsTr("nomic.ai")
+                        imageSource: "qrc:/gpt4all/icons/globe.svg"
+                        onClicked: { Qt.openUrlExternally("https://www.nomic.ai/gpt4all") }
+                        rightPadding: 15
+                    }
+                }
+            }
+        }
+    }
+
+    Rectangle {
+        anchors.top: mainArea.top
+        anchors.right: mainArea.right
+        border.width: 1
+        border.color: theme.dividerColor
+        radius: 6
+        z: 200
+        height: 30
+        color: theme.conversationBackground
+        width: subscribeLink.width
+        RowLayout {
+            anchors.centerIn: parent
+            MyFancyLink {
+                id: subscribeLink
+                Layout.alignment: Qt.AlignCenter
+                text: qsTr("Subscribe to Newsletter")
+                imageSource: "qrc:/gpt4all/icons/email.svg"
+                onClicked: { Qt.openUrlExternally("https://forms.nomic.ai/gpt4all-release-notes-signup") }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/LocalDocsSettings.qml

@@ -0,0 +1,321 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import QtQuick.Dialogs
+import localdocs
+import modellist
+import mysettings
+import network
+
+MySettingsTab {
+    onRestoreDefaultsClicked: {
+        MySettings.restoreLocalDocsDefaults();
+    }
+
+    showRestoreDefaultsButton: true
+
+    title: qsTr("LocalDocs")
+    contentItem: ColumnLayout {
+        id: root
+        spacing: 30
+
+        Label {
+            Layout.bottomMargin: 10
+            color: theme.settingsTitleTextColor
+            font.pixelSize: theme.fontSizeBannerSmall
+            font.bold: true
+            text: qsTr("LocalDocs Settings")
+        }
+
+        ColumnLayout {
+            spacing: 10
+            Label {
+                color: theme.styledTextColor
+                font.pixelSize: theme.fontSizeLarge
+                font.bold: true
+                text: qsTr("Indexing")
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 1
+                color: theme.settingsDivider
+            }
+        }
+
+        RowLayout {
+            MySettingsLabel {
+                id: extsLabel
+                text: qsTr("Allowed File Extensions")
+                helpText: qsTr("Comma-separated list. LocalDocs will only attempt to process files with these extensions.")
+            }
+            MyTextField {
+                id: extsField
+                text: MySettings.localDocsFileExtensions.join(',')
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                Layout.alignment: Qt.AlignRight
+                Layout.minimumWidth: 200
+                validator: RegularExpressionValidator {
+                    regularExpression: /([^ ,\/"']+,?)*/
+                }
+                onEditingFinished: {
+                    // split and remove empty elements
+                    var exts = text.split(',').filter(e => e);
+                    // normalize and deduplicate
+                    exts = exts.map(e => e.toLowerCase());
+                    exts = Array.from(new Set(exts));
+                    /* Blacklist common unsupported file extensions. We only support plain text and PDFs, and although we
+                     * reject binary data, we don't want to waste time trying to index files that we don't support. */
+                    exts = exts.filter(e => ![
+                        /* Microsoft documents  */ "rtf", "docx", "ppt", "pptx", "xls", "xlsx",
+                        /* OpenOffice           */ "odt", "ods", "odp", "odg",
+                        /* photos               */ "jpg", "jpeg", "png", "gif", "bmp", "tif", "tiff", "webp",
+                        /* audio                */ "mp3", "wma", "m4a", "wav", "flac",
+                        /* videos               */ "mp4", "mov", "webm", "mkv", "avi", "flv", "wmv",
+                        /* executables          */ "exe", "com", "dll", "so", "dylib", "msi",
+                        /* binary images        */ "iso", "img", "dmg",
+                        /* archives             */ "zip", "jar", "apk", "rar", "7z", "tar", "gz", "xz", "bz2", "tar.gz",
+                                                   "tgz", "tar.xz", "tar.bz2",
+                        /* misc                 */ "bin",
+                    ].includes(e));
+                    MySettings.localDocsFileExtensions = exts;
+                    extsField.text = exts.join(',');
+                    focus = false;
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: extsLabel.text
+                Accessible.description: extsLabel.helpText
+            }
+        }
+
+        ColumnLayout {
+            spacing: 10
+            Label {
+                color: theme.grayRed900
+                font.pixelSize: theme.fontSizeLarge
+                font.bold: true
+                text: qsTr("Embedding")
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 1
+                color: theme.grayRed500
+            }
+        }
+
+        RowLayout {
+            MySettingsLabel {
+                text: qsTr("Use Nomic Embed API")
+                helpText: qsTr("Embed documents using the fast Nomic API instead of a private local model. Requires restart.")
+            }
+
+            MyCheckBox {
+                id: useNomicAPIBox
+                Component.onCompleted: {
+                    useNomicAPIBox.checked = MySettings.localDocsUseRemoteEmbed;
+                }
+                onClicked: {
+                    MySettings.localDocsUseRemoteEmbed = useNomicAPIBox.checked && MySettings.localDocsNomicAPIKey !== "";
+                }
+            }
+        }
+
+        RowLayout {
+            MySettingsLabel {
+                id: apiKeyLabel
+                text: qsTr("Nomic API Key")
+                helpText: qsTr('API key to use for Nomic Embed. Get one from the Atlas <a href="https://atlas.nomic.ai/cli-login">API keys page</a>. Requires restart.')
+                onLinkActivated: function(link) { Qt.openUrlExternally(link) }
+            }
+
+            MyTextField {
+                id: apiKeyField
+
+                property bool isValid: validate()
+                onTextChanged: { isValid = validate(); }
+                function validate() { return /^(nk-[a-zA-Z0-9_-]{43})?$/.test(apiKeyField.text); }
+
+                placeholderText: "nk-" + "X".repeat(43)
+                text: MySettings.localDocsNomicAPIKey
+                color: apiKeyField.isValid ? theme.textColor : theme.textErrorColor
+                font.pixelSize: theme.fontSizeLarge
+                Layout.alignment: Qt.AlignRight
+                Layout.minimumWidth: 200
+                enabled: useNomicAPIBox.checked
+                onEditingFinished: {
+                    if (apiKeyField.isValid) {
+                        MySettings.localDocsNomicAPIKey = apiKeyField.text;
+                        MySettings.localDocsUseRemoteEmbed = useNomicAPIBox.checked && MySettings.localDocsNomicAPIKey !== "";
+                    }
+                    focus = false;
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: apiKeyLabel.text
+                Accessible.description: apiKeyLabel.helpText
+            }
+        }
+
+        RowLayout {
+            MySettingsLabel {
+                id: deviceLabel
+                text: qsTr("Embeddings Device")
+                helpText: qsTr('The compute device used for embeddings. Requires restart.')
+            }
+            MyComboBox {
+                id: deviceBox
+                enabled: !useNomicAPIBox.checked
+                Layout.minimumWidth: 400
+                Layout.maximumWidth: 400
+                Layout.fillWidth: false
+                Layout.alignment: Qt.AlignRight
+                model: ListModel {
+                    ListElement { text: qsTr("Application default") }
+                    Component.onCompleted: {
+                        MySettings.embeddingsDeviceList.forEach(d => append({"text": d}));
+                    }
+                }
+                Accessible.name: deviceLabel.text
+                Accessible.description: deviceLabel.helpText
+                function updateModel() {
+                    var device = MySettings.localDocsEmbedDevice;
+                    // This usage of 'Auto' should not be translated
+                    deviceBox.currentIndex = device === "Auto" ? 0 : deviceBox.indexOfValue(device);
+                }
+                Component.onCompleted: {
+                    deviceBox.updateModel();
+                }
+                Connections {
+                    target: MySettings
+                    function onDeviceChanged() {
+                        deviceBox.updateModel();
+                    }
+                }
+                onActivated: {
+                    // This usage of 'Auto' should not be translated
+                    MySettings.localDocsEmbedDevice = deviceBox.currentIndex === 0 ? "Auto" : deviceBox.currentText;
+                }
+            }
+        }
+
+        ColumnLayout {
+            spacing: 10
+            Label {
+                color: theme.grayRed900
+                font.pixelSize: theme.fontSizeLarge
+                font.bold: true
+                text: qsTr("Display")
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 1
+                color: theme.grayRed500
+            }
+        }
+
+        RowLayout {
+            MySettingsLabel {
+                id: showReferencesLabel
+                text: qsTr("Show Sources")
+                helpText: qsTr("Display the sources used for each response.")
+            }
+            MyCheckBox {
+                id: showReferencesBox
+                checked: MySettings.localDocsShowReferences
+                onClicked: {
+                    MySettings.localDocsShowReferences = !MySettings.localDocsShowReferences
+                }
+            }
+        }
+
+        ColumnLayout {
+            spacing: 10
+            Label {
+                color: theme.styledTextColor
+                font.pixelSize: theme.fontSizeLarge
+                font.bold: true
+                text: qsTr("Advanced")
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 1
+                color: theme.settingsDivider
+            }
+        }
+
+        MySettingsLabel {
+            id: warningLabel
+            Layout.bottomMargin: 15
+            Layout.fillWidth: true
+            color: theme.textErrorColor
+            wrapMode: Text.WordWrap
+            text: qsTr("Warning: Advanced usage only.")
+            helpText: qsTr("Values too large may cause localdocs failure, extremely slow responses or failure to respond at all. Roughly speaking, the {N chars x N snippets} are added to the model's context window. More info <a href=\"https://docs.gpt4all.io/gpt4all_desktop/localdocs.html\">here</a>.")
+            onLinkActivated: function(link) { Qt.openUrlExternally(link) }
+        }
+
+        RowLayout {
+            MySettingsLabel {
+                id: chunkLabel
+                Layout.fillWidth: true
+                text: qsTr("Document snippet size (characters)")
+                helpText: qsTr("Number of characters per document snippet. Larger numbers increase likelihood of factual responses, but also result in slower generation.")
+            }
+
+            MyTextField {
+                id: chunkSizeTextField
+                text: MySettings.localDocsChunkSize
+                validator: IntValidator {
+                    bottom: 1
+                }
+                onEditingFinished: {
+                    var val = parseInt(text)
+                    if (!isNaN(val)) {
+                        MySettings.localDocsChunkSize = val
+                        focus = false
+                    } else {
+                        text = MySettings.localDocsChunkSize
+                    }
+                }
+            }
+        }
+
+        RowLayout {
+            Layout.topMargin: 15
+            MySettingsLabel {
+                id: contextItemsPerPrompt
+                text: qsTr("Max document snippets per prompt")
+                helpText: qsTr("Max best N matches of retrieved document snippets to add to the context for prompt. Larger numbers increase likelihood of factual responses, but also result in slower generation.")
+
+            }
+
+            MyTextField {
+                text: MySettings.localDocsRetrievalSize
+                validator: IntValidator {
+                    bottom: 1
+                }
+                onEditingFinished: {
+                    var val = parseInt(text)
+                    if (!isNaN(val)) {
+                        MySettings.localDocsRetrievalSize = val
+                        focus = false
+                    } else {
+                        text = MySettings.localDocsRetrievalSize
+                    }
+                }
+            }
+        }
+
+        Rectangle {
+            Layout.topMargin: 15
+            Layout.fillWidth: true
+            height: 1
+            color: theme.settingsDivider
+        }
+     }
+}

gpt4all-chat/src/qml/LocalDocsView.qml

@@ -0,0 +1,443 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import Qt5Compat.GraphicalEffects
+import llm
+import chatlistmodel
+import download
+import modellist
+import network
+import gpt4all
+import mysettings
+import localdocs
+
+Rectangle {
+    id: localDocsView
+
+    Theme {
+        id: theme
+    }
+
+    color: theme.viewBackground
+    signal chatViewRequested()
+    signal localDocsViewRequested()
+    signal settingsViewRequested(int page)
+    signal addCollectionViewRequested()
+
+    ColumnLayout {
+        id: mainArea
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.margins: 30
+        spacing: 50
+
+        RowLayout {
+            Layout.fillWidth: true
+            Layout.alignment: Qt.AlignTop
+            visible: LocalDocs.databaseValid && LocalDocs.localDocsModel.count !== 0
+            spacing: 50
+
+            ColumnLayout {
+                Layout.fillWidth: true
+                Layout.alignment: Qt.AlignLeft
+                Layout.minimumWidth: 200
+                spacing: 5
+
+                Text {
+                    id: welcome
+                    text: qsTr("LocalDocs")
+                    font.pixelSize: theme.fontSizeBanner
+                    color: theme.titleTextColor
+                }
+
+                Text {
+                    text: qsTr("Chat with your local files")
+                    font.pixelSize: theme.fontSizeLarge
+                    color: theme.titleInfoTextColor
+                }
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 0
+            }
+
+            MyButton {
+                Layout.alignment: Qt.AlignTop | Qt.AlignRight
+                text: qsTr("\uFF0B Add Collection")
+                onClicked: {
+                    addCollectionViewRequested()
+                }
+            }
+        }
+
+        Rectangle {
+            id: warning
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            visible: !LocalDocs.databaseValid
+            Text {
+                anchors.centerIn: parent
+                text: qsTr("<h3>ERROR: The LocalDocs database cannot be accessed or is not valid.</h3><br>"
+                         + "<i>Note: You will need to restart after trying any of the following suggested fixes.</i><br>"
+                         + "<ul><li>Make sure that the folder set as <b>Download Path</b> exists on the file system.</li>"
+                         + "<li>Check ownership as well as read and write permissions of the <b>Download Path</b>.</li>"
+                         + "<li>If there is a <b>localdocs_v2.db</b> file, check its ownership and read/write "
+                         + "permissions, too.</li></ul><br>"
+                         + "If the problem persists and there are any 'localdocs_v*.db' files present, as a last resort you can<br>"
+                         + "try backing them up and removing them. You will have to recreate your collections, however.")
+                color: theme.textErrorColor
+                font.pixelSize: theme.fontSizeLarger
+            }
+        }
+
+        Item {
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            visible: LocalDocs.databaseValid && LocalDocs.localDocsModel.count === 0
+            ColumnLayout {
+                id: noInstalledLabel
+                anchors.centerIn: parent
+                spacing: 0
+
+                Text {
+                    Layout.alignment: Qt.AlignCenter
+                    text: qsTr("No Collections Installed")
+                    color: theme.mutedLightTextColor
+                    font.pixelSize: theme.fontSizeBannerSmall
+                }
+
+                Text {
+                    Layout.topMargin: 15
+                    horizontalAlignment: Qt.AlignHCenter
+                    color: theme.mutedLighterTextColor
+                    text: qsTr("Install a collection of local documents to get started using this feature")
+                    font.pixelSize: theme.fontSizeLarge
+                }
+            }
+
+            MyButton {
+                anchors.top: noInstalledLabel.bottom
+                anchors.topMargin: 50
+                anchors.horizontalCenter: noInstalledLabel.horizontalCenter
+                rightPadding: 60
+                leftPadding: 60
+                text: qsTr("\uFF0B Add Doc Collection")
+                onClicked: {
+                    addCollectionViewRequested()
+                }
+                Accessible.role: Accessible.Button
+                Accessible.name: qsTr("Shows the add model view")
+            }
+        }
+
+        ScrollView {
+            id: scrollView
+            ScrollBar.vertical.policy: ScrollBar.AsNeeded
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            clip: true
+            visible: LocalDocs.databaseValid && LocalDocs.localDocsModel.count !== 0
+
+            ListView {
+                id: collectionListView
+                model: LocalDocs.localDocsModel
+                boundsBehavior: Flickable.StopAtBounds
+                spacing: 30
+
+                delegate: Rectangle {
+                    width: collectionListView.width
+                    height: childrenRect.height + 60
+                    color: theme.conversationBackground
+                    radius: 10
+                    border.width: 1
+                    border.color: theme.controlBorder
+
+                    property bool removing: false
+
+                    ColumnLayout {
+                        anchors.top: parent.top
+                        anchors.left: parent.left
+                        anchors.right: parent.right
+                        anchors.margins: 30
+                        spacing: 10
+
+                        RowLayout {
+                            Layout.fillWidth: true
+                            Text {
+                                Layout.fillWidth: true
+                                Layout.alignment: Qt.AlignLeft
+                                text: collection
+                                elide: Text.ElideRight
+                                color: theme.titleTextColor
+                                font.pixelSize: theme.fontSizeLargest
+                                font.bold: true
+                            }
+
+                            Item {
+                                Layout.alignment: Qt.AlignRight
+                                Layout.preferredWidth: state.contentWidth + 50
+                                Layout.preferredHeight: state.contentHeight + 10
+                                ProgressBar {
+                                    id: itemProgressBar
+                                    anchors.fill: parent
+                                    value: {
+                                        if (model.error !== "")
+                                            return 0
+
+                                        if (model.indexing)
+                                            return (model.totalBytesToIndex - model.currentBytesToIndex) / model.totalBytesToIndex
+
+                                        if (model.currentEmbeddingsToIndex !== 0)
+                                            return (model.totalEmbeddingsToIndex - model.currentEmbeddingsToIndex) / model.totalEmbeddingsToIndex
+
+                                        return 0
+                                    }
+
+                                    background: Rectangle {
+                                        implicitHeight: 45
+                                        color: {
+                                            if (model.error !== "")
+                                                return "transparent"
+
+                                            if (model.indexing)
+                                                 return theme.altProgressBackground
+
+                                            if (model.currentEmbeddingsToIndex !== 0)
+                                                 return theme.altProgressBackground
+
+                                            if (model.forceIndexing)
+                                                return theme.red200
+
+                                            return theme.lightButtonBackground
+                                        }
+                                        radius: 6
+                                    }
+                                    contentItem: Item {
+                                        implicitHeight: 40
+
+                                        Rectangle {
+                                            width: itemProgressBar.visualPosition * parent.width
+                                            height: parent.height
+                                            radius: 2
+                                            color: theme.altProgressForeground
+                                        }
+                                    }
+                                    Accessible.role: Accessible.ProgressBar
+                                    Accessible.name: qsTr("Indexing progressBar")
+                                    Accessible.description: qsTr("Shows the progress made in the indexing")
+                                    ToolTip.text: model.error
+                                    ToolTip.visible: hovered && model.error !== ""
+                                }
+                                Label {
+                                    id: state
+                                    anchors.centerIn: itemProgressBar
+                                    horizontalAlignment: Text.AlignHCenter
+                                    color: {
+                                        if (model.error !== "")
+                                            return theme.textErrorColor
+
+                                        if (model.indexing)
+                                            return theme.altProgressText
+
+                                        if (model.currentEmbeddingsToIndex !== 0)
+                                            return theme.altProgressText
+
+                                        if (model.forceIndexing)
+                                            return theme.textErrorColor
+
+                                        return theme.lighterButtonForeground
+                                    }
+                                    text: {
+                                        if (model.error !== "")
+                                            return qsTr("ERROR")
+
+                                        // indicates extracting snippets from documents
+                                        if (model.indexing)
+                                            return qsTr("INDEXING")
+
+                                        // indicates generating the embeddings for any outstanding snippets
+                                        if (model.currentEmbeddingsToIndex !== 0)
+                                            return qsTr("EMBEDDING")
+
+                                        if (model.forceIndexing)
+                                            return qsTr("REQUIRES UPDATE")
+
+                                        if (model.installed)
+                                            return qsTr("READY")
+
+                                        return qsTr("INSTALLING")
+                                    }
+                                    elide: Text.ElideRight
+                                    font.bold: true
+                                    font.pixelSize: theme.fontSizeSmaller
+                                }
+                            }
+                        }
+
+                        RowLayout {
+                            Layout.fillWidth: true
+                            Text {
+                                Layout.fillWidth: true
+                                Layout.alignment: Qt.AlignLeft
+                                text: folder_path
+                                elide: Text.ElideRight
+                                color: theme.titleTextColor2
+                                font.pixelSize: theme.fontSizeSmall
+                            }
+
+                            Text {
+                                Layout.alignment: Qt.AlignRight
+                                text: {
+                                    if (model.error !== "")
+                                        return model.error
+
+                                    if (model.indexing)
+                                        return qsTr("Indexing in progress")
+
+                                    if (model.currentEmbeddingsToIndex !== 0)
+                                        return qsTr("Embedding in progress")
+
+                                    if (model.forceIndexing)
+                                        return qsTr("This collection requires an update after version change")
+
+                                    if (model.installed)
+                                        return qsTr("Automatically reindexes upon changes to the folder")
+
+                                    return qsTr("Installation in progress")
+                                }
+                                elide: Text.ElideRight
+                                color: theme.mutedDarkTextColor
+                                font.pixelSize: theme.fontSizeSmall
+                            }
+                            Text {
+                                visible: {
+                                    return model.indexing || model.currentEmbeddingsToIndex !== 0
+                                }
+                                Layout.alignment: Qt.AlignRight
+                                text: {
+                                    var percentComplete = Math.round(itemProgressBar.value * 100);
+                                    var formattedPercent = percentComplete < 10 ? " " + percentComplete : percentComplete.toString();
+                                    return formattedPercent + qsTr("%")
+                                }
+                                elide: Text.ElideRight
+                                color: theme.mutedDarkTextColor
+                                font.family: "monospace"
+                                font.pixelSize: theme.fontSizeSmall
+                            }
+                        }
+
+                        RowLayout {
+                            spacing: 7
+                            Text {
+                                text: "%1 – %2".arg(qsTr("%n file(s)", "", model.totalDocs)).arg(qsTr("%n word(s)", "", model.totalWords))
+                                elide: Text.ElideRight
+                                color: theme.styledTextColor2
+                                font.pixelSize: theme.fontSizeSmall
+                            }
+                            Text {
+                                text: model.embeddingModel
+                                elide: Text.ElideRight
+                                color: theme.mutedDarkTextColor
+                                font.bold: true
+                                font.pixelSize: theme.fontSizeSmall
+                            }
+                            Text {
+                                visible: Qt.formatDateTime(model.lastUpdate) !== ""
+                                text: Qt.formatDateTime(model.lastUpdate)
+                                elide: Text.ElideRight
+                                color: theme.mutedTextColor
+                                font.pixelSize: theme.fontSizeSmall
+                            }
+                            Text {
+                                visible: model.currentEmbeddingsToIndex !== 0
+                                text: (model.totalEmbeddingsToIndex - model.currentEmbeddingsToIndex) + " of "
+                                      + model.totalEmbeddingsToIndex + " embeddings"
+                                elide: Text.ElideRight
+                                color: theme.mutedTextColor
+                                font.pixelSize: theme.fontSizeSmall
+                            }
+                        }
+
+                        Rectangle {
+                            Layout.fillWidth: true
+                            height: 1
+                            color: theme.dividerColor
+                        }
+
+                        RowLayout {
+                            id: fileProcessingRow
+                            Layout.topMargin: 15
+                            Layout.bottomMargin: 15
+                            visible: model.fileCurrentlyProcessing !== "" && (model.indexing || model.currentEmbeddingsToIndex !== 0)
+                            MyBusyIndicator {
+                                Layout.alignment: Qt.AlignCenter
+                                Layout.preferredWidth: 12
+                                Layout.preferredHeight: 12
+                                running: true
+                                size: 12
+                                color: theme.textColor
+                            }
+
+                            Text {
+                                id: filename
+                                Layout.alignment: Qt.AlignCenter
+                                text: model.fileCurrentlyProcessing
+                                elide: Text.ElideRight
+                                color: theme.textColor
+                                font.bold: true
+                                font.pixelSize: theme.fontSizeLarge
+                            }
+                        }
+
+                        Rectangle {
+                            visible: fileProcessingRow.visible
+                            Layout.fillWidth: true
+                            height: 1
+                            color: theme.dividerColor
+                        }
+
+                        RowLayout {
+                            Layout.fillWidth: true
+                            spacing: 30
+                            MySettingsButton {
+                                text: qsTr("Remove")
+                                textColor: theme.red500
+                                onClicked: LocalDocs.removeFolder(collection, folder_path)
+                                backgroundColor: "transparent"
+                                backgroundColorHovered: theme.lighterButtonBackgroundHoveredRed
+                            }
+                            Item {
+                                Layout.fillWidth: true
+                            }
+                            MySettingsButton {
+                                id: rebuildButton
+                                visible: !model.forceIndexing && !model.indexing && model.currentEmbeddingsToIndex === 0
+                                text: qsTr("Rebuild")
+                                textColor: theme.green500
+                                onClicked: LocalDocs.forceRebuildFolder(folder_path)
+                                toolTip: qsTr("Reindex this folder from scratch. This is slow and usually not needed.")
+                                backgroundColor: "transparent"
+                                backgroundColorHovered: theme.lighterButtonBackgroundHovered
+                            }
+                            MySettingsButton {
+                                id: updateButton
+                                visible: model.forceIndexing
+                                text: qsTr("Update")
+                                textColor: theme.green500
+                                onClicked: LocalDocs.forceIndexing(collection)
+                                toolTip: qsTr("Update the collection to the new version. This is a slow operation.")
+                                backgroundColor: "transparent"
+                                backgroundColorHovered: theme.lighterButtonBackgroundHovered
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/ModelSettings.qml

@@ -0,0 +1,845 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import modellist
+import mysettings
+import chatlistmodel
+
+MySettingsTab {
+    onRestoreDefaultsClicked: {
+        MySettings.restoreModelDefaults(root.currentModelInfo);
+    }
+    title: qsTr("Model")
+    contentItem: GridLayout {
+        id: root
+        columns: 3
+        rowSpacing: 10
+        columnSpacing: 10
+        enabled: ModelList.selectableModels.count !== 0
+
+        property var currentModelName: comboBox.currentText
+        property var currentModelId: comboBox.currentValue
+        property var currentModelInfo: ModelList.modelInfo(root.currentModelId)
+
+        Label {
+            Layout.row: 1
+            Layout.column: 0
+            Layout.bottomMargin: 10
+            color: theme.settingsTitleTextColor
+            font.pixelSize: theme.fontSizeBannerSmall
+            font.bold: true
+            text: qsTr("Model Settings")
+        }
+
+        RowLayout {
+            Layout.fillWidth: true
+            Layout.row: 2
+            Layout.column: 0
+            Layout.columnSpan: 2
+            spacing: 10
+
+            MyComboBox {
+                id: comboBox
+                Layout.fillWidth: true
+                model: ModelList.selectableModels
+                valueRole: "id"
+                textRole: "name"
+                currentIndex: {
+                    var i = comboBox.indexOfValue(ChatListModel.currentChat.modelInfo.id);
+                    if (i >= 0)
+                        return i;
+                    return 0;
+                }
+                contentItem: Text {
+                    leftPadding: 10
+                    rightPadding: 20
+                    text: comboBox.currentText
+                    font: comboBox.font
+                    color: theme.textColor
+                    verticalAlignment: Text.AlignVCenter
+                    elide: Text.ElideRight
+                }
+                delegate: ItemDelegate {
+                    width: comboBox.width -20
+                    contentItem: Text {
+                        text: name
+                        color: theme.textColor
+                        font: comboBox.font
+                        elide: Text.ElideRight
+                        verticalAlignment: Text.AlignVCenter
+                    }
+                    background: Rectangle {
+                        radius: 10
+                        color: highlighted ? theme.menuHighlightColor : theme.menuBackgroundColor
+                    }
+                    highlighted: comboBox.highlightedIndex === index
+                }
+            }
+
+            MySettingsButton {
+                id: cloneButton
+                text: qsTr("Clone")
+                onClicked: {
+                    var id = ModelList.clone(root.currentModelInfo);
+                    comboBox.currentIndex = comboBox.indexOfValue(id);
+                }
+            }
+
+            MySettingsDestructiveButton {
+                id: removeButton
+                enabled: root.currentModelInfo.isClone
+                text: qsTr("Remove")
+                onClicked: {
+                    ModelList.removeClone(root.currentModelInfo);
+                    comboBox.currentIndex = 0;
+                }
+            }
+        }
+
+        RowLayout {
+            Layout.row: 3
+            Layout.column: 0
+            Layout.topMargin: 15
+            spacing: 10
+            MySettingsLabel {
+                text: qsTr("Name")
+            }
+        }
+
+        MyTextField {
+            id: uniqueNameField
+            text: root.currentModelName
+            font.pixelSize: theme.fontSizeLarge
+            enabled: root.currentModelInfo.isClone || root.currentModelInfo.description === ""
+            Layout.row: 4
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.fillWidth: true
+            Connections {
+                target: MySettings
+                function onNameChanged() {
+                    uniqueNameField.text = root.currentModelInfo.name;
+                }
+            }
+            Connections {
+                target: root
+                function onCurrentModelInfoChanged() {
+                    uniqueNameField.text = root.currentModelInfo.name;
+                }
+            }
+            onTextChanged: {
+                if (text !== "" && ModelList.isUniqueName(text)) {
+                    MySettings.setModelName(root.currentModelInfo, text);
+                }
+            }
+        }
+
+        MySettingsLabel {
+            text: qsTr("Model File")
+            Layout.row: 5
+            Layout.column: 0
+            Layout.topMargin: 15
+        }
+
+        MyTextField {
+            text: root.currentModelInfo.filename
+            font.pixelSize: theme.fontSizeLarge
+            enabled: false
+            Layout.row: 6
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.fillWidth: true
+        }
+
+        MySettingsLabel {
+            visible: !root.currentModelInfo.isOnline
+            text: qsTr("System Prompt")
+            helpText: qsTr("Prefixed at the beginning of every conversation. Must contain the appropriate framing tokens.")
+            Layout.row: 7
+            Layout.column: 0
+            Layout.topMargin: 15
+        }
+
+        Rectangle {
+            id: systemPrompt
+            visible: !root.currentModelInfo.isOnline
+            Layout.row: 8
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.fillWidth: true
+            color: "transparent"
+            Layout.minimumHeight: Math.max(100, systemPromptArea.contentHeight + 20)
+            MyTextArea {
+                id: systemPromptArea
+                anchors.fill: parent
+                text: root.currentModelInfo.systemPrompt
+                Connections {
+                    target: MySettings
+                    function onSystemPromptChanged() {
+                        systemPromptArea.text = root.currentModelInfo.systemPrompt;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        systemPromptArea.text = root.currentModelInfo.systemPrompt;
+                    }
+                }
+                onTextChanged: {
+                    MySettings.setModelSystemPrompt(root.currentModelInfo, text)
+                }
+                Accessible.role: Accessible.EditableText
+            }
+        }
+
+        RowLayout {
+            Layout.row: 9
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.topMargin: 15
+            spacing: 10
+            MySettingsLabel {
+                id: promptTemplateLabel
+                text: qsTr("Prompt Template")
+                helpText: qsTr("The template that wraps every prompt.")
+            }
+            MySettingsLabel {
+                id: promptTemplateLabelHelp
+                text: qsTr("Must contain the string \"%1\" to be replaced with the user's input.")
+                color: theme.textErrorColor
+                visible: templateTextArea.text.indexOf("%1") === -1
+                wrapMode: TextArea.Wrap
+            }
+        }
+
+        Rectangle {
+            id: promptTemplate
+            Layout.row: 10
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.fillWidth: true
+            Layout.minimumHeight: Math.max(100, templateTextArea.contentHeight + 20)
+            color: "transparent"
+            clip: true
+            MyTextArea {
+                id: templateTextArea
+                anchors.fill: parent
+                text: root.currentModelInfo.promptTemplate
+                Connections {
+                    target: MySettings
+                    function onPromptTemplateChanged() {
+                        templateTextArea.text = root.currentModelInfo.promptTemplate;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        templateTextArea.text = root.currentModelInfo.promptTemplate;
+                    }
+                }
+                onTextChanged: {
+                    if (templateTextArea.text.indexOf("%1") !== -1) {
+                        MySettings.setModelPromptTemplate(root.currentModelInfo, text)
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: promptTemplateLabel.text
+                Accessible.description: promptTemplateLabelHelp.text
+            }
+        }
+
+        MySettingsLabel {
+            id: chatNamePromptLabel
+            text: qsTr("Chat Name Prompt")
+            helpText: qsTr("Prompt used to automatically generate chat names.")
+            Layout.row: 11
+            Layout.column: 0
+            Layout.topMargin: 15
+        }
+
+        Rectangle {
+            id: chatNamePrompt
+            Layout.row: 12
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.fillWidth: true
+            Layout.minimumHeight: Math.max(100, chatNamePromptTextArea.contentHeight + 20)
+            color: "transparent"
+            clip: true
+            MyTextArea {
+                id: chatNamePromptTextArea
+                anchors.fill: parent
+                text: root.currentModelInfo.chatNamePrompt
+                Connections {
+                    target: MySettings
+                    function onChatNamePromptChanged() {
+                        chatNamePromptTextArea.text = root.currentModelInfo.chatNamePrompt;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        chatNamePromptTextArea.text = root.currentModelInfo.chatNamePrompt;
+                    }
+                }
+                onTextChanged: {
+                    MySettings.setModelChatNamePrompt(root.currentModelInfo, text)
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: chatNamePromptLabel.text
+                Accessible.description: chatNamePromptLabel.text
+            }
+        }
+
+        MySettingsLabel {
+            id: suggestedFollowUpPromptLabel
+            text: qsTr("Suggested FollowUp Prompt")
+            helpText: qsTr("Prompt used to generate suggested follow-up questions.")
+            Layout.row: 13
+            Layout.column: 0
+            Layout.topMargin: 15
+        }
+
+        Rectangle {
+            id: suggestedFollowUpPrompt
+            Layout.row: 14
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.fillWidth: true
+            Layout.minimumHeight: Math.max(100, suggestedFollowUpPromptTextArea.contentHeight + 20)
+            color: "transparent"
+            clip: true
+            MyTextArea {
+                id: suggestedFollowUpPromptTextArea
+                anchors.fill: parent
+                text: root.currentModelInfo.suggestedFollowUpPrompt
+                Connections {
+                    target: MySettings
+                    function onSuggestedFollowUpPromptChanged() {
+                        suggestedFollowUpPromptTextArea.text = root.currentModelInfo.suggestedFollowUpPrompt;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        suggestedFollowUpPromptTextArea.text = root.currentModelInfo.suggestedFollowUpPrompt;
+                    }
+                }
+                onTextChanged: {
+                    MySettings.setModelSuggestedFollowUpPrompt(root.currentModelInfo, text)
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: suggestedFollowUpPromptLabel.text
+                Accessible.description: suggestedFollowUpPromptLabel.text
+            }
+        }
+
+        GridLayout {
+            Layout.row: 15
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.topMargin: 15
+            Layout.fillWidth: true
+            columns: 4
+            rowSpacing: 30
+            columnSpacing: 10
+
+            MySettingsLabel {
+                id: contextLengthLabel
+                visible: !root.currentModelInfo.isOnline
+                text: qsTr("Context Length")
+                helpText: qsTr("Number of input and output tokens the model sees.")
+                Layout.row: 0
+                Layout.column: 0
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            Item {
+                Layout.row: 0
+                Layout.column: 1
+                Layout.fillWidth: true
+                Layout.maximumWidth: 200
+                Layout.margins: 0
+                height: contextLengthField.height
+
+                MyTextField {
+                    id: contextLengthField
+                    anchors.left: parent.left
+                    anchors.verticalCenter: parent.verticalCenter
+                    visible: !root.currentModelInfo.isOnline
+                    text: root.currentModelInfo.contextLength
+                    font.pixelSize: theme.fontSizeLarge
+                    color: theme.textColor
+                    ToolTip.text: qsTr("Maximum combined prompt/response tokens before information is lost.\nUsing more context than the model was trained on will yield poor results.\nNOTE: Does not take effect until you reload the model.")
+                    ToolTip.visible: hovered
+                    Connections {
+                        target: MySettings
+                        function onContextLengthChanged() {
+                            contextLengthField.text = root.currentModelInfo.contextLength;
+                        }
+                    }
+                    Connections {
+                        target: root
+                        function onCurrentModelInfoChanged() {
+                            contextLengthField.text = root.currentModelInfo.contextLength;
+                        }
+                    }
+                    onEditingFinished: {
+                        var val = parseInt(text)
+                        if (isNaN(val)) {
+                            text = root.currentModelInfo.contextLength
+                        } else {
+                            if (val < 8) {
+                                val = 8
+                                contextLengthField.text = val
+                            } else if (val > root.currentModelInfo.maxContextLength) {
+                                val = root.currentModelInfo.maxContextLength
+                                contextLengthField.text = val
+                            }
+                            MySettings.setModelContextLength(root.currentModelInfo, val)
+                            focus = false
+                        }
+                    }
+                    Accessible.role: Accessible.EditableText
+                    Accessible.name: contextLengthLabel.text
+                    Accessible.description: ToolTip.text
+                }
+            }
+
+            MySettingsLabel {
+                id: tempLabel
+                text: qsTr("Temperature")
+                helpText: qsTr("Randomness of model output. Higher -> more variation.")
+                Layout.row: 1
+                Layout.column: 2
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+
+            MyTextField {
+                id: temperatureField
+                text: root.currentModelInfo.temperature
+                font.pixelSize: theme.fontSizeLarge
+                color: theme.textColor
+                ToolTip.text: qsTr("Temperature increases the chances of choosing less likely tokens.\nNOTE: Higher temperature gives more creative but less predictable outputs.")
+                ToolTip.visible: hovered
+                Layout.row: 1
+                Layout.column: 3
+                validator: DoubleValidator {
+                    locale: "C"
+                }
+                Connections {
+                    target: MySettings
+                    function onTemperatureChanged() {
+                        temperatureField.text = root.currentModelInfo.temperature;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        temperatureField.text = root.currentModelInfo.temperature;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseFloat(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelTemperature(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.temperature
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: tempLabel.text
+                Accessible.description: ToolTip.text
+            }
+            MySettingsLabel {
+                id: topPLabel
+                text: qsTr("Top-P")
+                helpText: qsTr("Nucleus Sampling factor. Lower -> more predictable.")
+                Layout.row: 2
+                Layout.column: 0
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: topPField
+                text: root.currentModelInfo.topP
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                ToolTip.text: qsTr("Only the most likely tokens up to a total probability of top_p can be chosen.\nNOTE: Prevents choosing highly unlikely tokens.")
+                ToolTip.visible: hovered
+                Layout.row: 2
+                Layout.column: 1
+                validator: DoubleValidator {
+                    locale: "C"
+                }
+                Connections {
+                    target: MySettings
+                    function onTopPChanged() {
+                        topPField.text = root.currentModelInfo.topP;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        topPField.text = root.currentModelInfo.topP;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseFloat(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelTopP(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.topP
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: topPLabel.text
+                Accessible.description: ToolTip.text
+            }
+            MySettingsLabel {
+                id: minPLabel
+                text: qsTr("Min-P")
+                helpText: qsTr("Minimum token probability. Higher -> more predictable.")
+                Layout.row: 3
+                Layout.column: 0
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: minPField
+                text: root.currentModelInfo.minP
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                ToolTip.text: qsTr("Sets the minimum relative probability for a token to be considered.")
+                ToolTip.visible: hovered
+                Layout.row: 3
+                Layout.column: 1
+                validator: DoubleValidator {
+                    locale: "C"
+                }
+                Connections {
+                    target: MySettings
+                    function onMinPChanged() {
+                        minPField.text = root.currentModelInfo.minP;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        minPField.text = root.currentModelInfo.minP;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseFloat(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelMinP(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.minP
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: minPLabel.text
+                Accessible.description: ToolTip.text
+            }
+
+            MySettingsLabel {
+                id: topKLabel
+                visible: !root.currentModelInfo.isOnline
+                text: qsTr("Top-K")
+                helpText: qsTr("Size of selection pool for tokens.")
+                Layout.row: 2
+                Layout.column: 2
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: topKField
+                visible: !root.currentModelInfo.isOnline
+                text: root.currentModelInfo.topK
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                ToolTip.text: qsTr("Only the top K most likely tokens will be chosen from.")
+                ToolTip.visible: hovered
+                Layout.row: 2
+                Layout.column: 3
+                validator: IntValidator {
+                    bottom: 1
+                }
+                Connections {
+                    target: MySettings
+                    function onTopKChanged() {
+                        topKField.text = root.currentModelInfo.topK;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        topKField.text = root.currentModelInfo.topK;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseInt(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelTopK(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.topK
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: topKLabel.text
+                Accessible.description: ToolTip.text
+            }
+            MySettingsLabel {
+                id: maxLengthLabel
+                visible: !root.currentModelInfo.isOnline
+                text: qsTr("Max Length")
+                helpText: qsTr("Maximum response length, in tokens.")
+                Layout.row: 0
+                Layout.column: 2
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: maxLengthField
+                visible: !root.currentModelInfo.isOnline
+                text: root.currentModelInfo.maxLength
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                Layout.row: 0
+                Layout.column: 3
+                validator: IntValidator {
+                    bottom: 1
+                }
+                Connections {
+                    target: MySettings
+                    function onMaxLengthChanged() {
+                        maxLengthField.text = root.currentModelInfo.maxLength;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        maxLengthField.text = root.currentModelInfo.maxLength;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseInt(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelMaxLength(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.maxLength
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: maxLengthLabel.text
+                Accessible.description: ToolTip.text
+            }
+
+            MySettingsLabel {
+                id: batchSizeLabel
+                visible: !root.currentModelInfo.isOnline
+                text: qsTr("Prompt Batch Size")
+                helpText: qsTr("The batch size used for prompt processing.")
+                Layout.row: 1
+                Layout.column: 0
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: batchSizeField
+                visible: !root.currentModelInfo.isOnline
+                text: root.currentModelInfo.promptBatchSize
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                ToolTip.text: qsTr("Amount of prompt tokens to process at once.\nNOTE: Higher values can speed up reading prompts but will use more RAM.")
+                ToolTip.visible: hovered
+                Layout.row: 1
+                Layout.column: 1
+                validator: IntValidator {
+                    bottom: 1
+                }
+                Connections {
+                    target: MySettings
+                    function onPromptBatchSizeChanged() {
+                        batchSizeField.text = root.currentModelInfo.promptBatchSize;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        batchSizeField.text = root.currentModelInfo.promptBatchSize;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseInt(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelPromptBatchSize(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.promptBatchSize
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: batchSizeLabel.text
+                Accessible.description: ToolTip.text
+            }
+            MySettingsLabel {
+                id: repeatPenaltyLabel
+                visible: !root.currentModelInfo.isOnline
+                text: qsTr("Repeat Penalty")
+                helpText: qsTr("Repetition penalty factor. Set to 1 to disable.")
+                Layout.row: 4
+                Layout.column: 2
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: repeatPenaltyField
+                visible: !root.currentModelInfo.isOnline
+                text: root.currentModelInfo.repeatPenalty
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                Layout.row: 4
+                Layout.column: 3
+                validator: DoubleValidator {
+                    locale: "C"
+                }
+                Connections {
+                    target: MySettings
+                    function onRepeatPenaltyChanged() {
+                        repeatPenaltyField.text = root.currentModelInfo.repeatPenalty;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        repeatPenaltyField.text = root.currentModelInfo.repeatPenalty;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseFloat(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelRepeatPenalty(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.repeatPenalty
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: repeatPenaltyLabel.text
+                Accessible.description: ToolTip.text
+            }
+            MySettingsLabel {
+                id: repeatPenaltyTokensLabel
+                visible: !root.currentModelInfo.isOnline
+                text: qsTr("Repeat Penalty Tokens")
+                helpText: qsTr("Number of previous tokens used for penalty.")
+                Layout.row: 3
+                Layout.column: 2
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: repeatPenaltyTokenField
+                visible: !root.currentModelInfo.isOnline
+                text: root.currentModelInfo.repeatPenaltyTokens
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                Layout.row: 3
+                Layout.column: 3
+                validator: IntValidator {
+                    bottom: 1
+                }
+                Connections {
+                    target: MySettings
+                    function onRepeatPenaltyTokensChanged() {
+                        repeatPenaltyTokenField.text = root.currentModelInfo.repeatPenaltyTokens;
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        repeatPenaltyTokenField.text = root.currentModelInfo.repeatPenaltyTokens;
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseInt(text)
+                    if (!isNaN(val)) {
+                        MySettings.setModelRepeatPenaltyTokens(root.currentModelInfo, val)
+                        focus = false
+                    } else {
+                        text = root.currentModelInfo.repeatPenaltyTokens
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: repeatPenaltyTokensLabel.text
+                Accessible.description: ToolTip.text
+            }
+
+            MySettingsLabel {
+                id: gpuLayersLabel
+                visible: !root.currentModelInfo.isOnline
+                text: qsTr("GPU Layers")
+                helpText: qsTr("Number of model layers to load into VRAM.")
+                Layout.row: 4
+                Layout.column: 0
+                Layout.maximumWidth: 300 * theme.fontScale
+            }
+            MyTextField {
+                id: gpuLayersField
+                visible: !root.currentModelInfo.isOnline
+                text: root.currentModelInfo.gpuLayers
+                font.pixelSize: theme.fontSizeLarge
+                color: theme.textColor
+                ToolTip.text: qsTr("How many model layers to load into VRAM. Decrease this if GPT4All runs out of VRAM while loading this model.\nLower values increase CPU load and RAM usage, and make inference slower.\nNOTE: Does not take effect until you reload the model.")
+                ToolTip.visible: hovered
+                Layout.row: 4
+                Layout.column: 1
+                Connections {
+                    target: MySettings
+                    function onGpuLayersChanged() {
+                        gpuLayersField.text = root.currentModelInfo.gpuLayers
+                    }
+                }
+                Connections {
+                    target: root
+                    function onCurrentModelInfoChanged() {
+                        if (root.currentModelInfo.gpuLayers === 100) {
+                            gpuLayersField.text = root.currentModelInfo.maxGpuLayers
+                        } else {
+                            gpuLayersField.text = root.currentModelInfo.gpuLayers
+                        }
+                    }
+                }
+                onEditingFinished: {
+                    var val = parseInt(text)
+                    if (isNaN(val)) {
+                        gpuLayersField.text = root.currentModelInfo.gpuLayers
+                    } else {
+                        if (val < 1) {
+                            val = 1
+                            gpuLayersField.text = val
+                        } else if (val > root.currentModelInfo.maxGpuLayers) {
+                            val = root.currentModelInfo.maxGpuLayers
+                            gpuLayersField.text = val
+                        }
+                        MySettings.setModelGpuLayers(root.currentModelInfo, val)
+                        focus = false
+                    }
+                }
+                Accessible.role: Accessible.EditableText
+                Accessible.name: gpuLayersLabel.text
+                Accessible.description: ToolTip.text
+            }
+        }
+
+        Rectangle {
+            Layout.row: 16
+            Layout.column: 0
+            Layout.columnSpan: 2
+            Layout.topMargin: 15
+            Layout.fillWidth: true
+            height: 1
+            color: theme.settingsDivider
+        }
+    }
+}

gpt4all-chat/src/qml/ModelsView.qml

@@ -0,0 +1,596 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Dialogs
+import QtQuick.Layouts
+import chatlistmodel
+import download
+import llm
+import modellist
+import network
+import mysettings
+
+Rectangle {
+    id: modelsView
+    color: theme.viewBackground
+
+    signal addModelViewRequested()
+
+    ToastManager {
+        id: messageToast
+    }
+
+    ColumnLayout {
+        anchors.fill: parent
+        anchors.margins: 20
+        spacing: 30
+
+        Item {
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            visible: ModelList.installedModels.count === 0
+            ColumnLayout {
+                id: noInstalledLabel
+                anchors.centerIn: parent
+                spacing: 0
+
+                Text {
+                    Layout.alignment: Qt.AlignCenter
+                    text: qsTr("No Models Installed")
+                    color: theme.mutedLightTextColor
+                    font.pixelSize: theme.fontSizeBannerSmall
+                }
+
+                Text {
+                    Layout.topMargin: 15
+                    horizontalAlignment: Qt.AlignHCenter
+                    color: theme.mutedLighterTextColor
+                    text: qsTr("Install a model to get started using GPT4All")
+                    font.pixelSize: theme.fontSizeLarge
+                }
+            }
+
+            MyButton {
+                anchors.top: noInstalledLabel.bottom
+                anchors.topMargin: 50
+                anchors.horizontalCenter: noInstalledLabel.horizontalCenter
+                rightPadding: 60
+                leftPadding: 60
+                text: qsTr("\uFF0B Add Model")
+                onClicked: {
+                    addModelViewRequested()
+                }
+                Accessible.role: Accessible.Button
+                Accessible.name: qsTr("Shows the add model view")
+            }
+        }
+
+        RowLayout {
+            visible: ModelList.installedModels.count !== 0
+            Layout.fillWidth: true
+            Layout.alignment: Qt.AlignTop
+            spacing: 50
+
+            ColumnLayout {
+                Layout.fillWidth: true
+                Layout.alignment: Qt.AlignLeft
+                Layout.minimumWidth: 200
+                spacing: 5
+
+                Text {
+                    id: welcome
+                    text: qsTr("Installed Models")
+                    font.pixelSize: theme.fontSizeBanner
+                    color: theme.titleTextColor
+                }
+
+                Text {
+                    text: qsTr("Locally installed chat models")
+                    font.pixelSize: theme.fontSizeLarge
+                    color: theme.titleInfoTextColor
+                }
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 0
+            }
+
+            MyButton {
+                Layout.alignment: Qt.AlignTop | Qt.AlignRight
+                text: qsTr("\uFF0B Add Model")
+                onClicked: {
+                    addModelViewRequested()
+                }
+            }
+        }
+
+        ScrollView {
+            id: scrollView
+            visible: ModelList.installedModels.count !== 0
+            ScrollBar.vertical.policy: ScrollBar.AsNeeded
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+            clip: true
+
+            ListView {
+                id: modelListView
+                model: ModelList.installedModels
+                boundsBehavior: Flickable.StopAtBounds
+                spacing: 30
+
+                delegate: Rectangle {
+                    id: delegateItem
+                    width: modelListView.width
+                    height: childrenRect.height + 60
+                    color: theme.conversationBackground
+                    radius: 10
+                    border.width: 1
+                    border.color: theme.controlBorder
+
+                    ColumnLayout {
+                        anchors.top: parent.top
+                        anchors.left: parent.left
+                        anchors.right: parent.right
+                        anchors.margins: 30
+
+                        Text {
+                            Layout.fillWidth: true
+                            Layout.alignment: Qt.AlignLeft
+                            text: name
+                            elide: Text.ElideRight
+                            color: theme.titleTextColor
+                            font.pixelSize: theme.fontSizeLargest
+                            font.bold: true
+                            Accessible.role: Accessible.Paragraph
+                            Accessible.name: qsTr("Model file")
+                            Accessible.description: qsTr("Model file to be downloaded")
+                        }
+
+                        Rectangle {
+                            Layout.fillWidth: true
+                            height: 1
+                            color: theme.dividerColor
+                        }
+
+                        RowLayout {
+                            Layout.topMargin: 10
+                            Layout.fillWidth: true
+                            Text {
+                                id: descriptionText
+                                text: description
+                                font.pixelSize: theme.fontSizeLarge
+                                Layout.fillWidth: true
+                                wrapMode: Text.WordWrap
+                                textFormat: Text.StyledText
+                                color: theme.textColor
+                                linkColor: theme.textColor
+                                Accessible.role: Accessible.Paragraph
+                                Accessible.name: qsTr("Description")
+                                Accessible.description: qsTr("File description")
+                                onLinkActivated: function(link) { Qt.openUrlExternally(link); }
+                                MouseArea {
+                                    anchors.fill: parent
+                                    acceptedButtons: Qt.NoButton // pass clicks to parent
+                                    cursorShape: parent.hoveredLink ? Qt.PointingHandCursor : Qt.ArrowCursor
+                                }
+                            }
+
+                            Rectangle {
+                                id: actionBox
+                                width: childrenRect.width + 20
+                                color: "transparent"
+                                border.width: 1
+                                border.color: theme.dividerColor
+                                radius: 10
+                                Layout.rightMargin: 20
+                                Layout.bottomMargin: 20
+                                Layout.minimumHeight: childrenRect.height + 20
+                                Layout.alignment: Qt.AlignRight | Qt.AlignTop
+
+                                ColumnLayout {
+                                    spacing: 0
+                                    MySettingsButton {
+                                        id: downloadButton
+                                        text: isDownloading ? qsTr("Cancel") : qsTr("Resume")
+                                        font.pixelSize: theme.fontSizeLarge
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        visible: (isDownloading || isIncomplete) && downloadError === "" && !isOnline && !calcHash
+                                        Accessible.description: qsTr("Stop/restart/start the download")
+                                        onClicked: {
+                                            if (!isDownloading) {
+                                                Download.downloadModel(filename);
+                                            } else {
+                                                Download.cancelDownload(filename);
+                                            }
+                                        }
+                                    }
+
+                                    MySettingsDestructiveButton {
+                                        id: removeButton
+                                        text: qsTr("Remove")
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        visible: !isDownloading && (installed || isIncomplete)
+                                        Accessible.description: qsTr("Remove model from filesystem")
+                                        onClicked: {
+                                            Download.removeModel(filename);
+                                        }
+                                    }
+
+                                    MySettingsButton {
+                                        id: installButton
+                                        visible: !installed && isOnline
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        text: qsTr("Install")
+                                        font.pixelSize: theme.fontSizeLarge
+                                        onClicked: {
+                                            var apiKeyText = apiKey.text.trim(),
+                                                baseUrlText = baseUrl.text.trim(),
+                                                modelNameText = modelName.text.trim();
+
+                                            var apiKeyOk = apiKeyText !== "",
+                                                baseUrlOk = !isCompatibleApi || baseUrlText !== "",
+                                                modelNameOk = !isCompatibleApi || modelNameText !== "";
+
+                                            if (!apiKeyOk)
+                                                apiKey.showError();
+                                            if (!baseUrlOk)
+                                                baseUrl.showError();
+                                            if (!modelNameOk)
+                                                modelName.showError();
+
+                                            if (!apiKeyOk || !baseUrlOk || !modelNameOk)
+                                                return;
+
+                                            if (!isCompatibleApi)
+                                                Download.installModel(
+                                                    filename,
+                                                    apiKeyText,
+                                                );
+                                            else
+                                                Download.installCompatibleModel(
+                                                    modelNameText,
+                                                    apiKeyText,
+                                                    baseUrlText,
+                                                );
+                                        }
+                                        Accessible.role: Accessible.Button
+                                        Accessible.name: qsTr("Install")
+                                        Accessible.description: qsTr("Install online model")
+                                    }
+
+                                    ColumnLayout {
+                                        spacing: 0
+                                        Label {
+                                            Layout.topMargin: 20
+                                            Layout.leftMargin: 20
+                                            visible: downloadError !== ""
+                                            textFormat: Text.StyledText
+                                            text: qsTr("<strong><font size=\"1\"><a href=\"#error\">Error</a></strong></font>")
+                                            color: theme.textColor
+                                            font.pixelSize: theme.fontSizeLarge
+                                            linkColor: theme.textErrorColor
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: text
+                                            Accessible.description: qsTr("Describes an error that occurred when downloading")
+                                            onLinkActivated: {
+                                                downloadingErrorPopup.text = downloadError;
+                                                downloadingErrorPopup.open();
+                                            }
+                                        }
+
+                                        Label {
+                                            visible: LLM.systemTotalRAMInGB() < ramrequired
+                                            Layout.topMargin: 20
+                                            Layout.leftMargin: 20
+                                            Layout.maximumWidth: 300
+                                            textFormat: Text.StyledText
+                                            text: qsTr("<strong><font size=\"2\">WARNING: Not recommended for your hardware. Model requires more memory (%1 GB) than your system has available (%2).</strong></font>").arg(ramrequired).arg(LLM.systemTotalRAMInGBString())
+                                            color: theme.textErrorColor
+                                            font.pixelSize: theme.fontSizeLarge
+                                            wrapMode: Text.WordWrap
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: text
+                                            Accessible.description: qsTr("Error for incompatible hardware")
+                                            onLinkActivated: {
+                                                downloadingErrorPopup.text = downloadError;
+                                                downloadingErrorPopup.open();
+                                            }
+                                        }
+                                    }
+
+                                    ColumnLayout {
+                                        visible: isDownloading && !calcHash
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        spacing: 20
+
+                                        ProgressBar {
+                                            id: itemProgressBar
+                                            Layout.fillWidth: true
+                                            width: 200
+                                            value: bytesReceived / bytesTotal
+                                            background: Rectangle {
+                                                implicitHeight: 45
+                                                color: theme.progressBackground
+                                                radius: 3
+                                            }
+                                            contentItem: Item {
+                                                implicitHeight: 40
+
+                                                Rectangle {
+                                                    width: itemProgressBar.visualPosition * parent.width
+                                                    height: parent.height
+                                                    radius: 2
+                                                    color: theme.progressForeground
+                                                }
+                                            }
+                                            Accessible.role: Accessible.ProgressBar
+                                            Accessible.name: qsTr("Download progressBar")
+                                            Accessible.description: qsTr("Shows the progress made in the download")
+                                        }
+
+                                        Label {
+                                            id: speedLabel
+                                            color: theme.textColor
+                                            Layout.alignment: Qt.AlignRight
+                                            text: speed
+                                            font.pixelSize: theme.fontSizeLarge
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: qsTr("Download speed")
+                                            Accessible.description: qsTr("Download speed in bytes/kilobytes/megabytes per second")
+                                        }
+                                    }
+
+                                    RowLayout {
+                                        visible: calcHash
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.maximumWidth: 200
+                                        Layout.fillWidth: true
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        clip: true
+
+                                        Label {
+                                            id: calcHashLabel
+                                            color: theme.textColor
+                                            text: qsTr("Calculating...")
+                                            font.pixelSize: theme.fontSizeLarge
+                                            Accessible.role: Accessible.Paragraph
+                                            Accessible.name: text
+                                            Accessible.description: qsTr("Whether the file hash is being calculated")
+                                        }
+
+                                        MyBusyIndicator {
+                                            id: busyCalcHash
+                                            running: calcHash
+                                            Accessible.role: Accessible.Animation
+                                            Accessible.name: qsTr("Busy indicator")
+                                            Accessible.description: qsTr("Displayed when the file hash is being calculated")
+                                        }
+                                    }
+
+                                    MyTextField {
+                                        id: apiKey
+                                        visible: !installed && isOnline
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        wrapMode: Text.WrapAnywhere
+                                        function showError() {
+                                            messageToast.show(qsTr("ERROR: $API_KEY is empty."));
+                                            apiKey.placeholderTextColor = theme.textErrorColor;
+                                        }
+                                        onTextChanged: {
+                                            apiKey.placeholderTextColor = theme.mutedTextColor;
+                                        }
+                                        placeholderText: qsTr("enter $API_KEY")
+                                        Accessible.role: Accessible.EditableText
+                                        Accessible.name: placeholderText
+                                        Accessible.description: qsTr("Whether the file hash is being calculated")
+                                    }
+
+                                    MyTextField {
+                                        id: baseUrl
+                                        visible: !installed && isOnline && isCompatibleApi
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        wrapMode: Text.WrapAnywhere
+                                        function showError() {
+                                            messageToast.show(qsTr("ERROR: $BASE_URL is empty."));
+                                            baseUrl.placeholderTextColor = theme.textErrorColor;
+                                        }
+                                        onTextChanged: {
+                                            baseUrl.placeholderTextColor = theme.mutedTextColor;
+                                        }
+                                        placeholderText: qsTr("enter $BASE_URL")
+                                        Accessible.role: Accessible.EditableText
+                                        Accessible.name: placeholderText
+                                        Accessible.description: qsTr("Whether the file hash is being calculated")
+                                    }
+
+                                    MyTextField {
+                                        id: modelName
+                                        visible: !installed && isOnline && isCompatibleApi
+                                        Layout.topMargin: 20
+                                        Layout.leftMargin: 20
+                                        Layout.minimumWidth: 200
+                                        Layout.alignment: Qt.AlignTop | Qt.AlignHCenter
+                                        wrapMode: Text.WrapAnywhere
+                                        function showError() {
+                                            messageToast.show(qsTr("ERROR: $MODEL_NAME is empty."))
+                                            modelName.placeholderTextColor = theme.textErrorColor;
+                                        }
+                                        onTextChanged: {
+                                            modelName.placeholderTextColor = theme.mutedTextColor;
+                                        }
+                                        placeholderText: qsTr("enter $MODEL_NAME")
+                                        Accessible.role: Accessible.EditableText
+                                        Accessible.name: placeholderText
+                                        Accessible.description: qsTr("Whether the file hash is being calculated")
+                                    }
+                                }
+                            }
+                        }
+
+                        Item  {
+                            Layout.minimumWidth: childrenRect.width
+                            Layout.minimumHeight: childrenRect.height
+                            Layout.bottomMargin: 10
+                            RowLayout {
+                                id: paramRow
+                                anchors.centerIn: parent
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("File size")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: filesize
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("RAM required")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: ramrequired >= 0 ? qsTr("%1 GB").arg(ramrequired) : qsTr("?")
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("Parameters")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: parameters !== "" ? parameters : "?"
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("Quant")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: quant
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                                Rectangle {
+                                    width: 1
+                                    Layout.fillHeight: true
+                                    color: theme.dividerColor
+                                }
+                                ColumnLayout {
+                                    Layout.topMargin: 10
+                                    Layout.bottomMargin: 10
+                                    Layout.leftMargin: 20
+                                    Layout.rightMargin: 20
+                                    Text {
+                                        text: qsTr("Type")
+                                        font.pixelSize: theme.fontSizeSmall
+                                        color: theme.mutedDarkTextColor
+                                    }
+                                    Text {
+                                        text: type
+                                        color: theme.textColor
+                                        font.pixelSize: theme.fontSizeSmall
+                                        font.bold: true
+                                    }
+                                }
+                            }
+
+                            Rectangle {
+                                color: "transparent"
+                                anchors.fill: paramRow
+                                border.color: theme.dividerColor
+                                border.width: 1
+                                radius: 10
+                            }
+                        }
+
+                        Rectangle {
+                            Layout.fillWidth: true
+                            height: 1
+                            color: theme.dividerColor
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Connections {
+        target: Download
+        function onToastMessage(message) {
+            messageToast.show(message);
+        }
+    }
+}

gpt4all-chat/src/qml/MyBusyIndicator.qml

@@ -0,0 +1,67 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+BusyIndicator {
+    id: control
+
+    property real size: 48
+    property color color: theme.accentColor
+
+    contentItem: Item {
+        implicitWidth: control.size
+        implicitHeight: control.size
+
+        Item {
+            id: item
+            x: parent.width / 2 - width / 2
+            y: parent.height / 2 - height / 2
+            width: control.size
+            height: control.size
+            opacity: control.running ? 1 : 0
+
+            Behavior on opacity {
+                OpacityAnimator {
+                    duration: 250
+                }
+            }
+
+            RotationAnimator {
+                target: item
+                running: control.visible && control.running
+                from: 0
+                to: 360
+                loops: Animation.Infinite
+                duration: 1750
+            }
+
+            Repeater {
+                id: repeater
+                model: 6
+
+                Rectangle {
+                    id: delegate
+                    x: item.width / 2 - width / 2
+                    y: item.height / 2 - height / 2
+                    implicitWidth: control.size * .2
+                    implicitHeight: control.size * .2
+                    radius: control.size * .1
+                    color: control.color
+
+                    required property int index
+
+                    transform: [
+                        Translate {
+                            y: -Math.min(item.width, item.height) * 0.5 + delegate.radius
+                        },
+                        Rotation {
+                            angle: delegate.index / repeater.count * 360
+                            origin.x: delegate.radius
+                            origin.y: delegate.radius
+                        }
+                    ]
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/MyButton.qml

@@ -0,0 +1,43 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import mysettings
+import mysettingsenums
+
+Button {
+    id: myButton
+    padding: 10
+    rightPadding: 18
+    leftPadding: 18
+    property color textColor: theme.oppositeTextColor
+    property color mutedTextColor: theme.oppositeMutedTextColor
+    property color backgroundColor: theme.buttonBackground
+    property color backgroundColorHovered: theme.buttonBackgroundHovered
+    property real  backgroundRadius: 10
+    property real  borderWidth: MySettings.chatTheme === MySettingsEnums.ChatTheme.LegacyDark ? 1 : 0
+    property color borderColor: theme.buttonBorder
+    property real  fontPixelSize: theme.fontSizeLarge
+    property bool  fontPixelBold: false
+    property alias textAlignment: textContent.horizontalAlignment
+
+    contentItem: Text {
+        id: textContent
+        text: myButton.text
+        horizontalAlignment: myButton.textAlignment
+        color: myButton.enabled ? textColor : mutedTextColor
+        font.pixelSize: fontPixelSize
+        font.bold: fontPixelBold
+        Accessible.role: Accessible.Button
+        Accessible.name: text
+    }
+    background: Rectangle {
+        radius: myButton.backgroundRadius
+        border.width: myButton.borderWidth
+        border.color: myButton.borderColor
+        color: !myButton.enabled ? theme.mutedTextColor : myButton.hovered ? backgroundColorHovered : backgroundColor
+    }
+    Accessible.role: Accessible.Button
+    Accessible.name: text
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MyCheckBox.qml

@@ -0,0 +1,42 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+CheckBox {
+    id: myCheckBox
+
+    background: Rectangle {
+        color: "transparent"
+    }
+
+    indicator: Rectangle {
+        implicitWidth: 26
+        implicitHeight: 26
+        x: myCheckBox.leftPadding
+        y: parent.height / 2 - height / 2
+        border.color: theme.checkboxBorder
+        color: "transparent"
+        radius: 3
+
+        Rectangle {
+            width: 14
+            height: 14
+            x: 6
+            y: 6
+            radius: 2
+            color: theme.checkboxForeground
+            visible: myCheckBox.checked
+        }
+    }
+
+    contentItem: Text {
+        text: myCheckBox.text
+        font: myCheckBox.font
+        opacity: enabled ? 1.0 : 0.3
+        color: theme.textColor
+        verticalAlignment: Text.AlignVCenter
+        leftPadding: myCheckBox.indicator.width + myCheckBox.spacing
+    }
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MyComboBox.qml

@@ -0,0 +1,103 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import Qt5Compat.GraphicalEffects
+
+ComboBox {
+    id: comboBox
+    font.pixelSize: theme.fontSizeLarge
+    spacing: 0
+    padding: 10
+    Accessible.role: Accessible.ComboBox
+    contentItem: RowLayout {
+        id: contentRow
+        spacing: 0
+        Text {
+            id: text
+            Layout.fillWidth: true
+            leftPadding: 10
+            rightPadding: 20
+            text: comboBox.displayText
+            font: comboBox.font
+            color: theme.textColor
+            verticalAlignment: Text.AlignLeft
+            elide: Text.ElideRight
+        }
+        Item {
+            Layout.preferredWidth: updown.width
+            Layout.preferredHeight: updown.height
+            Image {
+                id: updown
+                anchors.verticalCenter: parent.verticalCenter
+                sourceSize.width: comboBox.font.pixelSize
+                sourceSize.height: comboBox.font.pixelSize
+                mipmap: true
+                visible: false
+                source: "qrc:/gpt4all/icons/up_down.svg"
+            }
+
+            ColorOverlay {
+                anchors.fill: updown
+                source: updown
+                color: theme.textColor
+            }
+        }
+    }
+    delegate: ItemDelegate {
+        width: comboBox.width -20
+        contentItem: Text {
+            text: modelData
+            color: theme.textColor
+            font: comboBox.font
+            elide: Text.ElideRight
+            verticalAlignment: Text.AlignVCenter
+        }
+        background: Rectangle {
+            radius: 10
+            color: highlighted ? theme.menuHighlightColor : theme.menuBackgroundColor
+        }
+        highlighted: comboBox.highlightedIndex === index
+    }
+    popup: Popup {
+        // FIXME This should be made much nicer to take into account lists that are very long so
+        // that it is scrollable and also sized optimally taking into account the x,y and the content
+        // width and height as well as the window width and height
+        y: comboBox.height - 1
+        width: comboBox.width
+        implicitHeight: contentItem.implicitHeight + 20
+        padding: 0
+
+        contentItem: Rectangle {
+            implicitWidth: myListView.contentWidth
+            implicitHeight: myListView.contentHeight
+            color: "transparent"
+            ListView {
+                id: myListView
+                anchors.fill: parent
+                anchors.margins: 10
+                clip: true
+                implicitHeight: contentHeight
+                model: comboBox.popup.visible ? comboBox.delegateModel : null
+                currentIndex: comboBox.highlightedIndex
+                ScrollIndicator.vertical: ScrollIndicator { }
+            }
+        }
+
+        background: Rectangle {
+            color: theme.menuBackgroundColor//theme.controlBorder
+            border.color: theme.menuBorderColor //theme.controlBorder
+            border.width: 1
+            radius: 10
+        }
+    }
+    indicator: Item {
+    }
+    background: Rectangle {
+        color: theme.controlBackground
+        border.width: 1
+        border.color: theme.controlBorder
+        radius: 10
+    }
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MyDialog.qml

@@ -0,0 +1,48 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Dialogs
+import QtQuick.Layouts
+
+Dialog {
+    id: myDialog
+    parent: Overlay.overlay
+    property alias closeButtonVisible: myCloseButton.visible
+    background: Rectangle {
+        width: parent.width
+        height: parent.height
+        color: theme.containerBackground
+        border.width: 1
+        border.color: theme.dialogBorder
+        radius: 10
+    }
+
+    Rectangle {
+        id: closeBackground
+        visible: myCloseButton.visible
+        z: 299
+        anchors.centerIn: myCloseButton
+        width: myCloseButton.width + 10
+        height: myCloseButton.height + 10
+        color: theme.containerBackground
+    }
+
+    MyToolButton {
+        id: myCloseButton
+        x: 0 + myDialog.width - myDialog.padding - width - 15
+        y: 0 - myDialog.padding + 15
+        z: 300
+        visible: myDialog.closePolicy != Popup.NoAutoClose
+        width: 24
+        height: 24
+        imageWidth: 24
+        imageHeight: 24
+        padding: 0
+        source: "qrc:/gpt4all/icons/close.svg"
+        fillMode: Image.PreserveAspectFit
+        onClicked: {
+            myDialog.close();
+        }
+    }
+}

gpt4all-chat/src/qml/MyDirectoryField.qml

@@ -0,0 +1,20 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import llm
+
+TextField {
+    id: myDirectoryField
+    padding: 10
+    property bool isValid: LLM.directoryExists(text)
+    color: text === "" || isValid ? theme.textColor : theme.textErrorColor
+    background: Rectangle {
+        implicitWidth: 150
+        color: theme.controlBackground
+        border.width: 1
+        border.color: theme.controlBorder
+        radius: 10
+    }
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MyFancyLink.qml

@@ -0,0 +1,44 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import Qt5Compat.GraphicalEffects
+import mysettings
+
+MyButton {
+    id: fancyLink
+    property alias imageSource: myimage.source
+
+    Image {
+        id: myimage
+        anchors.verticalCenter: parent.verticalCenter
+        anchors.left: parent.left
+        anchors.leftMargin: 12
+        sourceSize: Qt.size(15, 15)
+        mipmap: true
+        visible: false
+    }
+
+    ColorOverlay {
+        anchors.fill: myimage
+        source: myimage
+        color: fancyLink.hovered ? theme.fancyLinkTextHovered : theme.fancyLinkText
+    }
+
+    borderWidth: 0
+    backgroundColor: "transparent"
+    backgroundColorHovered: "transparent"
+    fontPixelBold: true
+    leftPadding: 35
+    rightPadding: 8
+    topPadding: 1
+    bottomPadding: 1
+    textColor: fancyLink.hovered ? theme.fancyLinkTextHovered : theme.fancyLinkText
+    fontPixelSize: theme.fontSizeSmall
+    background: Rectangle {
+        color: "transparent"
+    }
+
+    Accessible.name: qsTr("Fancy link")
+    Accessible.description: qsTr("A stylized link")
+}

gpt4all-chat/src/qml/MyMenu.qml

@@ -0,0 +1,62 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+Menu {
+    id: menu
+
+    implicitWidth: Math.max(implicitBackgroundWidth + leftInset + rightInset,
+                            contentWidth + leftPadding + rightPadding + 20)
+    implicitHeight: Math.max(implicitBackgroundHeight + topInset + bottomInset,
+                             contentHeight + topPadding + bottomPadding + 20)
+
+    background: Rectangle {
+        implicitWidth: 220
+        implicitHeight: 40
+        color: theme.menuBackgroundColor
+        border.color: theme.menuBorderColor
+        border.width: 1
+        radius: 10
+    }
+
+    contentItem: Rectangle {
+        implicitWidth: myListView.contentWidth
+        implicitHeight: myListView.contentHeight
+        color: "transparent"
+        ListView {
+            id: myListView
+            anchors.margins: 10
+            anchors.fill: parent
+            implicitHeight: contentHeight
+            model: menu.contentModel
+            interactive: Window.window
+                         ? contentHeight + menu.topPadding + menu.bottomPadding > menu.height
+                         : false
+            clip: true
+            currentIndex: menu.currentIndex
+
+            ScrollIndicator.vertical: ScrollIndicator {}
+        }
+    }
+
+    enter: Transition {
+        NumberAnimation {
+            property: "opacity"
+            from: 0
+            to: 1
+            easing.type: Easing.InOutQuad
+            duration: 100
+        }
+    }
+
+    exit: Transition {
+        NumberAnimation {
+            property: "opacity"
+            from: 1
+            to: 0
+            easing.type: Easing.InOutQuad
+            duration: 100
+        }
+    }
+}

gpt4all-chat/src/qml/MyMenuItem.qml

@@ -0,0 +1,22 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+MenuItem {
+    id: item
+    background: Rectangle {
+        radius: 10
+        width: parent.width -20
+        color: item.highlighted ? theme.menuHighlightColor : theme.menuBackgroundColor
+    }
+
+    contentItem: Text {
+        leftPadding: 10
+        rightPadding: 10
+        padding: 5
+        text: item.text
+        color: theme.textColor
+        font.pixelSize: theme.fontSizeLarge
+    }
+}

gpt4all-chat/src/qml/MyMiniButton.qml

@@ -0,0 +1,48 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import Qt5Compat.GraphicalEffects
+
+Button {
+    id: myButton
+    padding: 0
+    property color backgroundColor: theme.iconBackgroundDark
+    property color backgroundColorHovered: theme.iconBackgroundHovered
+    property alias source: image.source
+    property alias fillMode: image.fillMode
+    implicitWidth: 30
+    implicitHeight: 30
+    contentItem: Text {
+        text: myButton.text
+        horizontalAlignment: Text.AlignHCenter
+        color: myButton.enabled ? theme.textColor : theme.mutedTextColor
+        font.pixelSize: theme.fontSizeLarge
+        Accessible.role: Accessible.Button
+        Accessible.name: text
+    }
+
+    background: Item {
+        anchors.fill: parent
+        Rectangle {
+            anchors.fill: parent
+            color: "transparent"
+        }
+        Image {
+            id: image
+            anchors.centerIn: parent
+            visible: false
+            mipmap: true
+            sourceSize.width: 16
+            sourceSize.height: 16
+        }
+        ColorOverlay {
+            anchors.fill: image
+            source: image
+            color: myButton.hovered ? backgroundColorHovered : backgroundColor
+        }
+    }
+    Accessible.role: Accessible.Button
+    Accessible.name: text
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MySettingsButton.qml

@@ -0,0 +1,41 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import mysettings
+
+Button {
+    id: myButton
+    padding: 10
+    rightPadding: 18
+    leftPadding: 18
+    property color  textColor: theme.lightButtonText
+    property color  mutedTextColor: theme.lightButtonMutedText
+    property color  backgroundColor: theme.lightButtonBackground
+    property color  backgroundColorHovered: enabled ? theme.lightButtonBackgroundHovered : backgroundColor
+    property real   borderWidth: 0
+    property color  borderColor: "transparent"
+    property real   fontPixelSize: theme.fontSizeLarge
+    property string toolTip
+
+    contentItem: Text {
+        text: myButton.text
+        horizontalAlignment: Text.AlignHCenter
+        color: myButton.enabled ? textColor : mutedTextColor
+        font.pixelSize: fontPixelSize
+        font.bold: true
+        Accessible.role: Accessible.Button
+        Accessible.name: text
+    }
+    background: Rectangle {
+        radius: 10
+        border.width: borderWidth
+        border.color: borderColor
+        color: myButton.hovered ? backgroundColorHovered : backgroundColor
+    }
+    Accessible.role: Accessible.Button
+    Accessible.name: text
+    ToolTip.text: toolTip
+    ToolTip.visible: toolTip !== "" && myButton.hovered
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MySettingsDestructiveButton.qml

@@ -0,0 +1,38 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import mysettings
+
+Button {
+    id: myButton
+    padding: 10
+    rightPadding: 18
+    leftPadding: 18
+    font.pixelSize: theme.fontSizeLarge
+    property color textColor: theme.darkButtonText
+    property color mutedTextColor: theme.darkButtonMutedText
+    property color backgroundColor: theme.darkButtonBackground
+    property color backgroundColorHovered: enabled ? theme.darkButtonBackgroundHovered : backgroundColor
+    property real  borderWidth: 0
+    property color borderColor: "transparent"
+
+    contentItem: Text {
+        text: myButton.text
+        horizontalAlignment: Text.AlignHCenter
+        color: myButton.enabled ? textColor : mutedTextColor
+        font.pixelSize: theme.fontSizeLarge
+        font.bold: true
+        Accessible.role: Accessible.Button
+        Accessible.name: text
+    }
+    background: Rectangle {
+        radius: 10
+        border.width: borderWidth
+        border.color: borderColor
+        color: myButton.hovered ? backgroundColorHovered : backgroundColor
+    }
+    Accessible.role: Accessible.Button
+    Accessible.name: text
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MySettingsLabel.qml

@@ -0,0 +1,48 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+
+ColumnLayout {
+    id: root
+    property alias text: mainTextLabel.text
+    property alias helpText: helpTextLabel.text
+
+    property alias textFormat: mainTextLabel.textFormat
+    property alias wrapMode: mainTextLabel.wrapMode
+    property alias font: mainTextLabel.font
+    property alias horizontalAlignment: mainTextLabel.horizontalAlignment
+    signal linkActivated(link : url);
+    property alias color: mainTextLabel.color
+    property alias linkColor: mainTextLabel.linkColor
+
+    Label {
+        id: mainTextLabel
+        color: theme.settingsTitleTextColor
+        font.pixelSize: theme.fontSizeLarger
+        font.bold: true
+        onLinkActivated: function(link) {
+            root.linkActivated(link);
+        }
+    }
+    Label {
+        id: helpTextLabel
+        visible: text !== ""
+        Layout.fillWidth: true
+        wrapMode: Text.Wrap
+        color: theme.settingsTitleTextColor
+        font.pixelSize: theme.fontSizeLarge
+        font.bold: false
+
+        onLinkActivated: function(link) {
+            root.linkActivated(link);
+        }
+
+        MouseArea {
+            anchors.fill: parent
+            acceptedButtons: Qt.NoButton // pass clicks to parent
+            cursorShape: parent.hoveredLink ? Qt.PointingHandCursor : Qt.ArrowCursor
+        }
+    }
+}

gpt4all-chat/src/qml/MySettingsStack.qml

@@ -0,0 +1,96 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import QtQuick.Dialogs
+import Qt.labs.folderlistmodel
+import mysettings
+
+Item {
+    id: settingsStack
+
+    Theme {
+        id: theme
+    }
+
+    property ListModel tabTitlesModel: ListModel { }
+    property list<Component> tabs: [ ]
+
+    TabBar {
+        id: settingsTabBar
+        anchors.top: parent.top
+        anchors.horizontalCenter: parent.horizontalCenter
+        width: parent.width / 1.75
+        z: 200
+        visible: tabTitlesModel.count > 1
+        background: Rectangle {
+            color: "transparent"
+        }
+        Repeater {
+            model: settingsStack.tabTitlesModel
+            TabButton {
+                id: tabButton
+                padding: 10
+                contentItem: IconLabel {
+                    color: theme.textColor
+                    font.pixelSize: theme.fontSizeLarge
+                    font.bold: tabButton.checked
+                    text: model.title
+                }
+                background: Rectangle {
+                    color: "transparent"
+                }
+                Accessible.role: Accessible.Button
+                Accessible.name: model.title
+            }
+        }
+    }
+
+    Rectangle {
+        id: dividerTabBar
+        visible: tabTitlesModel.count > 1
+        anchors.top: settingsTabBar.bottom
+        anchors.topMargin: 15
+        anchors.bottomMargin: 15
+        anchors.leftMargin: 15
+        anchors.rightMargin: 15
+        anchors.left: parent.left
+        anchors.right: parent.right
+        height: 1
+        color: theme.settingsDivider
+    }
+
+    FolderDialog {
+        id: folderDialog
+        title: qsTr("Please choose a directory")
+    }
+
+    function openFolderDialog(currentFolder, onAccepted) {
+        folderDialog.currentFolder = currentFolder;
+        folderDialog.accepted.connect(function() { onAccepted(folderDialog.selectedFolder); });
+        folderDialog.open();
+    }
+
+    StackLayout {
+        id: stackLayout
+        anchors.top: tabTitlesModel.count > 1 ? dividerTabBar.bottom : parent.top
+        anchors.topMargin: 5
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.bottom: parent.bottom
+        currentIndex: settingsTabBar.currentIndex
+
+        Repeater {
+            model: settingsStack.tabs
+            delegate: Loader {
+                id: loader
+                sourceComponent: model.modelData
+                onLoaded: {
+                    settingsStack.tabTitlesModel.append({ "title": loader.item.title });
+                    item.openFolderDialog = settingsStack.openFolderDialog;
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/MySettingsTab.qml

@@ -0,0 +1,74 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+
+Item {
+    id: root
+    property string title: ""
+    property Item contentItem: null
+    property bool showRestoreDefaultsButton: true
+    property var openFolderDialog
+    signal restoreDefaultsClicked
+
+    onContentItemChanged: function() {
+        if (contentItem) {
+            contentItem.parent = contentInner;
+            contentItem.anchors.left = contentInner.left;
+            contentItem.anchors.right = contentInner.right;
+        }
+    }
+
+    ScrollView {
+        id: scrollView
+        width: parent.width
+        height: parent.height
+        topPadding: 15
+        leftPadding: 5
+        contentWidth: availableWidth
+        contentHeight: innerColumn.height
+        ScrollBar.vertical: ScrollBar {
+            parent: scrollView.parent
+            anchors.top: scrollView.top
+            anchors.left: scrollView.right
+            anchors.bottom: scrollView.bottom
+        }
+
+        Theme {
+            id: theme
+        }
+
+        ColumnLayout {
+            id: innerColumn
+            anchors.left: parent.left
+            anchors.right: parent.right
+            anchors.margins: 15
+            spacing: 10
+            Column {
+                id: contentInner
+                Layout.fillWidth: true
+            }
+
+            Item {
+                Layout.fillWidth: true
+                Layout.topMargin: 20
+                height: restoreDefaultsButton.height
+                MySettingsButton {
+                    id: restoreDefaultsButton
+                    anchors.left: parent.left
+                    visible: showRestoreDefaultsButton
+                    width: implicitWidth
+                    text: qsTr("Restore Defaults")
+                    font.pixelSize: theme.fontSizeLarge
+                    Accessible.role: Accessible.Button
+                    Accessible.name: text
+                    Accessible.description: qsTr("Restores settings dialog to a default state")
+                    onClicked: {
+                        root.restoreDefaultsClicked();
+                    }
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/MySlug.qml

@@ -0,0 +1,24 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+Label {
+    id: mySlug
+    padding: 3
+    rightPadding: 9
+    leftPadding: 9
+    font.pixelSize: theme.fontSizeSmall
+    background: Rectangle {
+        radius: 6
+        border.width: 1
+        border.color: mySlug.color
+        color: theme.slugBackground
+    }
+    ToolTip.visible: ma.containsMouse && ToolTip.text !== ""
+    MouseArea {
+        id: ma
+        anchors.fill: parent
+        hoverEnabled: true
+    }
+}

gpt4all-chat/src/qml/MyTextArea.qml

@@ -0,0 +1,22 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+TextArea {
+    id: myTextArea
+    color: enabled ? theme.textColor : theme.mutedTextColor
+    placeholderTextColor: theme.mutedTextColor
+    font.pixelSize: theme.fontSizeLarge
+    background: Rectangle {
+        implicitWidth: 150
+        color: theme.controlBackground
+        border.width: 1
+        border.color: theme.controlBorder
+        radius: 10
+    }
+    padding: 10
+    wrapMode: TextArea.Wrap
+
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MyTextButton.qml

@@ -0,0 +1,19 @@
+import QtQuick
+import QtQuick.Controls
+
+Text {
+    id: text
+
+    signal click()
+    property string tooltip
+
+    HoverHandler { id: hoverHandler }
+    TapHandler { onTapped: { click() } }
+
+    font.bold: true
+    font.underline: hoverHandler.hovered
+    font.pixelSize: theme.fontSizeSmall
+    ToolTip.text: tooltip
+    ToolTip.visible: tooltip !== "" && hoverHandler.hovered
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MyTextField.qml

@@ -0,0 +1,19 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+TextField {
+    id: myTextField
+    padding: 10
+    placeholderTextColor: theme.mutedTextColor
+    background: Rectangle {
+        implicitWidth: 150
+        color: myTextField.enabled ? theme.controlBackground : theme.disabledControlBackground
+        border.width: 1
+        border.color: theme.controlBorder
+        radius: 10
+    }
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+    color: enabled ? theme.textColor : theme.mutedTextColor
+}

gpt4all-chat/src/qml/MyToolButton.qml

@@ -0,0 +1,56 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import Qt5Compat.GraphicalEffects
+
+Button {
+    id: myButton
+    padding: 10
+    property color backgroundColor: theme.iconBackgroundDark
+    property color backgroundColorHovered: theme.iconBackgroundHovered
+    property color toggledColor: theme.accentColor
+    property real toggledWidth: 1
+    property bool toggled: false
+    property alias source: image.source
+    property alias fillMode: image.fillMode
+    property alias imageWidth: image.sourceSize.width
+    property alias imageHeight: image.sourceSize.height
+    contentItem: Text {
+        text: myButton.text
+        horizontalAlignment: Text.AlignHCenter
+        color: myButton.enabled ? theme.textColor : theme.mutedTextColor
+        font.pixelSize: theme.fontSizeLarge
+        Accessible.role: Accessible.Button
+        Accessible.name: text
+    }
+
+    background: Item {
+        anchors.fill: parent
+        Rectangle {
+            anchors.fill: parent
+            color: myButton.toggledColor
+            visible: myButton.toggled
+            border.color: myButton.toggledColor
+            border.width: myButton.toggledWidth
+            radius: 8
+        }
+        Image {
+            id: image
+            anchors.centerIn: parent
+            visible: false
+            fillMode: Image.PreserveAspectFit
+            mipmap: true
+            sourceSize.width: 32
+            sourceSize.height: 32
+        }
+        ColorOverlay {
+            anchors.fill: image
+            source: image
+            color: myButton.hovered ? backgroundColorHovered : backgroundColor
+        }
+    }
+    Accessible.role: Accessible.Button
+    Accessible.name: text
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/MyWelcomeButton.qml

@@ -0,0 +1,77 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import Qt5Compat.GraphicalEffects
+import QtQuick.Layouts
+import mysettings
+
+Button {
+    id: myButton
+    property alias imageSource: myimage.source
+    property alias description: description.text
+
+    contentItem: Item {
+        id: item
+        anchors.centerIn: parent
+
+        RowLayout {
+            anchors.fill: parent
+            Rectangle {
+                id: rec
+                color: "transparent"
+                Layout.preferredWidth: item.width * 1/5.5
+                Layout.preferredHeight: item.width * 1/5.5
+                Layout.alignment: Qt.AlignCenter
+                Image {
+                    id: myimage
+                    anchors.centerIn: parent
+                    sourceSize.width: rec.width
+                    sourceSize.height: rec.height
+                    mipmap: true
+                    visible: false
+                }
+
+                ColorOverlay {
+                    anchors.fill: myimage
+                    source: myimage
+                    color: theme.welcomeButtonBorder
+                }
+            }
+
+            ColumnLayout {
+                Layout.preferredWidth: childrenRect.width
+                Text {
+                    text: myButton.text
+                    horizontalAlignment: Text.AlignHCenter
+                    color: myButton.hovered ? theme.welcomeButtonTextHovered : theme.welcomeButtonText
+                    font.pixelSize: theme.fontSizeBannerSmall
+                    font.bold: true
+                    Accessible.role: Accessible.Button
+                    Accessible.name: text
+                }
+
+                Text {
+                    id: description
+                    horizontalAlignment: Text.AlignHCenter
+                    color: myButton.hovered ? theme.welcomeButtonTextHovered : theme.welcomeButtonText
+                    font.pixelSize: theme.fontSizeSmall
+                    font.bold: false
+                    Accessible.role: Accessible.Button
+                    Accessible.name: text
+                }
+            }
+        }
+    }
+
+    background: Rectangle {
+        radius: 10
+        border.width: 1
+        border.color: myButton.hovered ? theme.welcomeButtonBorderHovered : theme.welcomeButtonBorder
+        color: theme.welcomeButtonBackground
+    }
+
+    Accessible.role: Accessible.Button
+    Accessible.name: text
+    ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
+}

gpt4all-chat/src/qml/NetworkDialog.qml

@@ -0,0 +1,109 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import download
+import network
+import llm
+import mysettings
+
+MyDialog {
+    id: networkDialog
+    anchors.centerIn: parent
+    modal: true
+    padding: 20
+
+    Theme {
+        id: theme
+    }
+
+    Column {
+        id: column
+        spacing: 20
+        Item {
+            width: childrenRect.width
+            height: childrenRect.height
+            Image {
+                id: img
+                anchors.top: parent.top
+                anchors.left: parent.left
+                width: 60
+                height: 60
+                source: "qrc:/gpt4all/icons/gpt4all.svg"
+            }
+            Text {
+                anchors.left: img.right
+                anchors.leftMargin: 30
+                anchors.verticalCenter: img.verticalCenter
+                text: qsTr("Contribute data to the GPT4All Opensource Datalake.")
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+            }
+        }
+
+        ScrollView {
+            clip: true
+            height: 300
+            width: 1024 - 40
+            ScrollBar.vertical.policy: ScrollBar.AlwaysOn
+            ScrollBar.horizontal.policy: ScrollBar.AlwaysOff
+
+            MyTextArea {
+                id: textOptIn
+                width: 1024 - 40
+                text: qsTr("By enabling this feature, you will be able to participate in the democratic process of training a large language model by contributing data for future model improvements.
+
+When a GPT4All model responds to you and you have opted-in, your conversation will be sent to the GPT4All Open Source Datalake. Additionally, you can like/dislike its response. If you dislike a response, you can suggest an alternative response. This data will be collected and aggregated in the GPT4All Datalake.
+
+NOTE: By turning on this feature, you will be sending your data to the GPT4All Open Source Datalake. You should have no expectation of chat privacy when this feature is enabled. You should; however, have an expectation of an optional attribution if you wish. Your chat data will be openly available for anyone to download and will be used by Nomic AI to improve future GPT4All models. Nomic AI will retain all attribution information attached to your data and you will be credited as a contributor to any GPT4All model release that uses your data!")
+                focus: false
+                readOnly: true
+                Accessible.role: Accessible.Paragraph
+                Accessible.name: qsTr("Terms for opt-in")
+                Accessible.description: qsTr("Describes what will happen when you opt-in")
+            }
+        }
+
+        MyTextField {
+            id: attribution
+            width: parent.width
+            text: MySettings.networkAttribution
+            placeholderText: qsTr("Please provide a name for attribution (optional)")
+            Accessible.role: Accessible.EditableText
+            Accessible.name: qsTr("Attribution (optional)")
+            Accessible.description: qsTr("Provide attribution")
+            onEditingFinished: {
+                MySettings.networkAttribution = attribution.text;
+            }
+        }
+    }
+
+    footer: DialogButtonBox {
+        id: dialogBox
+        padding: 20
+        alignment: Qt.AlignRight
+        spacing: 10
+        MySettingsButton {
+            text: qsTr("Enable")
+            Accessible.description: qsTr("Enable opt-in")
+            DialogButtonBox.buttonRole: DialogButtonBox.AcceptRole
+        }
+        MySettingsButton {
+            text: qsTr("Cancel")
+            Accessible.description: qsTr("Cancel opt-in")
+            DialogButtonBox.buttonRole: DialogButtonBox.RejectRole
+        }
+        background: Rectangle {
+            color: "transparent"
+        }
+    }
+
+    onAccepted: {
+        MySettings.networkIsActive = true
+    }
+
+    onRejected: {
+        MySettings.networkIsActive = false
+    }
+}

gpt4all-chat/src/qml/NewVersionDialog.qml

@@ -0,0 +1,55 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import download
+import network
+import llm
+
+MyDialog {
+    id: newVerionDialog
+    anchors.centerIn: parent
+    modal: true
+    width: contentItem.width
+    height: contentItem.height
+    padding: 20
+    closeButtonVisible: false
+
+    Theme {
+        id: theme
+    }
+
+    Item {
+        id: contentItem
+        width: childrenRect.width + 40
+        height: childrenRect.height + 40
+
+        Label {
+            id: label
+            anchors.top: parent.top
+            anchors.left: parent.left
+            topPadding: 20
+            bottomPadding: 20
+            text: qsTr("New version is available")
+            color: theme.titleTextColor
+            font.pixelSize: theme.fontSizeLarge
+            font.bold: true
+        }
+
+        MySettingsButton {
+            id: button
+            anchors.left: label.right
+            anchors.leftMargin: 10
+            anchors.verticalCenter: label.verticalCenter
+            padding: 20
+            text: qsTr("Update")
+            font.pixelSize: theme.fontSizeLarge
+            Accessible.description: qsTr("Update to new version")
+            onClicked: {
+                if (!LLM.checkForUpdates())
+                    checkForUpdatesError.open()
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/PopupDialog.qml

@@ -0,0 +1,75 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+
+Dialog {
+    id: popupDialog
+    anchors.centerIn: parent
+    padding: 20
+    property alias text: textField.text
+    property bool shouldTimeOut: true
+    property bool shouldShowBusy: false
+    modal: shouldShowBusy
+    closePolicy: shouldShowBusy ? Popup.NoAutoClose : (Popup.CloseOnEscape | Popup.CloseOnPressOutside)
+
+    Theme {
+        id: theme
+    }
+
+    Row {
+        anchors.centerIn: parent
+        spacing: 20
+
+        Label {
+            id: textField
+            width: Math.min(1024, implicitWidth)
+            height: Math.min(600, implicitHeight)
+            anchors.verticalCenter: shouldShowBusy ? busyIndicator.verticalCenter : parent.verticalCenter
+            horizontalAlignment: Text.AlignLeft
+            verticalAlignment: Text.AlignVCenter
+            textFormat: Text.StyledText
+            wrapMode: Text.WordWrap
+            color: theme.textColor
+            linkColor: theme.linkColor
+            Accessible.role: Accessible.HelpBalloon
+            Accessible.name: text
+            Accessible.description: qsTr("Reveals a shortlived help balloon")
+            onLinkActivated: function(link) { Qt.openUrlExternally(link) }
+        }
+
+        MyBusyIndicator {
+            id: busyIndicator
+            visible: shouldShowBusy
+            running: shouldShowBusy
+
+            Accessible.role: Accessible.Animation
+            Accessible.name: qsTr("Busy indicator")
+            Accessible.description: qsTr("Displayed when the popup is showing busy")
+        }
+    }
+
+    background: Rectangle {
+        anchors.fill: parent
+        color: theme.containerBackground
+        border.width: 1
+        border.color: theme.dialogBorder
+        radius: 10
+    }
+
+    exit: Transition {
+        NumberAnimation { duration: 500; property: "opacity"; from: 1.0; to: 0.0 }
+    }
+
+    onOpened: {
+        if (shouldTimeOut)
+            timer.start()
+    }
+
+    Timer {
+        id: timer
+        interval: 500; running: false; repeat: false
+        onTriggered: popupDialog.close()
+    }
+}

gpt4all-chat/src/qml/SettingsView.qml

@@ -0,0 +1,158 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Dialogs
+import QtQuick.Layouts
+import Qt.labs.folderlistmodel
+import download
+import modellist
+import network
+import llm
+import mysettings
+
+Rectangle {
+    id: settingsDialog
+    color: theme.viewBackground
+
+    property alias pageToDisplay: listView.currentIndex
+
+    Item {
+        Accessible.role: Accessible.Dialog
+        Accessible.name: qsTr("Settings")
+        Accessible.description: qsTr("Contains various application settings")
+    }
+
+    ListModel {
+        id: stacksModel
+        ListElement {
+            title: qsTr("Application")
+        }
+        ListElement {
+            title: qsTr("Model")
+        }
+        ListElement {
+            title: qsTr("LocalDocs")
+        }
+    }
+
+    ColumnLayout {
+        id: mainArea
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.top: parent.top
+        anchors.bottom: parent.bottom
+        anchors.margins: 30
+        spacing: 50
+
+        RowLayout {
+            Layout.fillWidth: true
+            Layout.alignment: Qt.AlignTop
+            spacing: 50
+
+            ColumnLayout {
+                Layout.fillWidth: true
+                Layout.alignment: Qt.AlignLeft
+                Layout.minimumWidth: 200
+                spacing: 5
+
+                Text {
+                    id: welcome
+                    text: qsTr("Settings")
+                    font.pixelSize: theme.fontSizeBanner
+                    color: theme.titleTextColor
+                }
+            }
+
+            Rectangle {
+                Layout.fillWidth: true
+                height: 0
+            }
+        }
+
+        Item {
+            Layout.fillWidth: true
+            Layout.fillHeight: true
+
+            Rectangle {
+                id: stackList
+                anchors.top: parent.top
+                anchors.bottom: parent.bottom
+                anchors.left: parent.left
+                width: 220
+                color: theme.viewBackground
+                radius: 10
+
+                ScrollView {
+                    anchors.top: parent.top
+                    anchors.bottom: parent.bottom
+                    anchors.left: parent.left
+                    anchors.right: parent.right
+                    anchors.topMargin: 10
+                    ScrollBar.vertical.policy: ScrollBar.AsNeeded
+                    clip: true
+
+                    ListView {
+                        id: listView
+                        anchors.fill: parent
+                        model: stacksModel
+
+                        delegate: Rectangle {
+                            id: item
+                            width: listView.width
+                            height: titleLabel.height + 10
+                            color: "transparent"
+
+                            MyButton {
+                                id: titleLabel
+                                backgroundColor: index === listView.currentIndex ? theme.selectedBackground : theme.viewBackground
+                                backgroundColorHovered: backgroundColor
+                                borderColor: "transparent"
+                                borderWidth: 0
+                                textColor: theme.titleTextColor
+                                anchors.verticalCenter: parent.verticalCenter
+                                anchors.left: parent.left
+                                anchors.right: parent.right
+                                anchors.margins: 10
+                                font.bold: index === listView.currentIndex
+                                text: title
+                                textAlignment: Qt.AlignLeft
+                                font.pixelSize: theme.fontSizeLarge
+                                onClicked: {
+                                    listView.currentIndex = index
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            StackLayout {
+                id: stackLayout
+                anchors.top: parent.top
+                anchors.bottom: parent.bottom
+                anchors.left: stackList.right
+                anchors.right: parent.right
+                currentIndex: listView.currentIndex
+
+                MySettingsStack {
+                    tabs: [
+                        Component { ApplicationSettings { } }
+                    ]
+                }
+
+                MySettingsStack {
+                    tabs: [
+                        Component { ModelSettings { } }
+                    ]
+                }
+
+                MySettingsStack {
+                    tabs: [
+                        Component { LocalDocsSettings { } }
+                    ]
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/StartupDialog.qml

@@ -0,0 +1,346 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import Qt5Compat.GraphicalEffects
+import download
+import network
+import llm
+import mysettings
+
+MyDialog {
+    id: startupDialog
+    anchors.centerIn: parent
+    modal: true
+    padding: 10
+    width: 1024
+    height: column.height + 20
+    closePolicy: !optInStatisticsRadio.choiceMade || !optInNetworkRadio.choiceMade ? Popup.NoAutoClose : (Popup.CloseOnEscape | Popup.CloseOnPressOutside)
+
+    Theme {
+        id: theme
+    }
+
+    Column {
+        id: column
+        spacing: 20
+        Item {
+            width: childrenRect.width
+            height: childrenRect.height
+            Image {
+                id: img
+                anchors.top: parent.top
+                anchors.left: parent.left
+                sourceSize.width: 60
+                sourceSize.height: 60
+                mipmap: true
+                visible: false
+                source: "qrc:/gpt4all/icons/globe.svg"
+            }
+            ColorOverlay {
+                anchors.fill: img
+                source: img
+                color: theme.titleTextColor
+            }
+            Text {
+                anchors.left: img.right
+                anchors.leftMargin: 10
+                anchors.verticalCenter: img.verticalCenter
+                text: qsTr("Welcome!")
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+            }
+        }
+
+        ScrollView {
+            clip: true
+            height: 200
+            width: 1024 - 40
+            ScrollBar.vertical.policy: ScrollBar.AlwaysOn
+            ScrollBar.horizontal.policy: ScrollBar.AlwaysOff
+
+            MyTextArea {
+                id: welcome
+                width: 1024 - 40
+                textFormat: TextEdit.MarkdownText
+                text: qsTr("### Release notes\n%1### Contributors\n%2").arg(Download.releaseInfo.notes).arg(Download.releaseInfo.contributors)
+                focus: false
+                readOnly: true
+                Accessible.role: Accessible.Paragraph
+                Accessible.name: qsTr("Release notes")
+                Accessible.description: qsTr("Release notes for this version")
+            }
+        }
+
+        ScrollView {
+            clip: true
+            height: 150
+            width: 1024 - 40
+            ScrollBar.vertical.policy: ScrollBar.AlwaysOn
+            ScrollBar.horizontal.policy: ScrollBar.AlwaysOff
+
+            MyTextArea {
+                id: optInTerms
+                width: 1024 - 40
+                textFormat: TextEdit.MarkdownText
+                text: qsTr(
+"### Opt-ins for anonymous usage analytics and datalake
+By enabling these features, you will be able to participate in the democratic process of training a
+large language model by contributing data for future model improvements.
+
+When a GPT4All model responds to you and you have opted-in, your conversation will be sent to the GPT4All
+Open Source Datalake. Additionally, you can like/dislike its response. If you dislike a response, you
+can suggest an alternative response. This data will be collected and aggregated in the GPT4All Datalake.
+
+NOTE: By turning on this feature, you will be sending your data to the GPT4All Open Source Datalake.
+You should have no expectation of chat privacy when this feature is enabled. You should; however, have
+an expectation of an optional attribution if you wish. Your chat data will be openly available for anyone
+to download and will be used by Nomic AI to improve future GPT4All models. Nomic AI will retain all
+attribution information attached to your data and you will be credited as a contributor to any GPT4All
+model release that uses your data!")
+
+                focus: false
+                readOnly: true
+                Accessible.role: Accessible.Paragraph
+                Accessible.name: qsTr("Terms for opt-in")
+                Accessible.description: qsTr("Describes what will happen when you opt-in")
+            }
+        }
+
+        GridLayout {
+            columns: 2
+            rowSpacing: 10
+            columnSpacing: 10
+            anchors.right: parent.right
+            Label {
+                id: optInStatistics
+                text: "Opt-in to anonymous usage analytics used to improve GPT4All"
+                Layout.row: 0
+                Layout.column: 0
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                Accessible.role: Accessible.Paragraph
+                Accessible.name: qsTr("Opt-in for anonymous usage statistics")
+            }
+
+            ButtonGroup {
+                buttons: optInStatisticsRadio.children
+                onClicked: {
+                    MySettings.networkUsageStatsActive = optInStatisticsRadio.checked
+                    if (optInNetworkRadio.choiceMade && optInStatisticsRadio.choiceMade)
+                        startupDialog.close();
+                }
+            }
+
+            RowLayout {
+                id: optInStatisticsRadio
+                Layout.alignment: Qt.AlignVCenter
+                Layout.row: 0
+                Layout.column: 1
+                property alias checked: optInStatisticsRadioYes.checked
+                property bool choiceMade: optInStatisticsRadioYes.checked || optInStatisticsRadioNo.checked
+
+                RadioButton {
+                    id: optInStatisticsRadioYes
+                    checked: MySettings.networkUsageStatsActive
+                    text: qsTr("Yes")
+                    font.pixelSize: theme.fontSizeLarge
+                    Accessible.role: Accessible.RadioButton
+                    Accessible.name: qsTr("Opt-in for anonymous usage statistics")
+                    Accessible.description: qsTr("Allow opt-in for anonymous usage statistics")
+
+                    background: Rectangle {
+                        color: "transparent"
+                    }
+
+                    indicator: Rectangle {
+                        implicitWidth: 26
+                        implicitHeight: 26
+                        x: optInStatisticsRadioYes.leftPadding
+                        y: parent.height / 2 - height / 2
+                        radius: 13
+                        border.color: theme.dialogBorder
+                        color: "transparent"
+
+                        Rectangle {
+                            width: 14
+                            height: 14
+                            x: 6
+                            y: 6
+                            radius: 7
+                            color: theme.textColor
+                            visible: optInStatisticsRadioYes.checked
+                        }
+                    }
+
+                    contentItem: Text {
+                        text: optInStatisticsRadioYes.text
+                        font: optInStatisticsRadioYes.font
+                        opacity: enabled ? 1.0 : 0.3
+                        color: theme.textColor
+                        verticalAlignment: Text.AlignVCenter
+                        leftPadding: optInStatisticsRadioYes.indicator.width + optInStatisticsRadioYes.spacing
+                    }
+                }
+                RadioButton {
+                    id: optInStatisticsRadioNo
+                    checked: MySettings.isNetworkUsageStatsActiveSet() && !MySettings.networkUsageStatsActive
+                    text: qsTr("No")
+                    font.pixelSize: theme.fontSizeLarge
+                    Accessible.role: Accessible.RadioButton
+                    Accessible.name: qsTr("Opt-out for anonymous usage statistics")
+                    Accessible.description: qsTr("Allow opt-out for anonymous usage statistics")
+
+                    background: Rectangle {
+                        color: "transparent"
+                    }
+
+                    indicator: Rectangle {
+                        implicitWidth: 26
+                        implicitHeight: 26
+                        x: optInStatisticsRadioNo.leftPadding
+                        y: parent.height / 2 - height / 2
+                        radius: 13
+                        border.color: theme.dialogBorder
+                        color: "transparent"
+
+                        Rectangle {
+                            width: 14
+                            height: 14
+                            x: 6
+                            y: 6
+                            radius: 7
+                            color: theme.textColor
+                            visible: optInStatisticsRadioNo.checked
+                        }
+                    }
+
+                    contentItem: Text {
+                        text: optInStatisticsRadioNo.text
+                        font: optInStatisticsRadioNo.font
+                        opacity: enabled ? 1.0 : 0.3
+                        color: theme.textColor
+                        verticalAlignment: Text.AlignVCenter
+                        leftPadding: optInStatisticsRadioNo.indicator.width + optInStatisticsRadioNo.spacing
+                    }
+                }
+            }
+
+            Label {
+                id: optInNetwork
+                text: "Opt-in to anonymous sharing of chats to the GPT4All Datalake"
+                Layout.row: 1
+                Layout.column: 0
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+                Accessible.role: Accessible.Paragraph
+                Accessible.name: qsTr("Opt-in for network")
+                Accessible.description: qsTr("Allow opt-in for network")
+            }
+
+            ButtonGroup {
+                buttons: optInNetworkRadio.children
+                onClicked: {
+                    MySettings.networkIsActive = optInNetworkRadio.checked
+                    if (optInNetworkRadio.choiceMade && optInStatisticsRadio.choiceMade)
+                        startupDialog.close();
+                }
+            }
+
+            RowLayout {
+                id: optInNetworkRadio
+                Layout.alignment: Qt.AlignVCenter
+                Layout.row: 1
+                Layout.column: 1
+                property alias checked: optInNetworkRadioYes.checked
+                property bool choiceMade: optInNetworkRadioYes.checked || optInNetworkRadioNo.checked
+
+                RadioButton {
+                    id: optInNetworkRadioYes
+                    checked: MySettings.networkIsActive
+                    text: qsTr("Yes")
+                    font.pixelSize: theme.fontSizeLarge
+                    Accessible.role: Accessible.RadioButton
+                    Accessible.name: qsTr("Opt-in for network")
+                    Accessible.description: qsTr("Allow opt-in anonymous sharing of chats to the GPT4All Datalake")
+
+                    background: Rectangle {
+                        color: "transparent"
+                    }
+
+                    indicator: Rectangle {
+                        implicitWidth: 26
+                        implicitHeight: 26
+                        x: optInNetworkRadioYes.leftPadding
+                        y: parent.height / 2 - height / 2
+                        radius: 13
+                        border.color: theme.dialogBorder
+                        color: "transparent"
+
+                        Rectangle {
+                            width: 14
+                            height: 14
+                            x: 6
+                            y: 6
+                            radius: 7
+                            color: theme.textColor
+                            visible: optInNetworkRadioYes.checked
+                        }
+                    }
+
+                    contentItem: Text {
+                        text: optInNetworkRadioYes.text
+                        font: optInNetworkRadioYes.font
+                        opacity: enabled ? 1.0 : 0.3
+                        color: theme.textColor
+                        verticalAlignment: Text.AlignVCenter
+                        leftPadding: optInNetworkRadioYes.indicator.width + optInNetworkRadioYes.spacing
+                    }
+                }
+                RadioButton {
+                    id: optInNetworkRadioNo
+                    checked: MySettings.isNetworkIsActiveSet() && !MySettings.networkIsActive
+                    text: qsTr("No")
+                    font.pixelSize: theme.fontSizeLarge
+                    Accessible.role: Accessible.RadioButton
+                    Accessible.name: qsTr("Opt-out for network")
+                    Accessible.description: qsTr("Allow opt-out anonymous sharing of chats to the GPT4All Datalake")
+
+                    background: Rectangle {
+                        color: "transparent"
+                    }
+
+                    indicator: Rectangle {
+                        implicitWidth: 26
+                        implicitHeight: 26
+                        x: optInNetworkRadioNo.leftPadding
+                        y: parent.height / 2 - height / 2
+                        radius: 13
+                        border.color: theme.dialogBorder
+                        color: "transparent"
+
+                        Rectangle {
+                            width: 14
+                            height: 14
+                            x: 6
+                            y: 6
+                            radius: 7
+                            color: theme.textColor
+                            visible: optInNetworkRadioNo.checked
+                        }
+                    }
+
+                    contentItem: Text {
+                        text: optInNetworkRadioNo.text
+                        font: optInNetworkRadioNo.font
+                        opacity: enabled ? 1.0 : 0.3
+                        color: theme.textColor
+                        verticalAlignment: Text.AlignVCenter
+                        leftPadding: optInNetworkRadioNo.indicator.width + optInNetworkRadioNo.spacing
+                    }
+                }
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/SwitchModelDialog.qml

@@ -0,0 +1,46 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import llm
+import mysettings
+
+MyDialog {
+    id: switchModelDialog
+    anchors.centerIn: parent
+    modal: true
+    padding: 20
+    property int index: -1
+
+    Theme {
+        id: theme
+    }
+
+    contentItem: Text {
+        textFormat: Text.StyledText
+        text: qsTr("<b>Warning:</b> changing the model will erase the current conversation. Do you wish to continue?")
+        color: theme.textColor
+        font.pixelSize: theme.fontSizeLarge
+    }
+
+    footer: DialogButtonBox {
+        id: dialogBox
+        padding: 20
+        alignment: Qt.AlignRight
+        spacing: 10
+        MySettingsButton {
+            text: qsTr("Continue")
+            Accessible.description: qsTr("Continue with model loading")
+            DialogButtonBox.buttonRole: DialogButtonBox.AcceptRole
+        }
+        MySettingsButton {
+            text: qsTr("Cancel")
+            Accessible.description: qsTr("Cancel")
+            DialogButtonBox.buttonRole: DialogButtonBox.RejectRole
+        }
+        background: Rectangle {
+            color: "transparent"
+        }
+    }
+}

gpt4all-chat/src/qml/ThumbsDownDialog.qml

@@ -0,0 +1,77 @@
+import QtCore
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+import QtQuick.Layouts
+import download
+import network
+import llm
+
+MyDialog {
+    id: thumbsDownDialog
+    modal: true
+    padding: 20
+
+    Theme {
+        id: theme
+    }
+
+    property alias response: thumbsDownNewResponse.text
+
+    Column {
+        anchors.fill: parent
+        spacing: 20
+        Item {
+            width: childrenRect.width
+            height: childrenRect.height
+            Image {
+                id: img
+                anchors.top: parent.top
+                anchors.left: parent.left
+                width: 60
+                height: 60
+                source: "qrc:/gpt4all/icons/thumbs_down.svg"
+            }
+            Text {
+                anchors.left: img.right
+                anchors.leftMargin: 30
+                anchors.verticalCenter: img.verticalCenter
+                text: qsTr("Please edit the text below to provide a better response. (optional)")
+                color: theme.textColor
+                font.pixelSize: theme.fontSizeLarge
+            }
+        }
+
+        ScrollView {
+            clip: true
+            height: 120
+            width: parent.width
+            ScrollBar.vertical.policy: ScrollBar.AsNeeded
+            ScrollBar.horizontal.policy: ScrollBar.AlwaysOff
+
+            MyTextArea {
+                id: thumbsDownNewResponse
+                placeholderText: qsTr("Please provide a better response...")
+            }
+        }
+    }
+
+    footer: DialogButtonBox {
+        padding: 20
+        alignment: Qt.AlignRight
+        spacing: 10
+        MySettingsButton {
+            text: qsTr("Submit")
+            Accessible.description: qsTr("Submits the user's response")
+            DialogButtonBox.buttonRole: DialogButtonBox.AcceptRole
+        }
+        MySettingsButton {
+            text: qsTr("Cancel")
+            Accessible.description: qsTr("Closes the response dialog")
+            DialogButtonBox.buttonRole: DialogButtonBox.RejectRole
+        }
+        background: Rectangle {
+            color: "transparent"
+        }
+    }
+}

gpt4all-chat/src/qml/Toast.qml

@@ -0,0 +1,98 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Source: https://gist.github.com/jonmcclung/bae669101d17b103e94790341301c129
+ * Adapted from StackOverflow: http://stackoverflow.com/questions/26879266/make-toast-in-android-by-qml
+ */
+
+import QtQuick 2.0
+
+/**
+  * @brief An Android-like timed message text in a box that self-destroys when finished if desired
+  */
+Rectangle {
+    /**
+      * Public
+      */
+
+    /**
+      * @brief Shows this Toast
+      *
+      * @param {string} text Text to show
+      * @param {real} duration Duration to show in milliseconds, defaults to 3000
+      */
+    function show(text, duration=3000) {
+        message.text = text;
+        if (typeof duration !== "undefined") { // checks if parameter was passed
+            time = Math.max(duration, 2 * fadeTime);
+        }
+        else {
+            time = defaultTime;
+        }
+        animation.start();
+    }
+
+    property bool selfDestroying: false  // whether this Toast will self-destroy when it is finished
+
+    /**
+      * Private
+      */
+
+    id: root
+
+    readonly property real defaultTime: 3000
+    property real time: defaultTime
+    readonly property real fadeTime: 300
+
+    property real margin: 10
+
+    anchors {
+        left: parent.left
+        right: parent.right
+        margins: margin
+    }
+
+    height: message.height + margin
+    radius: margin
+
+    opacity: 0
+    color: "#222222"
+
+    Text {
+        id: message
+        color: "white"
+        wrapMode: Text.Wrap
+        horizontalAlignment: Text.AlignHCenter
+        anchors {
+            top: parent.top
+            left: parent.left
+            right: parent.right
+            margins: margin / 2
+        }
+    }
+
+    SequentialAnimation on opacity {
+        id: animation
+        running: false
+
+
+        NumberAnimation {
+            to: .9
+            duration: fadeTime
+        }
+
+        PauseAnimation {
+            duration: time - 2 * fadeTime
+        }
+
+        NumberAnimation {
+            to: 0
+            duration: fadeTime
+        }
+
+        onRunningChanged: {
+            if (!running && selfDestroying) {
+                root.destroy();
+            }
+        }
+    }
+}

gpt4all-chat/src/qml/ToastManager.qml

@@ -0,0 +1,60 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * Source: https://gist.github.com/jonmcclung/bae669101d17b103e94790341301c129
+ * Adapted from StackOverflow: http://stackoverflow.com/questions/26879266/make-toast-in-android-by-qml
+ */
+
+import QtQuick 2.0
+
+/**
+  * @brief Manager that creates Toasts dynamically
+  */
+ListView {
+    /**
+      * Public
+      */
+
+    /**
+      * @brief Shows a Toast
+      *
+      * @param {string} text Text to show
+      * @param {real} duration Duration to show in milliseconds, defaults to 3000
+      */
+    function show(text, duration=3000) {
+        model.insert(0, {text: text, duration: duration});
+    }
+
+    /**
+      * Private
+      */
+
+    id: root
+
+    z: Infinity
+    spacing: 5
+    anchors.fill: parent
+    anchors.bottomMargin: 10
+    verticalLayoutDirection: ListView.BottomToTop
+
+    interactive: false
+
+    displaced: Transition {
+        NumberAnimation {
+            properties: "y"
+            easing.type: Easing.InOutQuad
+        }
+    }
+    
+    delegate: Toast {
+        Component.onCompleted: {
+            if (typeof duration === "undefined") {
+                show(text);
+            }
+            else {
+                show(text, duration);
+            }
+        }
+    }
+
+    model: ListModel {id: model}
+}

gpt4all-chat/src/server.cpp

@@ -0,0 +1,468 @@
+#include "server.h"
+
+#include "chat.h"
+#include "modellist.h"
+#include "mysettings.h"
+
+#include <QByteArray>
+#include <QDateTime>
+#include <QDebug>
+#include <QHostAddress>
+#include <QHttpServer>
+#include <QHttpServerResponder>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QPair>
+#include <Qt>
+#include <QtLogging>
+
+#include <iostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+using namespace Qt::Literals::StringLiterals;
+
+//#define DEBUG
+
+static inline QJsonObject modelToJson(const ModelInfo &info)
+{
+    QJsonObject model;
+    model.insert("id", info.name());
+    model.insert("object", "model");
+    model.insert("created", 0);
+    model.insert("owned_by", "humanity");
+    model.insert("root", info.name());
+    model.insert("parent", QJsonValue::Null);
+
+    QJsonArray permissions;
+    QJsonObject permissionObj;
+    permissionObj.insert("id", "foobarbaz");
+    permissionObj.insert("object", "model_permission");
+    permissionObj.insert("created", 0);
+    permissionObj.insert("allow_create_engine", false);
+    permissionObj.insert("allow_sampling", false);
+    permissionObj.insert("allow_logprobs", false);
+    permissionObj.insert("allow_search_indices", false);
+    permissionObj.insert("allow_view", true);
+    permissionObj.insert("allow_fine_tuning", false);
+    permissionObj.insert("organization", "*");
+    permissionObj.insert("group", QJsonValue::Null);
+    permissionObj.insert("is_blocking", false);
+    permissions.append(permissionObj);
+    model.insert("permissions", permissions);
+    return model;
+}
+
+static inline QJsonObject resultToJson(const ResultInfo &info)
+{
+    QJsonObject result;
+    result.insert("file", info.file);
+    result.insert("title", info.title);
+    result.insert("author", info.author);
+    result.insert("date", info.date);
+    result.insert("text", info.text);
+    result.insert("page", info.page);
+    result.insert("from", info.from);
+    result.insert("to", info.to);
+    return result;
+}
+
+Server::Server(Chat *chat)
+    : ChatLLM(chat, true /*isServer*/)
+    , m_chat(chat)
+    , m_server(nullptr)
+{
+    connect(this, &Server::threadStarted, this, &Server::start);
+    connect(this, &Server::databaseResultsChanged, this, &Server::handleDatabaseResultsChanged);
+    connect(chat, &Chat::collectionListChanged, this, &Server::handleCollectionListChanged, Qt::QueuedConnection);
+}
+
+Server::~Server()
+{
+}
+
+void Server::start()
+{
+    m_server = new QHttpServer(this);
+    if (!m_server->listen(QHostAddress::LocalHost, MySettings::globalInstance()->networkPort())) {
+        qWarning() << "ERROR: Unable to start the server";
+        return;
+    }
+
+    m_server->route("/v1/models", QHttpServerRequest::Method::Get,
+        [](const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+
+            const QList<ModelInfo> modelList = ModelList::globalInstance()->selectableModelList();
+            QJsonObject root;
+            root.insert("object", "list");
+            QJsonArray data;
+            for (const ModelInfo &info : modelList) {
+                Q_ASSERT(info.installed);
+                if (!info.installed)
+                    continue;
+                data.append(modelToJson(info));
+            }
+            root.insert("data", data);
+            return QHttpServerResponse(root);
+        }
+    );
+
+    m_server->route("/v1/models/<arg>", QHttpServerRequest::Method::Get,
+        [](const QString &model, const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+
+            const QList<ModelInfo> modelList = ModelList::globalInstance()->selectableModelList();
+            QJsonObject object;
+            for (const ModelInfo &info : modelList) {
+                Q_ASSERT(info.installed);
+                if (!info.installed)
+                    continue;
+
+                if (model == info.name()) {
+                    object = modelToJson(info);
+                    break;
+                }
+            }
+            return QHttpServerResponse(object);
+        }
+    );
+
+    m_server->route("/v1/completions", QHttpServerRequest::Method::Post,
+        [this](const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+            return handleCompletionRequest(request, false);
+        }
+    );
+
+    m_server->route("/v1/chat/completions", QHttpServerRequest::Method::Post,
+        [this](const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+            return handleCompletionRequest(request, true);
+        }
+    );
+
+    // Respond with code 405 to wrong HTTP methods:
+    m_server->route("/v1/models",  QHttpServerRequest::Method::Post,
+        [](const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+            return QHttpServerResponse(
+                QJsonDocument::fromJson("{\"error\": {\"message\": \"Not allowed to POST on /v1/models."
+                    " (HINT: Perhaps you meant to use a different HTTP method?)\","
+                    " \"type\": \"invalid_request_error\", \"param\": null, \"code\": null}}").object(),
+                QHttpServerResponder::StatusCode::MethodNotAllowed);
+        }
+    );
+
+    m_server->route("/v1/models/<arg>", QHttpServerRequest::Method::Post,
+        [](const QString &model, const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+            return QHttpServerResponse(
+                QJsonDocument::fromJson("{\"error\": {\"message\": \"Not allowed to POST on /v1/models/*."
+                    " (HINT: Perhaps you meant to use a different HTTP method?)\","
+                    " \"type\": \"invalid_request_error\", \"param\": null, \"code\": null}}").object(),
+                QHttpServerResponder::StatusCode::MethodNotAllowed);
+        }
+    );
+
+    m_server->route("/v1/completions", QHttpServerRequest::Method::Get,
+        [](const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+            return QHttpServerResponse(
+                QJsonDocument::fromJson("{\"error\": {\"message\": \"Only POST requests are accepted.\","
+                    " \"type\": \"invalid_request_error\", \"param\": null, \"code\": \"method_not_supported\"}}").object(),
+                QHttpServerResponder::StatusCode::MethodNotAllowed);
+        }
+    );
+
+    m_server->route("/v1/chat/completions", QHttpServerRequest::Method::Get,
+        [](const QHttpServerRequest &request) {
+            if (!MySettings::globalInstance()->serverChat())
+                return QHttpServerResponse(QHttpServerResponder::StatusCode::Unauthorized);
+            return QHttpServerResponse(
+                QJsonDocument::fromJson("{\"error\": {\"message\": \"Only POST requests are accepted.\","
+                    " \"type\": \"invalid_request_error\", \"param\": null, \"code\": \"method_not_supported\"}}").object(),
+                QHttpServerResponder::StatusCode::MethodNotAllowed);
+        }
+    );
+
+    m_server->afterRequest([] (QHttpServerResponse &&resp) {
+        resp.addHeader("Access-Control-Allow-Origin", "*");
+        return std::move(resp);
+    });
+
+    connect(this, &Server::requestServerNewPromptResponsePair, m_chat,
+        &Chat::serverNewPromptResponsePair, Qt::BlockingQueuedConnection);
+}
+
+QHttpServerResponse Server::handleCompletionRequest(const QHttpServerRequest &request, bool isChat)
+{
+    // We've been asked to do a completion...
+    QJsonParseError err;
+    const QJsonDocument document = QJsonDocument::fromJson(request.body(), &err);
+    if (err.error || !document.isObject()) {
+        std::cerr << "ERROR: invalid json in completions body" << std::endl;
+        return QHttpServerResponse(QHttpServerResponder::StatusCode::NoContent);
+    }
+#if defined(DEBUG)
+    printf("/v1/completions %s\n", qPrintable(document.toJson(QJsonDocument::Indented)));
+    fflush(stdout);
+#endif
+    const QJsonObject body = document.object();
+    if (!body.contains("model")) { // required
+        std::cerr << "ERROR: completions contains no model" << std::endl;
+        return QHttpServerResponse(QHttpServerResponder::StatusCode::NoContent);
+    }
+    QJsonArray messages;
+    if (isChat) {
+        if (!body.contains("messages")) {
+            std::cerr << "ERROR: chat completions contains no messages" << std::endl;
+            return QHttpServerResponse(QHttpServerResponder::StatusCode::NoContent);
+        }
+        messages = body["messages"].toArray();
+    }
+
+    const QString modelRequested = body["model"].toString();
+    ModelInfo modelInfo = ModelList::globalInstance()->defaultModelInfo();
+    const QList<ModelInfo> modelList = ModelList::globalInstance()->selectableModelList();
+    for (const ModelInfo &info : modelList) {
+        Q_ASSERT(info.installed);
+        if (!info.installed)
+            continue;
+        if (modelRequested == info.name() || modelRequested == info.filename()) {
+            modelInfo = info;
+            break;
+        }
+    }
+
+    // We only support one prompt for now
+    QList<QString> prompts;
+    if (body.contains("prompt")) {
+        QJsonValue promptValue = body["prompt"];
+        if (promptValue.isString())
+            prompts.append(promptValue.toString());
+        else {
+            QJsonArray array = promptValue.toArray();
+            for (const QJsonValue &v : array)
+                prompts.append(v.toString());
+        }
+    } else
+        prompts.append(" ");
+
+    int max_tokens = 16;
+    if (body.contains("max_tokens"))
+        max_tokens = body["max_tokens"].toInt();
+
+    float temperature = 1.f;
+    if (body.contains("temperature"))
+        temperature = body["temperature"].toDouble();
+
+    float top_p = 1.f;
+    if (body.contains("top_p"))
+        top_p = body["top_p"].toDouble();
+
+    float min_p = 0.f;
+    if (body.contains("min_p"))
+        min_p = body["min_p"].toDouble();
+
+    int n = 1;
+    if (body.contains("n"))
+        n = body["n"].toInt();
+
+    int logprobs = -1; // supposed to be null by default??
+    if (body.contains("logprobs"))
+        logprobs = body["logprobs"].toInt();
+
+    bool echo = false;
+    if (body.contains("echo"))
+        echo = body["echo"].toBool();
+
+    // We currently don't support any of the following...
+#if 0
+    // FIXME: Need configurable reverse prompts
+    QList<QString> stop;
+    if (body.contains("stop")) {
+        QJsonValue stopValue = body["stop"];
+        if (stopValue.isString())
+            stop.append(stopValue.toString());
+        else {
+            QJsonArray array = stopValue.toArray();
+            for (QJsonValue v : array)
+                stop.append(v.toString());
+        }
+    }
+
+    // FIXME: QHttpServer doesn't support server-sent events
+    bool stream = false;
+    if (body.contains("stream"))
+        stream = body["stream"].toBool();
+
+    // FIXME: What does this do?
+    QString suffix;
+    if (body.contains("suffix"))
+        suffix = body["suffix"].toString();
+
+    // FIXME: We don't support
+    float presence_penalty = 0.f;
+    if (body.contains("presence_penalty"))
+        top_p = body["presence_penalty"].toDouble();
+
+    // FIXME: We don't support
+    float frequency_penalty = 0.f;
+    if (body.contains("frequency_penalty"))
+        top_p = body["frequency_penalty"].toDouble();
+
+    // FIXME: We don't support
+    int best_of = 1;
+    if (body.contains("best_of"))
+        logprobs = body["best_of"].toInt();
+
+    // FIXME: We don't need
+    QString user;
+    if (body.contains("user"))
+        suffix = body["user"].toString();
+#endif
+
+    QString actualPrompt = prompts.first();
+
+    // if we're a chat completion we have messages which means we need to prepend these to the prompt
+    if (!messages.isEmpty()) {
+        QList<QString> chats;
+        for (int i = 0; i < messages.count();  ++i) {
+            QJsonValue v = messages.at(i);
+            QString content = v.toObject()["content"].toString();
+            if (!content.endsWith("\n") && i < messages.count() - 1)
+                content += "\n";
+            chats.append(content);
+        }
+        actualPrompt.prepend(chats.join("\n"));
+    }
+
+    // adds prompt/response items to GUI
+    emit requestServerNewPromptResponsePair(actualPrompt); // blocks
+
+    // load the new model if necessary
+    setShouldBeLoaded(true);
+
+    if (modelInfo.filename().isEmpty()) {
+        std::cerr << "ERROR: couldn't load default model " << modelRequested.toStdString() << std::endl;
+        return QHttpServerResponse(QHttpServerResponder::StatusCode::BadRequest);
+    } else if (!loadModel(modelInfo)) {
+        std::cerr << "ERROR: couldn't load model " << modelInfo.name().toStdString() << std::endl;
+        return QHttpServerResponse(QHttpServerResponder::StatusCode::InternalServerError);
+    }
+
+    // don't remember any context
+    resetContext();
+
+    const QString promptTemplate    = modelInfo.promptTemplate();
+    const float top_k               = modelInfo.topK();
+    const int n_batch               = modelInfo.promptBatchSize();
+    const float repeat_penalty      = modelInfo.repeatPenalty();
+    const int repeat_last_n         = modelInfo.repeatPenaltyTokens();
+
+    int promptTokens = 0;
+    int responseTokens = 0;
+    QList<QPair<QString, QList<ResultInfo>>> responses;
+    for (int i = 0; i < n; ++i) {
+        if (!promptInternal(
+            m_collections,
+            actualPrompt,
+            promptTemplate,
+            max_tokens /*n_predict*/,
+            top_k,
+            top_p,
+            min_p,
+            temperature,
+            n_batch,
+            repeat_penalty,
+            repeat_last_n)) {
+
+            std::cerr << "ERROR: couldn't prompt model " << modelInfo.name().toStdString() << std::endl;
+            return QHttpServerResponse(QHttpServerResponder::StatusCode::InternalServerError);
+        }
+        QString echoedPrompt = actualPrompt;
+        if (!echoedPrompt.endsWith("\n"))
+            echoedPrompt += "\n";
+        responses.append(qMakePair((echo ? u"%1\n"_s.arg(actualPrompt) : QString()) + response(), m_databaseResults));
+        if (!promptTokens)
+            promptTokens += m_promptTokens;
+        responseTokens += m_promptResponseTokens - m_promptTokens;
+        if (i != n - 1)
+            resetResponse();
+    }
+
+    QJsonObject responseObject;
+    responseObject.insert("id", "foobarbaz");
+    responseObject.insert("object", "text_completion");
+    responseObject.insert("created", QDateTime::currentSecsSinceEpoch());
+    responseObject.insert("model", modelInfo.name());
+
+    QJsonArray choices;
+
+    if (isChat) {
+        int index = 0;
+        for (const auto &r : responses) {
+            QString result = r.first;
+            QList<ResultInfo> infos = r.second;
+            QJsonObject choice;
+            choice.insert("index", index++);
+            choice.insert("finish_reason", responseTokens == max_tokens ? "length" : "stop");
+            QJsonObject message;
+            message.insert("role", "assistant");
+            message.insert("content", result);
+            choice.insert("message", message);
+            if (MySettings::globalInstance()->localDocsShowReferences()) {
+                QJsonArray references;
+                for (const auto &ref : infos)
+                    references.append(resultToJson(ref));
+                choice.insert("references", references);
+            }
+            choices.append(choice);
+        }
+    } else {
+        int index = 0;
+        for (const auto &r : responses) {
+            QString result = r.first;
+            QList<ResultInfo> infos = r.second;
+            QJsonObject choice;
+            choice.insert("text", result);
+            choice.insert("index", index++);
+            choice.insert("logprobs", QJsonValue::Null); // We don't support
+            choice.insert("finish_reason", responseTokens == max_tokens ? "length" : "stop");
+            if (MySettings::globalInstance()->localDocsShowReferences()) {
+                QJsonArray references;
+                for (const auto &ref : infos)
+                    references.append(resultToJson(ref));
+                choice.insert("references", references);
+            }
+            choices.append(choice);
+        }
+    }
+
+    responseObject.insert("choices", choices);
+
+    QJsonObject usage;
+    usage.insert("prompt_tokens", int(promptTokens));
+    usage.insert("completion_tokens", int(responseTokens));
+    usage.insert("total_tokens", int(promptTokens + responseTokens));
+    responseObject.insert("usage", usage);
+
+#if defined(DEBUG)
+    QJsonDocument newDoc(responseObject);
+    printf("/v1/completions %s\n", qPrintable(newDoc.toJson(QJsonDocument::Indented)));
+    fflush(stdout);
+#endif
+
+    return QHttpServerResponse(responseObject);
+}

gpt4all-chat/src/server.h

@@ -0,0 +1,42 @@
+#ifndef SERVER_H
+#define SERVER_H
+
+#include "chatllm.h"
+#include "database.h"
+
+#include <QHttpServerRequest>
+#include <QHttpServerResponse>
+#include <QObject>
+#include <QList>
+#include <QString>
+
+class Chat;
+class QHttpServer;
+
+class Server : public ChatLLM
+{
+    Q_OBJECT
+
+public:
+    Server(Chat *parent);
+    virtual ~Server();
+
+public Q_SLOTS:
+    void start();
+
+Q_SIGNALS:
+    void requestServerNewPromptResponsePair(const QString &prompt);
+
+private Q_SLOTS:
+    QHttpServerResponse handleCompletionRequest(const QHttpServerRequest &request, bool isChat);
+    void handleDatabaseResultsChanged(const QList<ResultInfo> &results) { m_databaseResults = results; }
+    void handleCollectionListChanged(const QList<QString> &collectionList) { m_collections = collectionList; }
+
+private:
+    Chat *m_chat;
+    QHttpServer *m_server;
+    QList<ResultInfo> m_databaseResults;
+    QList<QString> m_collections;
+};
+
+#endif // SERVER_H