Client API RESTful ChatGPT

Cet exemple utilise la dernière spécification OpenAPI de l’API OpenAI pour créer du code client d’API RESTful. Comme il ne s’agit que d’un exemple, il ne met pas en œuvre l’ensemble des modèles et des opérations décrits dans la spécification officielle d’OpenAI. En particulier, l’exemple se limite à deux opérations décrites dans le fichier response_api.yaml:

• listModels : permet de récupérer la liste des modèles disponibles.
• createResponse : envoie une requête utilisateur au modèle choisi et reçoit un message de réponse.

Exécution de l'exemple

Vous pouvez exécuter l'exemple à partir de :

• Qt Creator

  Ouvrez le mode « Welcome » et sélectionnez l'exemple dans « Examples ». Pour plus d'informations, consultez Qt Creator: Tutoriel : Compiler et exécuter.

• Qt Extension for Visual Studio Code

  Exécutez la commande « Qt: Open Qt examples » à partir de Command Palette, puis sélectionnez l'exemple dans la liste. Pour plus d'informations, consultez Qt Extension for Visual Studio Code: Tutoriel : Compiler et exécuter.

Fonctionnalités de l’application

Cet exemple vous permet de choisir un modèle OpenAI parmi la liste des modèles disponibles, puis de dialoguer avec lui. La communication s'effectue selon quatre modes de configuration :

• Assistant – Le programme se comporte comme un assistant et préfère aborder des sujets liés à la magie.
• Scientifique : le modèle se comporte comme Albert Einstein et aime discuter de physique.
• Mode standard : configuration ChatGPT standard sans fonctionnalités supplémentaires.
• Votre choix : vous pouvez créer une description personnalisée du comportement de ChatGPT.

Une fois le mode sélectionné, la page de discussion s'affiche.

Génération de code client à partir d'une spécification OpenAPI

Le générateur OpenAPI de Qt 6 est invoqué à partir du fichier ` CMakeLists.txt ` pour générer du code client à partir de la spécification ` response_api.yaml ` en appelant la fonction ` qt_add_openapi_client() `.

qt_add_library(openAIResponseApi)
qt_add_openapi_client(openAIResponseApi
    SPEC_FILE
        ${CMAKE_CURRENT_SOURCE_DIR}/response_api.yaml
)

Les classes API générées ResponsesApi et ModelsApi gèrent tous les détails HTTP de bas niveau :

• Configuration du serveur
• Construction des requêtes HTTP pour toutes les méthodes HTTP standard
• Sérialisation des paramètres d’entrée conformément à la spécification
• Désérialisation des réponses du serveur en objets typés
• Signalisation des succès et des erreurs via les signaux Qt

Il ne vous reste plus qu'à envoyer une requête au modèle en appelant l'opération ` createResponse() ` de la classe ` ResponsesApi ` et à analyser sa réponse, comme indiqué ci-dessous :

m_responseApi->createResponse(response, this, [&](const QRestReply&reply,
                                                  const Response &summary) {
    if (!reply.isSuccess()) {
        qWarning() << "createResponse:" << reply.errorString() << reply.error();
    } else {
        // Pour conserver le contexte de la conversation avec le modèle OpenAI,
        // nous devons enregistrer le ResponseId renvoyé par le dernier message du modèle.
       // Le contexte perd toute pertinence après le passage à l’autre modèle. Si le modèle
        // ne connaît pas l’identifiant du contexte, il répondra comme si le ResponseId était vide.
       m_responseId = summary.getId();
        const QList<OutputMessage> outputMessage = summary.getOutput();
        for (qsizetype msgIndex = 0; msgIndex < outputMessage.size(); msgIndex++) {
            const QList<OutputTextContent> messages
                = outputMessage.at(msgIndex).getContent();
            for (qsizetype contentIndex = 0; contentIndex < messages.size(); contentIndex++)
                emit responseReady(messages.at(contentIndex).getText());
        }
    }
});

Exposition des API générées vers QML

La classe d'aide OpenAIChatManager expose les classes d'API générées ResponsesApi et ModelsApi à QML. Elle est définie dans openaichatmanager.h.

La classe d'aide utilise les macros QML_ELEMENT et QML_SINGLETON et enregistre l'instance C++ sous-jacente en tant que singleton, ce qui permet à QML d'accéder au même objet tout en conservant la propriété en C++ :

class OpenAIChatManager : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON

    Q_PROPERTY(QString modelName READ modelName WRITE setModelName NOTIFY modelNameChanged FINAL)
    Q_PROPERTY(QString userRequest READ userRequest
               WRITE setUserRequest NOTIFY userRequestChanged FINAL)
    Q_PROPERTY(QStringList modelList READ modelList
               WRITE setModelList NOTIFY modelListChanged FINAL)
    Q_PROPERTY(CharacterMode characterId READ characterId
               WRITE setCharacterId NOTIFY characterIdChanged FINAL)
    Q_PROPERTY(QString customUserCharacter READ customUserCharacter
               WRITE setCustomUserCharacter NOTIFY customUserCharacterChanged FINAL)

L’opération ` createResponse() ` est exposée via la fonction invoquable du singleton ` OpenAIChatManager ` :

    Q_INVOKABLE void sendUserRequest();

Pour plus de détails, consultez la documentation Qt Qml sur l’enregistrement d’une classe pour fournir des singletons.

Utilisation des API depuis QML

Une fois enregistré, le singleton est disponible globalement dans QML. Cela permet aux composants QML d'accéder à ResponsesApi et ModelsApi en utilisant les méthodes du singleton, comme illustré ci-dessous :

function editingFinished() {
    var messageObject = {"name": "Me", "message": messageField.text };
    conversationModel.append(messageObject);
    OpenAIChatManager.userRequest = messageField.text;
    OpenAIChatManager.sendUserRequest();
    messageField.text = "";
}

Fichiers source

Exemple de projet sur code.qt.io