Utilisez la macro ONLYOFFICE pour remplir les cellules avec des données OpenAI

22 février 2023By Dasha

La technologie de l’IA a fait des progrès considérables et est devenue un outil précieux qui peut automatiser notre flux de travail. Dans notre précédent billet de blog, nous avons abordé la macro ONLYOFFICE qui peut générer des essais en utilisant l’API OpenAI. Dans ce billet de blog, nous allons vous présenter une macro qui alimente une feuille de calcul avec des données obtenues par OpenAI. Use ONLYOFFICE macro to populate cells with OpenAI data

Utilisation de l’API OpenAI

La dernière fois, nous nous sommes connectés à l’API OpenAI via la plateforme RapidAPI. Il s’agit d’un moyen rapide et pratique de gérer les demandes de récupération. Cependant, le plan de base ne propose que 100 demandes par mois. Cette fois-ci, nous allons donc monter d’un cran et créer notre propre serveur Node.js Express. Il utilisera la bibliothèque OpenAI pour servir les demandes d’API directement au modèle de langage approprié. Il nous permettra également de contourner les erreurs CORS lors d’une demande de récupération à partir d’un navigateur.

Remarque ! L’envoi de demande à OpenAI directement n’est possible qu’après l’enregistrement d’un compte OpenAI et l’acquisition d’une clé API personnelle.

Configuration d’un serveur

Tout d’abord, nous créons un nouveau dossier pour notre serveur et configurons un nouveau projet Node.js en exécutant la commande suivante dans le terminal :

$ npm init -y

Ensuite, nous installons les dépendances suivantes :

paquet express – est un cadre essentiel qui facilite la fonctionnalité du serveur.
paquet cors – fournit un middleware pour activer CORS.
paquet openai – fournit un accès pratique à l’API OpenAI depuis Node.js.
paquet dotenv – charge les variables d’environnement d’un fichier .env dans process.env.

Pour les installer, exécutez la commande npm instal dans le terminal :

$ npm install express
$ npm install openai
$ npm install dotenv --save
$ npm install cors

Après cela, nous créons le fichier .env. Nous allons y stocker nos clés API :

OPEN_AI_API_KEY="<YourOpenAIkey"
SECOND_API_KEY="YourAPIkey"

Le paramètre OPEN_AI_API_KEY contient votre clé API obtenue auprès d’OpenAI, et le paramètre SECOND_API_KEY est la clé API de notre serveur. Nous l’incorporerons dans la requête de récupération entrante par mesure de sécurité.

Ensuite, nous initialisons les paquets installés dans le fichier index.js :

const express = require('express');
const cors = require('cors');
const { Configuration, OpenAIApi } = require('openai');
require('dotenv').config();
const app = express();

const openai = new OpenAIApi(configuration);
app.use(cors());
app.use(express.json());

Une demande réussie à OpenAI doit inclure la clé API d’OpenAI. Pour ce faire, nous extrayons cette clé API du fichier .env et la stockons dans la variable de configuration :

const configuration = new Configuration({
  apiKey: process.env.OPEN_AI_API_KEY,
});

Puis nous ajoutons une route postale à partir de laquelle nous enverrons une demande à OpenAI :

app.post('/completion', async (req, res) => {
}

Nous voulons également implémenter notre clé API pour des mesures de sécurité. Cette deuxième clé d’API est censée être incluse dans une demande de récupération. À cet égard, notre serveur doit vérifier la demande de récupération entrante et valider la clé API incluse. Pour ce faire, nous ajoutons le code suivant à notre route :

app.post('/completion', async (req, res) => {
  const requestApiKey = req.body.apiKey;
  
  if (!requestApiKey) {
    res.status(400).send({ error: "Error: API Key is missing." });
    return;
  }
  if (requestApiKey !== process.env.SECOND_API_KEY) {
    res.status(401).send({ error: "Error: API Key is incorrect." });
    return;
  }

Si la clé API est correcte, nous envoyons une demande à OpenAI :

const completion = await openai.createCompletion({
    model: 'text-davinci-003',
    prompt: req.body.prompt,
    temperature: 0,
    max_tokens: 300,
  });
  res.json(completion.data.choices[0].text);

Le paramètre model spécifie le nom du modèle de langage à utiliser pour la génération de texte. Dans ce cas, il s’agit de text-davinci-003, qui est le modèle le plus avancé pour la génération de texte.
Le paramètre prompt spécifie le texte ou le contexte à partir duquel le modèle de langue doit générer du texte. Nous obtiendrons cette valeur à partir du corps de la demande de récupération.
Le paramètre de température contrôle le caractère aléatoire du texte généré. Une valeur de 0 signifie que le texte est complètement déterministe, tandis que des valeurs plus élevées donneront un texte plus varié et inattendu.
Le paramètre max-tokens indique la longueur maximale du texte généré en tokens (c’est-à-dire en mots ou sous-mots).

Enfin, nous configurons notre serveur pour qu’il écoute sur le port 3000 :

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

L’ensemble du code index.js est le suivant :

const express = require('express');
const cors = require('cors');
const { Configuration, OpenAIApi } = require('openai');
require('dotenv').config();
const app = express();
const configuration = new Configuration({
  apiKey: process.env.OPEN_AI_API_KEY,
});
const openai = new OpenAIApi(configuration);
app.use(cors());
app.use(express.json());
app.post('/completion', async (req, res) => {
  const requestApiKey = req.body.apiKey;
  
  if (!requestApiKey) {
    res.status(400).send({ error: "Error: API Key is missing." });
    return;
  }
  if (requestApiKey !== process.env.SECOND_API_KEY) {
    res.status(401).send({ error: "Error: API Key is incorrect." });
    return;
  }
  const completion = await openai.createCompletion({
    model: 'text-davinci-003',
    prompt: req.body.prompt,
    temperature: 0,
    max_tokens: 300,
  });
  res.json(completion.data.choices[0].text);
});
app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Construction de la macro

Tout d’abord, nous faisons une demande de récupération à notre serveur :

fetch('http://<your_server_address>/completion', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
prompt: 'List the 10 wealthiest countries in the world. Provide GPT figures',
apiKey: '<YourAPIkey>'
})
})

Nous avons spécifié les valeurs prompt et apiKey dans le corps de la requête. Notez que ces paramètres seront différents en fonction des données que vous souhaitez recevoir et de la clé API de votre serveur.

Ensuite, nous analysons la réponse en tant que données JSON :

.then(response => response.json())

Nous divisons le texte de la réponse par des sauts de ligne dans un tableau de chaînes de caractères et nous ciblons la feuille de calcul active :

.then(data => {
var arrAllRows = data.split(/\r?\n|\r/);
var wSheet = Api.GetActiveSheet()

Ensuite, nous créons une boucle imbriquée qui itère sur les lignes et les colonnes de la feuille de calcul, en utilisant la fonction split(). Nous utilisons la méthode SetValue pour remplir chaque cellule avec les données de la réponse et les débarrasser des espaces :

var i = 0;
var j = 0;
  for (var singleRow = 0; singleRow < arrAllRows.length; singleRow++) {
            var rowCells = arrAllRows[singleRow].split('-');
            for (var rowCell = 0; rowCell < rowCells.length; rowCell++) {
                wSheet.GetCells(i,j).SetValue(rowCells[rowCell].trim());
                j = j + 1;
            } 
            i = i + 1;
            j = 1;
        }

Le code entier de la macro est le suivant :

(function()
{
   fetch('http://<your_server_address>/completion', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
prompt: 'List the 10 wealthiest countries in the world. Provide GPT figures',
apiKey: 'dfhgsd63456efgdfhjikhfzf435332fdhd'
})
})
.then(response => response.json())
.then(data => {
var arrAllRows = data.split(/\r?\n|\r/);
var wSheet = Api.GetActiveSheet();
var i = 0;
var j = 0;
  for (var singleRow = 0; singleRow < arrAllRows.length; singleRow++) {
            var rowCells = arrAllRows[singleRow].split('-');
            for (var rowCell = 0; rowCell < rowCells.length; rowCell++) {
                wSheet.GetCells(i,j).SetValue(rowCells[rowCell].trim());
                j = j + 1;
            } 
            i = i + 1;
            j = 1;
        }
});
})();

Maintenant, ouvrons le tableur et exécutons notre macro !

Nous espérons que vous utiliserez les concepts décrits dans cet article de blog et que vous rendrez votre flux de travail plus efficace. Nous vous encourageons à tirer parti de nos diverses méthodes API et à les intégrer dans vos tâches quotidiennes.

Si vous avez des questions ou des idées à partager, n’hésitez pas à laisser des commentaires ou à nous contacter. Nous sommes ouverts à vos idées et désireux de collaborer avec vous. Bonne chance dans vos projets d’exploration !