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.

Train an AI chatbot using blocks to define responses, set a welcome and default replies, add variations, and train phrases to handle diverse user inputs, then test NLP.

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.

Design a matcher function in Node.js that tests user input against a patterns array with xregexp, returning an intent and entities, or an empty object when no match.

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.

Capture entities from user input with capture groups and named capture groups, extracting keywords like hello, order, weather, and city using xregexp to power bot actions.

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 weather feature by connecting a chatbot to a weather API with axios, handling API keys, using async/await, and formatting three-day forecast data for a given location.

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.

Parse user weather questions by pattern matching the forecast text from the weather API, decide yes or no, and format a future-tense reply with date and location.

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.

Set up an express server to connect Vanilla to the messenger platform, creating server.js and wiring get and post routes. Return hello and use port from env or 3000.

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.

Configure page access tokens and verify tokens, register and verify webhooks on the messenger platform, and switch between development and production using a config loader and environment variables.

Define and instantiate a reusable F Beamer module in Node.js using ES6 classes to register Facebook Messenger webhooks and send text and image messages.

Register your chat bot webhook with the messenger platform by validating the verify token and returning the challenge code, establishing the secure https endpoint via Ngrok for local development.

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.

Register and verify the messenger webhook with Beamer, then parse incoming json payloads to extract user messages from the entry and messaging arrays, handling text and post backs.

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.

implement an img function to send images in messenger by building an image attachment payload with a url, default messaging_type to response, and sending via the send_message call.

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.

Explore deriving user intent and extracting entities like location from messages, then use wit.ai and machine learning through NLP to train models for weather queries and chatbots.

Train a Wit.ai natural language model by defining intents and entities with trait, free text, and keywords search strategies, then validate and improve extraction for movie info.

Train the Wit.ai model to recognize director intents and extract movie names, then refine labels and validate with more samples to improve accuracy.

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.

Create a movie info response by extracting title, year, and overview from TMDb data, and director details, then attach a poster image.

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.

Build a currency bot that accepts amount and currencies via natural language, uses a currency converter application programming interface, employs slot filling, and returns results after calls to the interface.

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.

Understand how intents serve as end-to-end units that extract entities and generate responses in API, with events, multiple intents, and fallback handling, including slot filling.

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.

Enable the Facebook Messenger integration and generate the page access token. Set up the webhook with the callback URL and verify token, subscribe to messages, and test that it works.

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.

Install the serverless framework CLI globally and verify it by running the version command, then follow a step-by-step setup as we build a bot.

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.

Handle the apply intent within the webhook by capturing parameters and storing them as a new row in a Google Sheets. Generate a numeric application code and notify the candidate.

Create a status intent to let users query job application status using an application code. Enable slot filling with a number integer entity named candidate code and wire webhook fulfillment.

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

Deploy a serverless function to aws lambda with the serverless framework. Generate a cloudformation template and package code into s3 for deployment.

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