Creating Custom Food Fact Skill Using Fact Skill Template

Introduction

Here is another article on custom Alexa skills. In this article, I am going to demonstrate how to create a custom Alexa skill on Alexa Hosted node.js server. For that, I will be creating a custom Alexa skill named Food Fact. With the help of this skill, users can ask Alexa to fetch a random fact about food, and Alexa will fetch facts about food at random and prompt a message giving information about any particular food.

Each time Alexa asks if the user wants to know any facts about different food items. The users can give a response by saying for example “give me a food fact”. Alexa will fetch facts about food at random and prompt a message giving information about any particular food. The backend code required for the Alexa skill to work will be stored in a lambda function inside the Amazon developer console.

Creating an Alexa Skill

To create a new skill, first we need to login to the Alexa developer console. Then, we need to mention the unique skill name and select the default language according to our location.

After that, we can choose a model to add to our skill. To create a custom skill, we can select Custom model.

We can also choose a method or a template to host the skill’s backend code inside a lambda function.

We can choose Alexa hosted node.js or Python template. We can also mention our own endpoint or server to store backend resources for the required Alexa skills.

The next step is to choose a template to add to our skill, which we customize later according to our need and click on the Create Skill button. Now that a skill has been created, we need to make adjustments to the skill’s frontend. I will be creating intents, slots, and custom slot types to create the skill’s frontend.

First, we need to mention the invocation name. Users say a skill's invocation name to begin an interaction with a particular custom skill.

Now we have to create intents:

Here, I have added a new intent named FoodFacts along with some sample utterances such as give me a food fact, tell me a food fact. No slots and custom slot types are defined for this Alexa skill.

After creating a model for a particular skill, we can save and build the model by clicking on the save model and build model button on the top.

Json code for the above frontend is as follows:

{
"interactionModel": {
"languageModel": {
"invocationName": "food facts",
"intents": [
{
"name": "AMAZON.CancelIntent",
"samples": []
},
{
"name": "AMAZON.HelpIntent",
"samples": []
},
{
"name": "AMAZON.StopIntent",
"samples": []
},
{
"name": "AMAZON.NavigateHomeIntent",
"samples": []
},
{
"name": "FoodFacts",
"slots": [],
"samples": [
"give me a food fact",
"amazing food facts",
"a food fact",
"food facts",
"tell me a food fact"
]
}
],
"types": []
}
}
}

Creating the backend resource for the Alexa skill

To create backend code inside the lambda function, we can write code inside the index.js node.js file. The code for the custom Alexa skill is as follows:

const Alexa = require('ask-sdk-core');
const data = [
'Green, yellow, and red bell peppers are not actually the same vegetable.',
'white chocolate is not actually chocolate at all.',
'Scientists can turn peanut butter into diamonds.',
'Ripe cranberries will bounce like rubber balls.',
'Chocolate was once used as currency.',
'Fruit snacks and cars are coated in the same type of wax.',
'Potatoes can absorb and reflect Wi-fi signals.',
];
const GET_FACT_MESSAGE = "This is your Fact " ;
const LaunchRequestHandler = {
canHandle(handlerInput) {
return handlerInput.requestEnvelope.request.type === 'LaunchRequest';
},
handle(handlerInput) {
const speechText = 'Welcome to food fact. you can ask me about a food fact';
return handlerInput.responseBuilder
.speak(speechText)
.reprompt(speechText)
.getResponse();
}
};
const FoodFactsHandler = {
canHandle(handlerInput) {
return handlerInput.requestEnvelope.request.type === 'IntentRequest'
&& handlerInput.requestEnvelope.request.intent.name === 'FoodFacts';
},
handle(handlerInput) {
const factArr = data;
const factIndex = Math.floor(Math.random() * factArr.length);
const randomFact = factArr[factIndex];
const speechOutput = GET_FACT_MESSAGE + randomFact;
const speechText = speechOutput;
return handlerInput.responseBuilder
.speak(speechText)
.reprompt(speechText)
.getResponse();
}
};
const HelpIntentHandler = {
canHandle(handlerInput) {
return handlerInput.requestEnvelope.request.type === 'IntentRequest'
&& handlerInput.requestEnvelope.request.intent.name === 'AMAZON.HelpIntent';
},
handle(handlerInput) {
const speechText = 'You can ask me about a food fact';
return handlerInput.responseBuilder
.speak(speechText)
.reprompt(speechText)
.getResponse();
}
};
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 = 'Goodbye!';
return handlerInput.responseBuilder
.speak(speechText)
.getResponse();
}
};
const SessionEndedRequestHandler = {
canHandle(handlerInput) {
return handlerInput.requestEnvelope.request.type === 'SessionEndedRequest';
},
handle(handlerInput) {
// Any cleanup logic goes here.
return handlerInput.responseBuilder.getResponse();
}
};
// The intent reflector is used for interaction model testing and debugging.
// It will simply repeat the intent the user said. You can create custom handlers
// for your intents by defining them above, then also adding them to the request
// handler chain below.
const IntentReflectorHandler = {
canHandle(handlerInput) {
return handlerInput.requestEnvelope.request.type === 'IntentRequest';
},
handle(handlerInput) {
const intentName = handlerInput.requestEnvelope.request.intent.name;
const speechText = `You just triggered ${intentName}`;
return handlerInput.responseBuilder
.speak(speechText)
//.reprompt('add a reprompt if you want to keep the session open for the user to respond')
.getResponse();
}
};
// Generic error handling to capture any syntax or routing errors. If you receive an error
// stating the request handler chain is not found, you have not implemented a handler for
// the intent being invoked or included it in the skill builder below.
const ErrorHandler = {
canHandle() {
return true;
},
handle(handlerInput, error) {
console.log(`~~~~ Error handled: ${error.message}`);
const speechText = `Sorry, I couldn't understand what you said. Please try again.`;
return handlerInput.responseBuilder
.speak(speechText)
.reprompt(speechText)
.getResponse();
}
};
// This handler acts as the entry point for your skill, routing all request and response
// payloads to the handlers above. Make sure any new handlers or interceptors you've
// defined are included below. The order matters - they're processed top to bottom.
exports.handler = Alexa.SkillBuilders.custom()
.addRequestHandlers(
LaunchRequestHandler,
FoodFactsHandler,
HelpIntentHandler,
CancelAndStopIntentHandler,
SessionEndedRequestHandler,
IntentReflectorHandler) // make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers
.addErrorHandlers(
ErrorHandler)
.lambda();

To receive requests from the user, request handlers are created for each intent to handle. Inside each handlers, canHandle and handle functions are defined.

The canHandle() function is where you define what requests the handler responds to. The handle() function returns a response to the user. If your skill receives a request, the canHandle() function within each handler determines whether or not that handler can service the request.

In this case, the user wants to launch the skill, which is a LaunchRequest. Therefore, the canHandle() function within the LaunchRequestHandler will let the SDK know it can fulfill the request. In computer terms, the canHandle returns true to confirm it can do the work.

With the help of LaunchRequestHandler, Alexa greets the user by saying welcome to food fact and tells the user that he/she ask Alexa about random food facts. She also asks the user if he/she wants to know any random facts about food items.

After that, FoodFactsHandler is defined to handle each and every request of the user to know a random food fact. This handler will enable Alexa to tell users a random fact about any food item and also asks the user if he/she wants to know about any more facts.

As we can see from the above code, inside the handle() function an array name containing some random facts about food items is defined. With the help of math.random function, a fact is extracted at random from the array and then displayed to the user by Alexa.

Output

As we can see from the output above, to invoke a skill, the user can say open followed by invocation name. Here food facts is an invocation name to invoke this skill. Alexa then greets the user by saying welcome to food fact and tells the user that he/she ask Alexa about random food facts.

Users can ask Alexa for a random fact by saying get me a food fact, which is a sample utterance defined for the skill. In response, Alexa tells a random fact about any food item.

Summary

In this article, I created a custom Alexa skill. I also defined the invocation name, intents, and sample utterances. I demonstrated the method to generate random facts about food items each time a user asks for it. Proper code snippets along with the output for the backend of the skill are also provided.