chatskills
1.0.0
Exécutez les applications Alexa sur la ligne de commande. Exécutez-les dans Slack. Exécutez-les n'importe où ! Prend en charge les compétences et les intentions d'Amazon Alexa.
$ npm install chatskillsChatskills est un moyen rapide et simple d'exécuter des applications Alexa en dehors d'Amazon. Créez facilement vos compétences et intentions et exécutez-les directement sur la ligne de commande !
Chatskills ne nécessite pas de serveur et peut s'exécuter directement dans la console. Il peut également fonctionner sur le Web, sur Slack ou n'importe où. Il gère les demandes de plusieurs utilisateurs et maintient la mémoire de session. Lorsqu'un utilisateur démarre une conversation avec l'une des compétences, la compétence continue de s'exécuter dans un contexte de session jusqu'à ce qu'elle se termine.
Voici à quoi ressemble une application Amazon Alexa, exécutée sur la ligne de commande.
> chatskills, ask hello to say hi.
Hello, World!
> chatskills, ask horoscope for Scorpio.
Things are looking up today for Scorpio.
> chatskills, ask funny to tell me a joke
Knock knock.
> who's there?
Banana.
> banana who
Knock knock.
> whos there
Orange.
> orange who?
Orange you glad I didn't say banana?
Dans cet exemple, l'utilisateur accède à trois compétences différentes : bonjour, horoscope et drôle.
Utiliser Chatskills est simple. Utilisez la syntaxe Alexa pour ajouter une nouvelle compétence, puis créez des intentions. Voici un exemple simple.
var chatskills = require ( 'chatskills' ) ;
// Create a skill.
var hello = chatskills . app ( 'hello' ) ;
// Create an intent.
hello . intent ( 'helloWorld' , {
'slots' : { } ,
'utterances' : [ '{to |}{say|speak|tell me} {hi|hello|howdy|hi there|hiya|hi ya|hey|hay|heya}' ]
} ,
function ( req , res ) {
res . say ( 'Hello, World!' ) ;
}
) ;
// Respond to input.
chatskills . respond ( 'chatskills, ask hello to say hi' , function ( response ) {
console . log ( response ) ;
} ) ;Dans l'exemple ci-dessus, la grammaire des énoncés s'étend automatiquement pour correspondre aux phrases suivantes :
helloWorld to say hi
helloWorld say hi
helloWorld to speak hi
helloWorld speak hi
helloWorld to tell me hi
helloWorld tell me hi
helloWorld to say hello
helloWorld say hello
helloWorld to speak hello
helloWorld speak hello
helloWorld to tell me hello
helloWorld tell me hello
helloWorld to say howdy
...
Pour interagir avec le chatbot à l'aide de cette compétence, prononcez l'une des phrases cibles. Dans l'exemple ci-dessus, nous avons utilisé l'expression « pour dire bonjour », mais vous pouvez la comparer à n'importe laquelle des expressions générées. Par exemple:
> chatskills, ask hello to tell me hi
Hello, World!
> chatskills, ask hello to say hello
Hello, World!
> chatskills, ask hello to say howdy
Hello, World!
Pour créer un chatbot qui s'exécute localement sur la console, incluez simplement une boucle de lecture des entrées.
var readlineSync = require ( 'readline-sync' ) ;
// Console client.
var text = ' ' ;
while ( text . length > 0 && text != 'quit' ) {
text = readlineSync . question ( '> ' ) ;
// Respond to input.
chatskills . respond ( text , function ( response ) {
console . log ( response ) ;
} ) ;
}Si vous utilisez des appels asynchrones dans vos compétences (telles que des requêtes, etc.), vous souhaiterez utiliser une boucle asynchrone au lieu de la boucle while ci-dessus. Voici un exemple.
Vous n'êtes pas obligé d'utiliser uniquement la console ! Vous pouvez exécuter votre chatbot n'importe où, comme Slack. Voir ici pour un exemple complet.
var SlackBot = require ( 'slackbots' ) ;
var bot = new SlackBot ( { token : token , name : 'awesome' } ) ;
// Listen to slack messages.
bot . on ( 'message' , function ( message ) {
// Reply to humans.
if ( message . type == 'message' && message . text && message . subtype != 'bot_message' ) {
var author = getUserById ( message . user ) ;
var channel = getChannelById ( message . channel ) ;
// Respond to input, use author.name as the session id.
chatskills . respond ( message . text , author . name , function ( response ) {
if ( channel ) {
// Public channel message.
bot . postMessageToChannel ( channel . name , response ) ;
}
else {
// Private message.
bot . postMessageToUser ( author . name , response ) ;
}
} ) ;
}
} ) ; Les compétences sont des programmes que votre chatbot peut exécuter. Ils se composent d'intentions, composées d'énoncés (phrases correspondant à la saisie de l'utilisateur), de réponses et de mémoire de session. Chaque compétence peut accéder à la mémoire de session, ce qui vous permet de stocker et de récupérer des variables pour vous aider à répondre intelligemment à l'utilisateur.
Voici un exemple de création d'une nouvelle compétence, nommée « horoscope ».
var horoscope = chatskills . app ( 'horoscope' ) ; Les compétences sont constituées d'intentions. C'est ici que les entrées de l'utilisateur sont comparées à un ensemble d'énoncés. Lorsqu'une correspondance est trouvée, cette intention est exécutée. Une intention peut obtenir/définir des variables dans la session utilisateur en appelant req.get('variable') et req.set('variable', value) . Une intention peut générer une réponse en appelant res.say('hello') .
Voici un exemple de création d'une nouvelle intention pour la compétence « horoscope ».
horoscope . intent ( 'predict' , {
'slots' : { 'SIGN' : 'LITERAL' } ,
'utterances' : [ 'for {signs|SIGN}' ]
} ,
function ( req , res ) {
res . say ( 'Things are looking up today for ' + req . get ( 'SIGN' ) + '.' ) ;
}
) ;Cette intention peut être interagi comme ceci :
> chatskills, ask horoscope for Scorpio
Things are looking up today for Scorpio.
Il existe deux manières de commencer à exécuter une compétence.
La première façon de lancer une compétence consiste à créer une intention telle que « exécuter ». Cela vous permettrait de saisir : "chatskills, demandez à [skillname] de s'exécuter.". À condition que l'intention ait une valeur de retour true (pour maintenir la session active), votre compétence sera désormais exécutée.
Un exemple de compétence « courir » peut être trouvé dans le jeu de devinettes.
app . intent ( 'run' , {
"slots" : { } ,
"utterances" : [ "{to|} {run|start|go|launch}" ]
} , function ( req , res ) {
var prompt = "Guess a number between 1 and 100!" ;
res . say ( prompt ) . reprompt ( prompt ) . shouldEndSession ( false ) ;
}
) ; La deuxième façon de lancer une compétence consiste à créer une méthode de lancement qui s'exécutera automatiquement au démarrage de votre application. Ensuite, appelez simplement chatskills.launch(app) pour démarrer votre compétence. Vous pouvez transmettre la compétence ou le nom de la compétence. Vous pouvez également fournir un identifiant de session unique facultatif.
Exemple : chatskills.launch(app) ou chatskills.launch('horoscope') ou chatskills.launch('horoscope', 'some-unique-id') .
Voici un exemple complet.
var chatskills = require ( './lib/chatskills' ) ;
var readlineSync = require ( 'readline-sync' ) ;
// Create a skill.
var hello = chatskills . app ( 'hello' ) ;
// Launch method to run at startup.
hello . launch ( function ( req , res ) {
res . say ( "Ask me to say hi!" ) ;
// Keep session open.
res . shouldEndSession ( false ) ;
} ) ;
// Create an intent.
hello . intent ( 'helloWorld' , {
'slots' : { } ,
'utterances' : [ '{to |}{say|speak|tell me} {hi|hello|howdy|hi there|hiya|hi ya|hey|hay|heya}' ]
} ,
function ( req , res ) {
res . say ( 'Hello, World!' ) ;
}
) ;
// Start running our skill.
chatskills . launch ( hello ) ;
// Console client.
var text = ' ' ;
while ( text . length > 0 && text != 'quit' ) {
text = readlineSync . question ( '> ' ) ;
// Respond to input.
chatskills . respond ( text , function ( response ) {
console . log ( response ) ;
} ) ;
} Lorsqu'un utilisateur fournit une contribution, celle-ci est comparée à chaque compétence et à sa liste d'intentions. Lorsqu'une correspondance est trouvée, une nouvelle session démarre et la compétence commence à s'exécuter.
Lorsqu'une session a démarré pour un utilisateur, l'intention de la compétence activée peut obtenir/définir des valeurs variables au sein de la session. Cela vous permet de stocker et de récupérer des données.
Lorsqu'une session est ouverte pour un utilisateur, toutes les entrées de l'utilisateur sont dirigées vers la compétence activée. De cette manière, l'utilisateur n'a pas besoin de redemander une compétence (« chatskills, demander bonjour pour dire bonjour »). Au lieu de cela, l'utilisateur peut simplement fournir du texte, qui sera comparé aux intentions de la compétence en cours d'exécution.
Une intention peut maintenir une session ouverte en renvoyant true ou en appelant res.shouldEndSession(false) et mettre fin à une session en renvoyant false ou en appelant res.shouldEndSession(true) . Une intention peut également omettre une instruction return, ce qui revient à renvoyer false.
Pour un exemple d'utilisation de session, voir la compétence horoscope. Remarquez que l'intention pose une question à l'utilisateur, puis renvoie true pour poursuivre la session. L'intention ne renvoie false qu'une fois qu'une réponse valide est donnée, mettant ainsi fin à la session.
En résumé, lorsqu'une session utilisateur est ouverte, toutes les entrées de l'utilisateur sont dirigées vers la compétence. Lorsqu'une session utilisateur est terminée, les entrées de l'utilisateur doivent être reçues au format « chatskills, demander le texte [SKILL] » pour exécuter une nouvelle compétence.
Le délai d'expiration de session par défaut est d'une heure sans intervention de l'utilisateur. Pour modifier le délai d'expiration de la session, définissez chatskills.timeout = 3600 , où la valeur est spécifiée en secondes. Pour désactiver le délai d'expiration de la session, définissez la valeur sur 0.
Le nom du chatbot par défaut est « chatskills ». Toutes les demandes d'exécution d'une compétence doivent commencer par le nom du chatbot. Par exemple, "chatskills, demandez bonjour pour dire bonjour". Pour personnaliser le nom du chatbot, utilisez ce qui suit :
chatskills . name ( 'awesome' ) ; Pour afficher les avertissements et les erreurs, définissez chatskills.verbose = true .
Chatskills utilise Alexa-app pour générer de nombreux exemples d'énoncés à partir de vos intentions. Pour une description plus détaillée des énoncés, voir ici.
Transmettez un objet avec deux propriétés : les emplacements et les énoncés.
app . intent ( 'sampleIntent' ,
{
"slots" : { "NAME" : "LITERAL" , "AGE" : "NUMBER" } ,
"utterances" : [ "my {name is|name's} {names|NAME} and {I am|I'm} {1-100|AGE}{ years old|}" ]
} ,
function ( request , response ) { ... }
) ; L’objet slots est un simple mappage Name:Type. Le type doit être l'un des types d'emplacement pris en charge par Amazon : LITTERAL, NUMBER, DATE, TIME, DURATION
En remplacement du type d'emplacement LITERAL , qui n'est plus pris en charge par Amazon, il est recommandé d'utiliser des types d'emplacement personnalisés à la place. Voici un exemple de définition d'un type d'emplacement personnalisé pour DragonType .
app . intent ( 'attack' ,
{
'slots' : { 'DragonType' : 'DRAGONTYPE' } ,
'utterances' : [ '{attack|fight|hit|use} {sword|dagger|wand} on {-|DragonType} dragon' ]
} , function ( request , response ) {
response . say ( 'You are attacking the ' + request . slot ( 'DragonType' ) + ' dragon!' ) ;
}
) ; Vous pouvez inclure des types d'attributs personnalisés dans les énoncés à l'aide de la syntaxe {-|CustomTypeName} . Cela indique que le terme doit provenir d'une liste de valeurs pour le type d'emplacement personnalisé. Dans l'exemple ci-dessus, l'énoncé utilise le terme {-|DragonType} , indiquant qu'un terme doit provenir de la liste de valeurs (affichée ci-dessous). Pour les chatskills, une liste de valeurs n'a pas besoin d'être fournie - n'importe quel mot sera accepté pour un type d'emplacement personnalisé et utilisé comme valeur.
Si vous publiez sur le service Amazon Alexa, vous devez fournir les types d'emplacements personnalisés pour DragonType en spécifiant le nom du type et une liste de valeurs. Par exemple:
Type : DRAGONTYPE
Valeurs:
golden
fire
ice
water
snow
Notez que chatskills et Amazon Alexa accepteront n'importe quel mot pour la valeur de l'emplacement personnalisé. Il n'est pas nécessaire qu'il corresponde à un mot de la liste de valeurs. De cette manière, les types d'emplacements personnalisés sont similaires à LITERAL .
La syntaxe des énoncés vous permet de générer de nombreux (des centaines, voire des milliers) d'exemples d'énoncés en utilisant seulement quelques échantillons qui sont automatiquement développés. N'importe quel nombre d'échantillons d'énoncés peut être transmis dans le tableau d'énoncés. Vous trouverez ci-dessous quelques exemples de macros d’énoncés et ce à quoi elles seront étendues.
"my favorite color is {red|green|blue|NAME}"
=>
"my favorite color is {red|NAME}"
"my favorite color is {green|NAME}"
"my favorite color is {blue|NAME}"
Cela vous permet de définir plusieurs façons de prononcer une phrase, mais combinées en un seul échantillon d'énoncé.
"{what is the|what's the|check the} status"
=>
"what is the status"
"what's the status"
"check the status"
Lors de la capture d'une valeur d'attribut numérique, il est utile de générer de nombreux exemples d'énoncés avec différentes valeurs numériques.
"buy {2-5|NUMBER} items"
=>
"buy {two|NUMBER} items"
"buy {three|NUMBER} items"
"buy {four|NUMBER} items"
"buy {five|NUMBER} items"
Les plages de numéros peuvent également augmenter par étapes
"buy {5-20 by 5|NUMBER} items"
=>
"buy {five|NUMBER} items"
"buy {ten|NUMBER} items"
"buy {fifteen|NUMBER} items"
"buy {twenty|NUMBER} items"
"what is your {favorite |}color"
=>
"what is your color"
"what is your favorite color"
Plusieurs intentions peuvent utiliser la même liste de valeurs possibles. Vous souhaitez donc les définir au même endroit, et non dans chaque schéma d'intention. Utilisez le dictionnaire de l'application.
app.dictionary = {"colors":["red","green","blue"]};
...
"my favorite color is {colors|FAVEORITE_COLOR}"
"I like {colors|COLOR}"
Vous pouvez afficher les Amazon Alexa Home Cards en gérant l'objet carte renvoyé dans la méthode de réponse. Lorsque vous utilisez l'application Alexa, la carte d'accueil sera affichée dans l'application Amazon Alexa sur votre appareil mobile. Lors de l'utilisation de chatskills, la carte d'accueil peut être gérée dans la méthode de rappel chatskills.respond() , qui renvoie deux arguments : response et card .
À l'aide de l'objet carte, vous pouvez afficher le texte et l'image de la carte de la manière que vous souhaitez. Par exemple, si vous hébergez votre application Chatskills dans Slack, vous souhaiterez peut-être afficher l’image sous forme de média intégré. De même, si vous hébergez un chatbot textuel sur la console, vous souhaiterez peut-être simplement afficher la carte sous forme de texte.
Ci-dessous un exemple.
app . intent ( 'example' , {
"slots" : { } ,
"utterances" : [ "show a card" ]
} , function ( req , res ) {
// Show home card in Alexa app.
res . card ( {
type : 'Standard' ,
title : 'My Awesome Card' , // this is not required for type Simple or Standard
text : 'This is an example of an Alexa home card.' ,
image : { // image is optional
smallImageUrl : 'http://www.yoursite.com/image.jpg' , // required
largeImageUrl : null
}
} ) ;
} ) ;
// Respond to input.
chatskills . respond ( text , function ( response , card ) {
if ( ! card ) {
// Text response from res.say() method.
console . log ( response ) ;
}
else {
// Home card response from res.card() method.
console . log ( '[DISPLAYING CARD: Title=' + card . title + ', Text=' + card . text + ']' ) ;
}
} ) ; MIT
Kory Becker http://www.primaryobjects.com/kory-becker
