Comment développer une compétence Amazon Alexa à l'aide de Node.js

Dans ce didacticiel, nous allons implémenter une compétence personnalisée pour Amazon Alexa en utilisant nodejs, npm et AWS Lambda Functions. Cette compétence est fondamentalement un exemple de Hello World. Avec ce didacticiel, vous pourrez créer une compétence personnalisée pour Amazon Alexa, implémenter des fonctionnalités à l'aide de nodejs et démarrer votre compétence personnalisée à la fois depuis votre ordinateur local et depuis AWS.

Ce didacticiel contient des éléments de différentes ressources que l’on peut consulter dans la section Ressources.

Conditions préalables

  • Un projet de NGP. Pour plus d'informations sur la configuration d'un projet NPM, consultez la section suivante.
  • Un environnement de développement Node.js approprié. ASK SDK v2 pour Node.js nécessite le noeud 4.3.2 ou supérieur.
  • Un compte développeur Amazon. Cela est nécessaire pour créer et configurer les compétences Alexa.
  • Un compte Amazon Web Services (AWS). Ce guide vous expliquera comment héberger une compétence sur AWS Lambda. (Si vous souhaitez créer une compétence sans utiliser AWS, vous pouvez également utiliser un paquet npm appelé [alexa-skill-local]. (Https://www.npmjs.com/package/alexa-skill-local))

Ajout du kit de développement logiciel ASK à votre projet

  • À partir de votre projet NPM, exécutez les commandes suivantes pour installer la distribution standard ASK SDK v2 pour Node.js:

npm installer --save ask-sdk

Configuration de la compétence personnalisée Amazon Alexa

  • Créez une nouvelle compétence dans la console du développeur. Lorsque vous êtes invité à choisir un modèle, sélectionnez le modèle Personnalisé.
  • Allez sur developer.amazon.com/alexa.
  • Cliquez sur Vos consoles Alexa, puis sur Compétences. Cela ouvre la console du développeur et affiche toutes les compétences que vous avez déjà créées.
  • Cliquez sur Créer une compétence.
  • Entrez le nom de la compétence. C'est le nom que les clients verront lorsque vous publiez la compétence. Vous pouvez modifier ce nom ultérieurement sur la page Distribution.
  • Si nécessaire, changez la langue initiale de la compétence, puis cliquez sur Suivant.
  • Cliquez sur le bouton Sélectionner le modèle que vous souhaitez inclure (pour ce tutoriel, nous utiliserons custom).

Implémentation des gestionnaires de demandes

Créez d’abord les gestionnaires de requêtes nécessaires pour gérer les différents types de requêtes entrantes de votre compétence.

LaunchRequest Handler

L'exemple de code suivant montre comment configurer un gestionnaire à appeler lorsque la compétence reçoit une demande LaunchRequest. L'événement LaunchRequest se produit lorsque la compétence est appelée sans intention spécifique.

Créez un fichier nommé index.js et collez-le dans le code suivant.

const LaunchRequestHandler = {
    canHandle (handlerInput) {
        return handlerInput.requestEnvelope.request.type === 'LaunchRequest';
    },
    handle (handlerInput) {
        const speechText = 'Bienvenue dans le Alexa Skills Kit, vous pouvez dire bonjour!';
retour handlerInput.responseBuilder
            .speak (speechText)
            .reprompt (speechText)
            .withSimpleCard ('Hello World', speechText)
            .avoir une réponse();
    }
};

La fonction canHandle renvoie true si la demande entrante est une LaunchRequest. La fonction handle génère et retourne une réponse d'accueil de base.

HelloWorldIntent Handler

L'exemple de code suivant montre comment configurer un gestionnaire à appeler lorsque la compétence reçoit l'objet HelloWorldIntent.

Collez le code suivant dans votre fichier index.js, après le gestionnaire précédent.

const HelloWorldIntentHandler = {
    canHandle (handlerInput) {
        return handlerInput.requestEnvelope.request.type === 'IntentRequest'
            && handlerInput.requestEnvelope.request.intent.name === 'HelloWorldIntent';
    },
    handle (handlerInput) {
        const speechText = 'Hello World!';
retour handlerInput.responseBuilder
            .speak (speechText)
            .withSimpleCard ('Hello World', speechText)
            .avoir une réponse();
    }
};

La fonction canHandle détecte si la demande entrante est un IntentRequest et renvoie true si le nom de l'intention est HelloWorldIntent. La fonction handle génère et renvoie une réponse de base «Hello world».

HelpIntent Handler

L'exemple de code suivant montre comment configurer un gestionnaire à appeler lorsque la compétence reçoit l'intention intégrée AMAZON.HelpIntent.

Collez le code suivant dans votre fichier index.js, après le gestionnaire précédent.

const HelpIntentHandler = {
    canHandle (handlerInput) {
        return handlerInput.requestEnvelope.request.type === 'IntentRequest'
            && handlerInput.requestEnvelope.request.intent.name === 'AMAZON.HelpIntent';
    },
    handle (handlerInput) {
        const speechText = 'Vous pouvez me dire bonjour!';
retour handlerInput.responseBuilder
            .speak (speechText)
            .reprompt (speechText)
            .withSimpleCard ('Hello World', speechText)
            .avoir une réponse();
    }
};

Semblable au gestionnaire précédent, ce gestionnaire correspond à un IntentRequest avec le nom d'intention attendu. Les instructions d'aide de base sont renvoyées.

CancelAndStopIntent Handler

Le gestionnaire CancelAndStopIntenthandler est similaire au gestionnaire HelpIntent, car il est également déclenché par les intentions intégrées. L'exemple suivant utilise un seul gestionnaire pour répondre à deux intentions différentes, Amazon.CancelIntent et Amazon.StopIntent.

Collez le code suivant dans votre fichier index.js, après le gestionnaire précédent.

const CancelAndStopIntentHandler = {
    canHandle (handlerInput) {
        return handlerInput.requestEnvelope.request.type === 'IntentRequest'
            && (handlerInput.requestEnvelope.request.intent.name === 'AMAZON.CancelIntent'
                || handlerInput.requestEnvelope.request.intent.name === 'AMAZON.StopIntent');
    },
    handle (handlerInput) {
        const speechText = 'Au revoir!';
retour handlerInput.responseBuilder
            .speak (speechText)
            .withSimpleCard ('Hello World', speechText)
            .avoir une réponse();
    }
};

La réponse aux deux intentions est la même, de sorte qu'un seul gestionnaire réduit le code répétitif.

SessionEndedRequestHandler

Bien que vous ne puissiez pas renvoyer de réponse avec un discours, une carte ou des directives après avoir reçu une SessionEndedRequest, SessionEndedRequestHandler est un bon endroit pour mettre votre logique de nettoyage.

Collez le code suivant dans votre fichier index.js, après le gestionnaire précédent.

const SessionEndedRequestHandler = {
    canHandle (handlerInput) {
        return handlerInput.requestEnvelope.request.type === 'SessionEndedRequest';
    },
    handle (handlerInput) {
        // n'importe quelle logique de nettoyage va ici
        return handlerInput.responseBuilder.getResponse ();
    }
};

ErrorHandler

ASK SDK v2 pour Node.js offre une meilleure prise en charge de la gestion des erreurs, ce qui permet aux compétences de garantir une expérience utilisateur fluide. Le gestionnaire d'erreurs est un bon endroit pour injecter votre logique de traitement des erreurs, telle qu'une requête non gérée, le délai d'attente du service api, etc.

Collez le code suivant dans votre fichier index.js, après le gestionnaire précédent.

const ErrorHandler = {
    peut gérer() {
      retourne vrai;
    },
    handle (handlerInput, error) {
      console.log (`Erreur gérée: $ {error.message}`);
retour handlerInput.responseBuilder
        .speak ('Désolé, je ne peux pas comprendre la commande. Dites-le encore une fois.')
        .reprompt ('Désolé, je ne peux pas comprendre la commande. Dites-le encore une fois.')
        .avoir une réponse();
    },
};

Création du gestionnaire Lambda

Le gestionnaire Lambda est le point d'entrée de votre fonction AWS Lambda. L'exemple de code suivant crée une fonction de gestionnaire Lambda pour router toutes les demandes entrantes vers votre compétence. La fonction de gestionnaire Lambda crée une instance Skill SDK configurée avec les gestionnaires de demandes que vous venez de créer.

Ajoutez le code suivant au début de votre fichier index.js. Le code devrait précéder les gestionnaires que vous avez créés précédemment. (Rappelez-vous, c'est le ASK SDK v2!)

'use strict';
const Alexa = require ('ask-sdk-core');
// utilise 'ask-sdk' si le module SDK standard est installé
//////////////////////////////////////
// Code pour les gestionnaires ici //
//////////////////////////////////////
exports.handler = Alexa.SkillBuilders.custom ()
     .addRequestHandlers (LaunchRequestHandler,
                         HelloWorldIntentHandler,
                         HelpIntentHandler,
                         CancelAndStopIntentHandler,
                         SessionEndedRequestHandler)
     .lambda ();

Configurer votre compétence

Sélectionnez l'option Invocation dans la barre latérale et entrez «greeter» comme nom d'invocation de compétence.

Ajoutez ensuite une intention appelée HelloWorldIntent au modèle d'interaction. Cliquez sur le bouton Ajouter sous la section Intentions du modèle d'interaction.

Laissez «Créer une intention personnalisée» sélectionné, entrez «HelloWorldIntent» pour le nom de l'intention et créez-la. Sur la page de détail de l'intention, ajoutez quelques exemples d'énoncés que les utilisateurs peuvent dire pour appeler l'intention. Pour cet exemple, vous pouvez utiliser ceux-ci:

dis bonjour
dire bonjour monde
salut
dis salut
Salut le monde
salut
Comment allez-vous

Étant donné que AMAZON.CancelIntent, AMAZON.HelpIntent et AMAZON.StopIntent sont des fonctions Alexa intégrées, vous n'avez pas besoin de leur fournir d'exemples d'énoncés.

La console pour développeurs vous permet également de modifier l'intégralité du modèle de compétence au format JSON. Sélectionnez JSON Editor dans la barre latérale. Pour cet exemple, vous pouvez utiliser le schéma JSON suivant.

{
  "interactionModel": {
    "languageModel": {
      "invocationName": "greeter",
      "intention": [
        {
          "name": "AMAZON.CancelIntent",
          "échantillons": []
        },
        {
          "name": "AMAZON.HelpIntent",
          "échantillons": []
        },
        {
          "name": "AMAZON.StopIntent",
          "échantillons": []
        },
        {
          "name": "HelloWorldIntent",
          "slots": [],
          "échantillons": [
            "Comment allez-vous",
            "salut",
            "Salut le monde",
            "dis salut",
            "salut",
            "bonjour le monde",
            "dis bonjour"
          ]
        }
      ],
      "les types": []
    }
  }
}

Une fois que vous avez terminé la modification du modèle d'interaction, veillez à enregistrer et à générer le modèle.

Commencer votre compétence Alexa sur Local

Installation du package NPM et des fichiers de configuration

Nous allons utiliser un paquet npm appelé alexa-skill-local pour cette partie. Afin de démarrer votre application, vous devez également créer un fichier asl-config.json dans votre répertoire racine. Le fichier de configuration doit être au format suivant (si vous n'êtes pas sûr de la «scène», dans la plupart des cas, il s'agit du «développement»):

{
    "skillId": "your_skill_id_here",
    "stage": "stage_of_the_skill"
}

Vous pouvez trouver votre identifiant de compétence sur la page de la console Alexa. Elle ressemble à amzn1.ask.skill.6f2f04b5-abba-3f47–9fc9–0sbba79b1535. Utilisez Node.js v8.x.x pour exécuter. Vous pouvez installer alexa-skill-local globalement (recommandé) ou dans votre répertoire de projet (dans ce cas, vous voudrez peut-être l’exécuter à partir de scripts npm dans package.json).

$ npm installer -g alexa-skill-local

Usage

Exécuter la commande suivante. Lorsque vous y êtes invité, ouvrez http: // localhost: 3001 dans votre navigateur. Connectez-vous avec Amazon pour donner à alexa-skill-local un accès pour mettre à jour le point de terminaison de votre compétence.

$ alexa-skill-local

Après cela, suivez les instructions sur la console.

Configuration de la compétence Amazon Alexa

Configurez le noeud final pour la compétence. Sous Endpoint, sélectionnez HTTPS et collez l'URL fournie sur la ligne de commande. Sélectionnez le type de certificat SSL, car mon noeud final de développement est un sous-domaine d'un domaine doté d'un certificat générique émis par une autorité de certification. Le reste des paramètres peut être laissé à ses valeurs par défaut. Cliquez sur Save Endpoints.

Démarrer votre compétence Alexa avec AWS Lambda

Création de la fonction AWS Lambda

  • Si vous ne possédez pas encore de compte sur AWS, accédez à Amazon Web Services et créez-en un.
  • Connectez-vous à AWS Management Console et accédez à AWS Lambda.
  • Cliquez sur la liste déroulante des régions située dans le coin supérieur droit de la console et sélectionnez l'une des régions prises en charge pour les compétences Alexa: Asie Pacifique (Tokyo), UE (Irlande), US East (Virginie du Nord) ou US West (Oregon). ).
  • Si vous n'avez pas encore de fonctions Lambda, cliquez sur Commencer maintenant. Sinon, cliquez sur Créer une fonction Lambda.
  • Sélectionnez Auteur à partir de zéro.
  • Entrez un nom pour la fonction.
  • Sélectionnez le rôle de la fonction. Ceci définit les ressources AWS auxquelles la fonction peut accéder.
  • Pour utiliser un rôle existant, sélectionnez-le sous Rôle existant.
  • Pour créer un nouveau rôle, voir Définition d'un nouveau rôle pour la fonction. N'oubliez pas que nous avons besoin d'une autorisation Simple Microservice pour ce rôle!
  • Sélectionnez la langue que vous souhaitez utiliser pour le Runtime (Node.js, Java ou Python). Pour ce tutoriel, nous utilisons Node.js.
  • Cliquez sur Créer une fonction.
  • Configurez le déclencheur Alexa Skills Kit.

Ajout du déclencheur du kit de compétences Alexa

  • Accédez à https://www.developer.amazon.com/alexa.
  • Cliquez sur Vos consoles Alexa, puis sur Compétences. Cela ouvre la console du développeur et affiche toutes les compétences que vous avez créées.
  • Trouvez la compétence dans la liste. L'ID est affiché sous le nom de la compétence.

Une fois que vous avez votre ID de compétence, ajoutez le déclencheur à la fonction:

  • Connectez-vous à AWS Management Console et accédez à AWS Lambda.
  • Cliquez sur votre fonction dans la liste pour ouvrir les détails de la configuration.
  • Assurez-vous que vous êtes sur la page de configuration.
  • Dans la section Designer, sous Ajouter des déclencheurs, cliquez sur Alexa Skills Kit pour sélectionner le déclencheur.
  • Sous Configurer les déclencheurs, sélectionnez Activer pour la vérification des ID de compétence.
  • Entrez votre ID de compétence dans la zone d'édition ID de compétence.
  • Cliquez sur Ajouter.
  • Cliquez sur Enregistrer pour enregistrer le changement.

Création du package de compétences

Lorsque le code de compétence est complet, vous pouvez créer le package de compétences. Pour préparer la compétence en vue de son téléchargement sur AWS Lambda, créez un fichier zip contenant le fichier de compétence et le dossier node_modules. Assurez-vous de compresser tous les fichiers du projet directement, PAS le dossier du projet.

Téléchargement de votre compétence sur AWS Lambda

Une fois que vous avez créé votre fonction AWS Lambda et configuré le déclencheur «Alexa Skills Kit», téléchargez le fichier .zip généré à l’étape précédente et laissez le gestionnaire en tant que gestionnaire index.handler par défaut. Enfin, copiez l’ARN de votre fonction AWS Lambda, car vous en aurez besoin lors de la configuration de vos compétences dans la console Amazon Developer.

Configuration de la compétence Amazon Alexa

Configurez le noeud final pour la compétence. Sous Noeud final, sélectionnez AWS Lambda ARN et collez l'ARN de la fonction créée précédemment. Le reste des paramètres peut être laissé à ses valeurs par défaut. Cliquez sur Save Endpoints.

Tester votre compétence

À ce stade, vous pouvez tester la compétence. Cliquez sur Test dans la navigation du haut pour accéder à la page de test. Assurez-vous que le test est activé pour cette compétence. Vous pouvez utiliser la page de test pour simuler des demandes, sous forme de texte et de voix. Utilisez le nom de l'invocation avec l'un des énoncés de phrase. Par exemple, "dites à la personne d'accueil de dire Salut monde" devrait avoir pour résultat que votre compétence répondra par "Bonjour monde" Il existe plusieurs options pour tester une nouvelle compétence:

Utilisez le nom de l'appel avec l'un des exemples d'énoncés que nous venons de configurer comme guide. Par exemple, "dire à la personne d'accueil de dire bonjour" devrait entraîner une réponse de votre compétence avec "Bonjour tout le monde". Vous devriez également pouvoir accéder à l'Application Alexa (sur votre téléphone ou à l'adresse https://alexa.amazon.com) et voir vos compétences répertoriées sous Vos compétences. À partir de là, vous pouvez activer la compétence de votre compte pour effectuer des tests à partir d'un appareil compatible Alexa.

Vous devez suivre régulièrement les performances de votre bot et surveiller son comportement pour qu’il atteigne les charts.

Enfin, connectez vos compétences à Botanalytics pour obtenir votre analyse gratuite des compétences Amazon Alexa. Vous ne pouvez pas améliorer ce que vous ne mesurez pas, non? Vous pouvez utiliser notre bibliothèque officielle Node.js pour intégrer facilement Botanalytics.

Références

  • https://github.com/alexa/alexa-skills-kit-sdk-for-nodejs
  • https://github.com/alexa/alexa-skills-kit-sdk-for-nodejs/wiki/Developing-Your-First-Skill
  • https://developer.amazon.com/docs/custom-skills/understanding-custom-skills.html
  • https://developer.amazon.com/docs/custom-skills/steps-to-build-a-custom-skill.html
  • https://developer.amazon.com/docs/devconsole/test-your-skill.html
  • https://developer.amazon.com/docs/devconsole/build-your-skill.html
  • https://medium.com/@moonahmad/how-to-test-alexa-locally-6d498e307a8
  • https://www.npmjs.com/package/alexa-skill-local
  • https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an--aws-lambda-function.html
Clap pour recommander cette histoire à d'autres