Build Incredible Chatbots

Explore building a simple hello world chatbot with bot B using chat fuel on the Facebook Messenger platform, training the natural language processing model to map questions to responses.

Explore how to build and test a first chatbot using chatfuel on Facebook Messenger, with natural language processing mapping user inputs to responses you design using rules.

Build a rule-based weather bot like Poncho, and learn intents and entities, pattern matching, and how to fetch forecasts via a weather API.

Build an interactive terminal chatbot in NodeJS using the readline interface, pattern matching with regular expressions to fetch weather data from Yahoo Weather API and respond in the console.

Master regular expressions to identify patterns in text, validate inputs like emails and URLs, and power simple regex based bots before exploring natural language processing.

Master regular expressions for chatbots by learning word boundaries, optional quantifiers, capture groups, and patterns to match colors, pin codes, and emails using practical examples and testing tools.

Create a pattern dictionary of regex patterns and intents to recognize greetings and exit commands, then map user input to intents with a RegExp-based matcher.

Wire the matcher module in App.js and pass user input to the match pattern function, capturing results with data. Use a switch on intent to respond to hello with a big hello from vanilla, exit to end the session, and default to I don't know what you mean.

Develop a chatbot that outputs the current weather for a city by extracting the city with a named regex capture group and routing to the current weather intent.

Build a parser that converts weather API json into a human-like response by extracting location, condition, and temperature, then expressing temperature in words and forming grammatically correct sentences.

Map weather condition codes to present and future prefixes with a dictionary, build getPrefix(code, tense='present'), and generate sentences like it is sunny or it will be sunny.

Learn to craft a weather forecast pattern and capture the city and time from user queries using regex, capture groups, and a weather forecast intent in a NodeJS chatbot.

Explore building a simple rules-based chatbot that runs in the terminal, using regular expressions via the xregexp module in NodeJS to recognize intents and entities like weather.

Learn to deploy chatbots on the Facebook Messenger platform, leveraging a 900 million user base with either your own platform or bot-as-a-service, using rich UI widgets.

Understand the messenger platform's value and build a reusable NodeJS interface to send and receive messages on Facebook Messenger, deploy to the cloud, and review the approval process.

Create a Facebook app to connect your bot to the Messenger platform, obtain the page access token for your page, and incorporate that token into your chat bot app.

Register a webhook with Facebook to receive messages, verify payload authenticity with the x-hub-signature using sha1 and app secret, and parse json with body parser.

Learn to handle text messages in the Beamer interface by filtering the incoming payload into a simple, structured object, extracting sender IDs, and composing text replies.

Master the send API to reply to Facebook Messenger users by building a payload with recipient id, message content, and messaging_type, then posting to the messages endpoint.

Integrate vanilla with Facebook Messenger by routing text through a matcher, handle hello and weather intents, fetch Yahoo weather data, and respond via the php txt method.

Deploy a Node.js bot to Heroku using the Heroku CLI, configure the node version and environment variables, and push via git to a dyno while handling webhooks and production mode.

Prepare and submit your messenger bot for Facebook review by adding app details, privacy policy, conversation examples, and category, then enable production mode after approval.

Download the fbx starter kit for the femur module to start quickly, then create a new Facebook app, add Messenger, and set up webhooks for development to deployment.

Download and extract starter kit, rename the app to movie mate, then run npm install. Configure the page access token and verify token, then run nodemon and set up webhooks.

Train wit.ai to understand release year questions about movies, train and assign release year as the intent, and map the movie name to the movie entity.

Explore built-in NLP on Facebook Messenger that parses messages into date time and greetings. Integrate wit.ai for custom entities to enhance chatbot capabilities.

Extract entities from the messenger NLP data, fetch movie details using a tmdb module, obtain the movie's unique ID and director, and format a clear response for the user.

Sign up for a free tmdb account and obtain an API key, then use the search and movie endpoints to fetch Dunkirk's id, poster, overview, and credits.

Implement the getMovie data function to query the TMDB API with a movie name and optional year, returning id, title, overview, release date, and poster using async/await.

Write the get director function to fetch the movie's director names by ID, filter the crew for directors, map their names, and join them for the result.

Learn to service the director intent by constructing a response that combines the movie title, 'was directed by', and the director fetched via the get director function.

Deploy a weather bot to Heroku by configuring the start script and node version, initializing git, setting environment variables, and pushing to Heroku master.

Continue evolving your chat bot through testing and feedback, add testers in the Facebook dashboard to access the bot, and run a closed user group test to refine wit.ai model.

Build incredible chatbots by mastering natural language understanding with wit.ai, intents and entities, using movie mate, test users, and the movie db api with facebook nlp.

Explore API.ai as a leading natural language processing service; sign up, create an agent, train intents and entities, connect channels, use analytics, and leverage fulfillment for your chatbot.

build a currency converter intent that extracts amount and target currency, normalizes to symbols, and uses webhook fulfillment with slot filling and custom prompts.

Implement fulfillment with a webhook to connect the currency converter to external APIs, set up a Restify server, parse req.body payloads, extract parameters and entities, and return speech-ready responses.

Fetches latest currency rates from the fixer.io API to convert an amount between base and output symbols, computes the converted value, and returns it through the chatbot fulfillment.

Explore storing and using the output currency in a chatbot context, using set currency context and input context to power a currency converter intent with webhook integration.

Learn to manage chat context by creating a custom reset entity and a reset-context intent to delete the context and support currency changes.

Learn to rapidly connect your chatbot to dozens of channels with one-click integrations, using a NodeJS app and channel credentials, then deploy, test, and publish on Skype and beyond.

Integrate your bot with Slack by creating a Slack app, configuring a bot user, and enabling event subscriptions for direct messages and channel mentions.

This lecture summarizes how to use a Google-backed API-based NLP service for chatbots, detailing intents, entities, context objects, and webhooks for currency rates, with multi-platform bot integration.

Build incredible WhatsApp chatbots by linking Dialogflow and Twilio to a Google Sheets workflow that runs screening questions, generates application codes, and provides real-time status updates.

Create a new agent on Dialogflow for your WhatsApp bot, naming it 'bot worthy air bot' and enabling the option to create a new Google project.

Develop a dialogflow bot that talks to the whatsapp for business api using twilio's sandbox, enabling testing before formal business verification.

Connect Twilio to Dialogflow for the WhatsApp sandbox using a ready integration with an account SID, auth token, and number; test the bot on WhatsApp.

Reconfigure the welcome and default intents in Dialogflow to improve onboarding and guiding interactions. Replace canned messages with a single welcome and a clear fallback, then test responses.

Set up a service account and enable the Google Drive API to allow your Dialogflow NodeJS webhook to read and write Google Sheets as the chatbot's job listings database.

Set up a two-sheet Google Sheets file named bought worthy with Jobs and applications, using numeric IDs. Grant the webhook service account read/write access and securely manage credentials.

Set up an AWS account and install the AWS CLI to configure a programmatic user. Deploy a webhook as an AWS Lambda function with the Serverless framework and API Gateway.

Store secrets securely with AWS SSM parameter store, encrypting private keys and client emails as secure strings, then fetch them into a Node.js webhook without exposing them.

Set up a serverless webhook on AWS Lambda using a boilerplate, define an HTTP POST event with API Gateway, and run it locally with serverless offline for testing.

Develop a lambda function that fetches and decrypts the private key, client email, and sheet id from the SSM parameter store, governed by an IAM policy that allows Get parameters.

Learn to access and decrypt secrets from the parameter store in a webhook using params store and AWS SDK, and build a Sheets module to connect to Google Sheets.

Authorize with a service account to access the Sheets API and load the target spreadsheet, then implement a higher order function to access individual worksheets via the Google Spreadsheet package.

Create the get openings intent in Dialogflow, supply training phrases, and enable webhook fulfillment to fetch job openings from a worksheet and reply to users on WhatsApp.

Build a webhook handler for the get openings intent that reads a Google Sheets jobs worksheet, formats job IDs and titles, and returns a Dialogflow JSON response for WhatsApp.

Test the webhook offline by running the serverless function with Ngrok, configure the region, and enable the Dialogflow webhook to test job queries.

Create an apply intent that captures a job code as a required parameter, uses slot filling and a webhook to store data in the applications worksheet on Google Sheets.

Builds the status intent handler that queries a sheet for the candidate code and returns pending, shortlisted, or rejected statuses.

Develop a WhatsApp for business bot with Twilio and Dialogflow, backed by Google Sheets, and deployed serverless on AWS Lambda via the Serverless Framework.