API7.ai is an open-source software infrastructure company that empowers API management and analysis. We provide a wide range of products for microservices and real-time traffic processing, such as API Gateway, Kubernetes Ingress Controller and Service Mesh. Apache APISIX, a top-level project donated by API7.ai to the Apache Software Foundation, is the next generation of cloud-native API gateway that provides rich traffic management functions such as load balancing, dynamic upstream, canary release, circuit breaking, authentication and authorization, and observability. Built on Apache APISIX, the enterprise-grade API7 products provide more advanced capabilities to meet the core requirements of enterprise users: multi-tenancy, multi-cluster management, role-based access control (RBAC), API audits and much more. Whether your services are on-premises, on the hybrid cloud, or multi-cloud, you will get the solution best suited to your needs. Apache APISIX and API7 products are used by thousands of companies worldwide across the internet, financial, blockchain, manufacturing, retail and IoT industries. Founded in 2019, API7.ai has attracted global talents from 6 countries and 20 cities, many of whom are Apache Software Foundation members, OpenResty / Nginx core maintainers, Kubernetes members and industry experts in cloud infrastructure and security.

API7.ai

api7ai

Last year, I wrote my first . I liked the experience, so I'm trying one more time. Let the future decide if it will become a trend or not. yearly retrospective Before diving into our safe technological world, my thoughts go to Ukraine, to my friends who had to flee their own country, to other friends who fought on the front to defend it from an imperial power, and to all victims of an old kleptocrat who clings to power despite the cost to others. The free world needs to support Ukraine more. I hope 2024 will be the year of Ukrainian victory. The AI revolution Last year, I kept the post focused on what I did. However, AI is pervasive in our tech world, if not the whole world, and deserves a dedicated section. Nobody even remotely connected to tech can ignore the buzz surrounding AI. Even friends and families who don't work near tech probably talk about it. So far, I didn't weave any AI-related thing into any of my talks, despite the huge incentive to do so: having AI in your Call For Paper proposal vastly increases your chances of being selected. And yet, it doesn't mean that I'm not playing with it on a personal level. Here's my experience so far. I've been playing with Dall-E as a use case to try out web development in Rust. I found the results mind-blowing. However, the limitations are enormous; it seems the size is always square, and the set of possible dimensions is limited. I've used ChatGPT in several areas. First, I tried to generate conference abstracts. I fed an entire blog post and asked ChatGPT to turn it into an abstract. Despite my lack of prompt engineering skills, I've found results severely lacking. Abstracts felt artificial, like any content created with ChatGPT, but worse, the abstract revealed too much or not enough. I also tried to use it to refactor two nested Kotlin statements, one nested in the other, to the null-safe construct. The first result didn't compile; the second one forgot a branch. It led me to the correct solution, though. if else let Finally, I recently started using GitHub Copilot as an extension inside of IntelliJ IDEA. Its behavior is fascinating: most of the time, it does nothing, but once in a while, it offers a snippet of a couple of lines, which is either entirely correct or at least very close to the target solution. Even better, the suggestions seem to be more frequent and even more relevant with time. All in all, I'm far from impressed by the current state of AI. However, I like Copilot a lot: I prefer rare advice, which is relevant, than the opposite. Technical content Next February will mark the two-year milestone that I'm working for: on . I'm still very pleased about both. It allows me to do things I like a lot, such as writing posts and giving talks. API7.ai Apache APISIX In 2023, I published fifty blog posts on : one each week on Sunday, but on Christmas and the New Year - for obvious reasons. Here are the top most viewed pages: this blog Rank Post Views Avg. time on page #1 Leverage the richness of HTTP status codes 14,848 :29 #2 A list of cache providers 12,770 1:15 #3 Calling Rust from Python 8,780 :52 #4 My final take on Gradle (vs. Maven) 8,238 2:11 #5 Learning by doing: An HTTP API with Rust 6,642 1:00 I continue to cross-post on different sites. Here are the numbers compared with last year's: Site 2023 2022 Medium 741 564 Dev.to 8156 1,838 Hashnode 89 80 Absolute numbers are not that interesting, but comparing them is. Interestingly, numbers on are growing wildly, while on Hashnode, they plateau. Note that other sites provide no precise follower count or no count. dev.to Besides, I created a script to track daily metrics across sites and social media, just as I did for Apache APISIX. It displays interesting results: As above, numbers are much less important than the trend. Growth visibly happens mainly on and Bluesky for reasons I cannot fathom (yet?). dev.to Finally, I started a weekly newsletter, unoriginally named A Java Geek weekly. So far, I've written a . I list the posts and videos I found interesting during the week. Note that they contain the same links I post on , , and , with a bit more content, either a summary or my opinion. couple of them LinkedIn Mastodon BlueSky Open Source contributions In 2023, after over twenty years in software, I finally became ! I'm both excited and impressed; it's like belonging to a group of mythical beings I'd only heard about. an Apache committer Of course, working on Apache APISIX helped a lot. Yet, the exciting bit is that all my contributions are entirely unrelated to code; they are blog posts, reviews of blog posts written by others, issues, comments on issues, etc. Here's the GitHub summary: Conclusion Last year, my resolutions were: To deepen my understanding of the Apache APISIX ecosystem Write as many blog posts as in 2022 - it's hard to do better, anyway Design at least three new talks I fulfilled the two first goals but unfortunately failed the last item. I have only created two new talks, both based on previous posts. I'll keep them secret for now; they should appear soon on my page in case they are selected. Speaking I lack imagination, so I'll keep the same goals for this year as last year's and add exploring the ecosystem as well. Let's see how it fares. Happy New Year! API7.ai Originally on on January 7th, 2024 published A Java Geek

Everything I Achieved in 2023

is an excellent key-value distributed database used internally by Kubernetes and managed by the CNCF. It's a great option, and that's the reason why Apache APISIX uses it too. Yet, it's not devoid of issues. etcd First, some mention scalability, but one can expect this from a distributed data store that values consistency. Another issue may be the need for more familiarity with etcd. It's relatively new, so your Ops team may need help operating it correctly while having decades of operating MySQL or Postgres. Finally, only a few etcd users are aware that it lacks maintainers: In the last few months, primary maintainers G.L. (Amazon, announcement) and S.B. (Red Hat) have stopped actively participating in the project. This leaves the project with only one active and two occasionally-reviewing maintainers, M.S. (Google),  P.T. (Google), both are relatively new to the project (1 month and 1 year of tenure) and S.P.Z. (IBM). Other maintainers are either dormant or have very minimal activity over the last six months. . The project is effectively unmaintained (emphasis mine) -- Google Groups of Kubernetes Steering Committee, March 2022 For all those reasons, you may prefer to use a standard SQL database with Apache APISIX. In this post, I'll show how you can use MySQL. The kine project It would be a lot of effort if each product had to introduce an abstraction layer and different adapters for both etcd and other databases. kine is a project that aims to offer a translation step between etcd calls and other implementations: Kine is an etcdshim that translates etcd API to: SQLite Postgres MySQL NATS Jetstream Features Can be ran standalone so any k8s (not just K3s) can use Kine Implements a subset of etcdAPI (not usable at all for general purpose etcd) Translates etcdTX calls into the desired API (Create, Update, Delete) -- Kine (Kine is not etcd) In essence, kine is a Go library that translates etcd calls to the datastore you want (among those implemented). Yet, using kine directly is a non-trivial effort. Fortunately, , the company that gave Apache APISIX to the Apache Software Foundation, provides a component already focused on APISIX usage. api7 ETCD adapter ETCD adapter wraps kine to be APISIX-specific: ETCD Adapter mimics the ETCD V3 APIs best effort. It incorporates the kine as the Server side implementation, and it develops a totally in-memory watchable backend. Not all features in ETCD V3 APIs supported, this is designed for Apache APISIX, so it's inherently not a generic solution. -- ETCD adapter Two things of note: At the moment of this writing, the adapter supports either local in-memory storage or MySQL It's available as an embeddable library but also as a standalone component Therefore, we can design our architecture as the following: Demo Let's implement the above architecture with an additional admin UI over MySQL. I'll use Docker Compose: version: "3"

services:
  apisix:
    image: apache/apisix:3.4.0-debian                         #1
    volumes:
      - ./config.yaml:/usr/local/apisix/conf/config.yaml:ro
    ports:
      - "9080:9080"
      - "9180:9180"
    depends_on:
      - etcd-adapter
    restart: always                                           #2
  etcd-adapter:
    build: ./etcd-adapter                                     #3
    volumes:
      - ./adapter.yml:/etcd-adapter/conf/config.yaml:ro       #4
    depends_on:
      - mysql
    restart: always                                           #2
  mysql:
    image: bitnami/mysql:8.0                                  #5
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_USER: etcd
      MYSQL_PASSWORD: etcd
      MYSQL_DATABASE: apisix
  adminer:
    image: adminer:standalone                                 #6
    ports:
      - "8080:8080"
    environment:
      ADMINER_DEFAULT_SERVER: mysql
    depends_on:
      - mysql Latest version of Apache APISIX, yeah! To avoid any failure with dependencies between containers, restart until it works. Kubernetes's manifests would involve health checks still needs to provide a container. We need to build from the source code api7.ai Override the default configuration file with a context-specific one The regular MySQL image didn't work for me. Let's take the one from Bitnami Adminer, formerly known as PHP myAdmin, will help to visualize the database state ETCD-adapter's configuration looks like this: server:
  host: 0.0.0.0                 #1
  port: 12379

log:
  level: info

datasource:
  type: mysql                   #2
  mysql:
    host: mysql                 #3
    port: 3306                  #3
    username: etcd              #3
    password: etcd              #3
    database: apisix Bind any IP since Docker will assign a random one Implementation type. The default is ; we need to change it. btree As configured in the file docker-compose.yml Finally, here's Apache APISIX configuration: deployment:
  admin:
    allow_admin:
      - 0.0.0.0/0
  etcd:
    host:
      - "http://etcd-adapter:12379"   #1 Use this etcd instance, which is the adapter Testing Now that we are set let's test our system by creating a route: curl -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '{                                          
  "methods": ["GET"],
  "uris": ["/get"],
  "upstream": {
    "nodes": {
      "httpbin.org:80": 1
    }
  }
}' http://localhost:9180/apisix/admin/routes/1 We can now get it: curl -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' http://localhost:9180/apisix/admin/routes/1 We can also check via the Adminer interface that it has been persisted via MySQL: Unfortunately, we need to stop at this point. Getting all routes doesn't work: curl -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' http://localhost:9180/apisix/admin/routes {"header":{"revision":"1689689596"},"message":"Key not found"} Worse, using the route fails: curl localhost:9080/get {"error_msg":"404 Route Not Found"} Conclusion etcd is an excellent piece of infrastructure Kubernetes uses, but there might be better choices in some contexts. Worse, it might become a security threat in the future - or is already one, because of the lack of maintenance. Being able to move away from etcd is a considerable benefit. kine offers an etcd-compatible facade and multiple implementations. Using kine with Apache APISIX requires some adaptation effort, already done in ETCD-Adapter. Currently, ETCD-Adapter is not feature-complete (to say the least) and requires more love. That's why it was not donated to the Apache Foundation yet. If you're a Go developer and are interested in the project, feel free to subscribe to the to offer your help. Apache APISIX mailing list and/or join our Slack The complete source code for this post can be found on . GitHub To go further: Kine ETCD Adapter "Goodbye etcd, Hello PostgreSQL: Running Kubernetes with an SQL Database" Originally published at on July 23rd, 2023 A Java Geek

Apache APISIX Without etcd?

In the world full of Siri, Cortana & Alexa, have you ever wondered you can create a new friend of yours. Well it might not be that intelligent but it not worthless to try creating  something new. With the current state of web apps, we can rely on various UI elements to interact with users. With the Web Speech API, we can develop rich web applications with natural user interactions and minimal visual interface, using voice commands. This enables countless use cases for richer web applications. Moreover, the API can make web apps accessible,helping people with physical or cognitive disabilities or injuries. The future web will be more conversational and accessible! Here, we will use the API to create an artificial intelligence (AI) voice chat interface in the browser. The app will listen to the user’s voice and reply with a synthetic voice. Because the Web Speech API is still experimental, the app works only in . The features used for this article, both speech recognition and speech synthesis, are currently only in the Chromium-based browsers, including Chrome 25+ and Opera 27+, while Firefox, Edge and Safari support only speech synthesis at the moment. supported browsers Let's get started To build the web app, we’re going to take three major steps: Use the Web Speech API’s interface to listen to the user’s voice. Speech Recognition Send the user’s message to a commercial natural-language-processing API as a text string. Once API.AI returns the response text back, use the SpeechSynthesis interface to give it a synthetic voice. Requirements and Installations Supported browser Installation of Node.js Installation of node modules like: : APIAI npm i apiai : Socket.io npm install socket.io : dotenv npm i dotenv-extended : Express npm install express --save Setting Up Your Application Set up a web app framework with Node.js. Create your app directory, and set up your app’s structure like this: .
├── index.js
├── files
│   ├── css
│   │   └── style.css
│   └── js
│       └── script.js
└── views
    └── index.html Then, run this command to initialize your Node.js app: npm init This will generate a package.json file that contains the basic info for your app. Now, install all of the dependencies needed to build this app: $ npm i apiai
$ npm install socket.io
$ npm i dotenv-extended
$ npm install express --save We are going to use , a Node.js web application server framework, to run the server locally. To enable real-time bidirectional communication between the server and the browser, we’ll use . Also, we’ll install the natural language processing service tool, in order to build an AI chatbot that can have an artificial conversation. Express Socket.IO APIAI Socket.IO is a library that enables us to use WebSocket easily with Node.js. By establishing a socket connection between the client and server, our chat messages will be passed back and forth between the browser and our server, as soon as text data is returned by the Web Speech API (the voice message) or by API.AI API (the “AI” message). Now, let’s create an file and instantiate Express and listen to the server: index.js ; apiai = ( ); APIAI_TOKEN =apiai( ); APIAI_SESSION_ID = ; express = ( ); app = express();

app.use(express.static(__dirname + )); 
app.use(express.static(__dirname + )); server = app.listen(process.env.PORT || , () => { .log( , server.address().port);
}); io = ( )(server);
io.on( , { .log( );
}); app.get( , (req, res) => {
  res.sendFile( );
});

io.on( , {
  socket.on( , (text) => { .log( + text); apiaiReq = APIAI_TOKEN.textRequest(text, { : APIAI_SESSION_ID
    });

    apiaiReq.on( , (response) => { aiText = response.result.fulfillment.speech; .log( + aiText);
      socket.emit( , aiText);
    });

    apiaiReq.on( , (error) => { .log(error);
    });

    apiaiReq.end();

  });
}); 'use strict' var require 'apiai' var " " //use a api token from the official site const " " //use a session id const require 'express' const '/views' '/files' const 3000 console 'Server listening on port %d ' const require 'socket.io' 'connection' ( ) function socket console 'a user connected' // Web UI '/' 'index.html' 'connection' ( ) function socket 'chat message' console 'Message: ' // Get a reply from API.ai let sessionId 'response' let console 'Bot reply: ' 'bot reply' 'error' console Now,we will integrate the front-end code with the Web Speech API. Creating The User Interface The UI of this app is simple: just a button to trigger voice recognition. Let’s set up our index.html file and include our front-end JavaScript file (script.js) and Socket.IO, which we will use later to enable the real-time communication: Recognito Recognito You said: ... Recognito replied: ... <!DOCTYPE html> < = > html lang "en" < > head < = > meta charset "utf-8" < = = > meta http-equiv "X-UA-Compatible" content "IE=edge,chrome=1" < = = > meta name "viewport" content "width=device-width" < > title </ > title < = = > link rel "stylesheet" href "https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" < = = = > link rel "stylesheet" type "text/css" href "css/style.css" </ > head < > body < > section < > h1 </ > h1 < = > button id "btn" < = > i class "fa fa-microphone" </ > i </ > button < > div < > p < = > em class "output-you" </ > em </ > p < > p < = > em class "output-bot" </ > em </ > p </ > div </ > section < = > script src "socket.io/socket.io.js" </ > script < = > script src "js/script.js" </ > script </ > body </ > html To style the button , refer to the style.css file in the . source code Capturing Voice With JavaScript In , invoke an instance of , the controller interface of the Web Speech API for voice recognition: script.js SpeechRecognition We’re including both prefixed and non-prefixed objects, because Chrome currently supports the API with prefixed properties. Also, we are using some of ECMAScript 6 syntax in this tutorial, because the syntax, including the const and arrow functions, are available in browsers that support both Speech API interfaces, and Speech Recognition SpeechSynthesis. Optionally, you can set varieties of to customize speech recognition: properties recognition.lang = ;
recognition.interimResults = ; 'en-US' false Then, capture the DOM reference for the button UI, and listen for the click event to initiate speech recognition. .querySelector( ).addEventListener( , () => {
  recognition.start();
}); document 'button' 'click' Once speech recognition has started, use the result event to retrieve what was said as text. This will return a SpeechRecognitionResultList object containing the result, and you can retrieve the text in the array. Also, as you can see in the code sample, this will return confidence for the transcription, too. recognition.addEventListener( , (e) => { last = e.results.length - ; text = e.results[last][ ].transcript; .log( + e.results[ ][ ].confidence); }); 'result' let 1 let 0 console 'Confidence: ' 0 0 // We will use the Socket.IO here later… Real-Time Communication With Socket.IO is a library for real-time web applications. It enables real-time bidirectional communication between web clients and servers. We are going to use it to pass the result from the browser to the Node.js code, and then pass the response back to the browser. Socket.IO You may be wondering why are we not using simple HTTP or AJAX instead. You could send data to the server via POST. However, we are using WebSocket via Socket.IO because sockets are the best solution for bidirectional communication, especially when pushing an event from the server to the browser. With a continuous socket connection, we won’t need to reload the browser or keep sending an AJAX request at a frequent interval. Instantiate Socket.IO in script.js somewhere: socket = io(); const Then, insert this code where you are listening to the result event from SpeechRecognition: socket.emit( , text); 'chat message' Now, let’s go back to the Node.js code to receive this text and use AI to reply to the user. To build a quick conversational interface, we will use because it provides a free developer account and allows us to set up a small-talk system quickly using its web interface and Node.js library. API.AI Setting Up APIAI Use this for reference: APIAI_TOKEN =apiai( ); APIAI_SESSION_ID = ; var "5afc4bdf601046b39972ff3866cca392" const "chatbot-clvxfh" or get your own by visiting the official site( )and signing up. Getting Started Now we will use the server-side Socket.IO to receive the result from the browser. io.on( , {
  socket.on( , (text) => { apiaiReq = apiai.textRequest(text, { : APIAI_SESSION_ID
    });

    apiaiReq.on( , (response) => { aiText = response.result.fulfillment.speech;
      socket.emit( , aiText); });

    apiaiReq.on( , (error) => { .log(error);
    });

    apiaiReq.end();

  });
}); 'connection' ( ) function socket 'chat message' // Get a reply from API.AI let sessionId 'response' let 'bot reply' // Send the result back to the browser! 'error' console Once the connection is established and the message is received, use the API.AI APIs to retrieve a reply to the user’s message.When API.AI returns the result, use Socket.IO’s to send it back to the browser. socket.emit() Giving   Voice  to the bot With The SpeechSynthesis Interface Create a function to generate a synthetic voice. This time, we are using the SpeechSynthesis controller interface of the Web Speech API. The function takes a string as an argument and enables the browser to speak the text: { synth = .speechSynthesis; utterance = SpeechSynthesisUtterance();
  utterance.text = text;
  synth.speak(utterance);
} ( ) function synthVoice text const window const new In the function, first, create a reference to the API entry point, . You might notice that there is no prefixed property this time: This API is more widely supported than SpeechRecognition, and all browsers that support it have already dropped the prefix for SpeechSysthesis. window.speechSynthesis Then, create a new instance using its constructor, and set the text that will be synthesised when the utterance is spoken. You can set other , such as voice to choose the type of the voices that the browser and operating system should support. SpeechSynthesisUtterance() properties Finally, use the to let it speak! SpeechSynthesis.speak() Now, get the response from the server using Socket.IO again. Once the message is received, call the function. ; socket = io(); outputYou = .querySelector( ); outputBot = .querySelector( ); SpeechRecognition = .SpeechRecognition || .webkitSpeechRecognition; recognition = SpeechRecognition();

recognition.lang = ;
recognition.interimResults = ;
recognition.maxAlternatives = ; .querySelector( ).addEventListener( , () => {
  recognition.start();
});

recognition.addEventListener( , () => { .log( );
});

recognition.addEventListener( , (e) => { .log( ); last = e.results.length - ; text = e.results[last][ ].transcript;

  outputYou.textContent = text; .log( + e.results[ ][ ].confidence);

  socket.emit( , text);
});

recognition.addEventListener( , () => {
  recognition.stop();
});

recognition.addEventListener( , (e) => {
  outputBot.textContent = + e.error;
}); { synth = .speechSynthesis; utterance = SpeechSynthesisUtterance();
  utterance.text = text;
  synth.speak(utterance);
}

socket.on( , {
  synthVoice(replyText); (replyText == ) replyText = ;
  outputBot.textContent = replyText;
}); 'use strict' const const document '.output-you' const document '.output-bot' const window window const new 'en-US' false 1 document 'button' 'click' 'speechstart' console 'Speech has been detected.' 'result' console 'Result has been detected.' let 1 let 0 console 'Confidence: ' 0 0 'chat message' 'speechend' 'error' 'Error: ' ( ) function synthVoice text const window const new 'bot reply' ( ) function replyText if '' '(No answer...)' It's done.Run the following command in your terminal. $ node index.js And search in any supported browser. localhost:3000 You can refer to my for further help. repository References https://caniuse.com/#search=speech https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition https://www.npmjs.com/package/apiai https://socket.io/ https://www.npmjs.com/package/dotenv-extended https://expressjs.com/

Creating A Chatbot Using Socket.io, API.AI and Web Speech API

In this article, we will be sharing steps to integrate chatbot into your app. All you need to build a sample for an android app is and dialogflow Android chatbot Dialogflow Kommunicate. Below is an example of developed in android using Dialogflow. We actually use this bot on our website. If you wish to see the bot live in action, head . Kommunicate Support Bot here The actionable rich messaging powered bot can reply based on whether users are on chat for general queries, technical queries or scheduling a demo. You can use your existing dialogflow bot or checkout to build a qualifying bot of your own. Download the Kommunicate Support Bot from and import into your Dialogflow account. bot samples here Step 1: Setup an account in Kommunicate This is fairly simple. You can get a free account in . Signup and navigate to the . Click on in Dialogflow block. Kommunicate Bot section Settings Upload your Dialogflow provided client keys. In case you are using Dialogflow V1, you can copy paste your client and dev tokens. Though, we recommend using Dialogflow V2 for the latest capabilities. Step 2: Install Dialogflow integrated Android Chatbot SDK into your app Add Android SDK to your app Installing Kommunicate in your Android app is easy and fast. Kommunicate SDK comes with pre-configured dialogflow integration. Add the following in your app build.gradle dependency: Installation implementation 'io.kommunicate:kommunicate:1.6.3' **Initialize SDK**After the Gradle sync has finished with kommunicate dependency, you can initialize the SDK by calling the below method: Kommunicate.init(context, Your-APP-Key); You can get the Application Key by signing up on Kommunicate Dashboard.For full documentation, refer . here Sample Android app with Dialogflow Chatbot Here is a sample android app which has dialogflow chatbot integrated. and run it in android studio. Download Step 3: Launch Android chat app with Dialogflow integrated chatbot Now, you can send payload to dialogflow through chat screen and get text response from Dialogflow Agent.Kommunicate provides a ready to use Chat UI so only launching the chat screen is required in this step. Here are the instructions for launching the chat with Dialogflow bot: List<String> agentList = new ArrayList();agentList.add("agent1@yourdomain.com"); //add your agentID List<String> botList = new ArrayList();botList.add("bot1"); //enter your integrated bot Ids Kommunicate.launchSingleChat(context, "Support", Kommunicate.getVisitor(), false, true, agentList, botList, new KmCallback(){@Overridepublic void onSuccess(Object message) {Log.d(context, "ChatLaunch", "Success : " + message);} @Overridepublic void onFailure(Object error) {Log.d(context, "ChatLaunch", "Failure : " + error);}}); That’s all! Run the Android app and chat with the Dialogflow bot. You can easily integrate Dialogflow in Android apps in a few simple steps. In case you need more information, you can check out the Kommunicate documentation. Dialogflow Android SDK Dialogflow provides Android Client SDK that makes it easy to integrate speech recognition with API.AI natural language processing API on Android devices. If you are looking to develop your own chat implementation and directly integrate dialogflow into your android app without kommunicate SDK, then integrate with the following SDK. Github — Dialogflow Android Client SDK Read more about dialogflow and bot integration here: Integrate Dialogflow (Api.ai) Bot into Website Beginner’s Guide to Creating Chatbots Using Dialogflow This article is originally published . here

Build Android Chatbot with Dialogflow (API.ai)

(formerly ) gives users new ways to interact with your bot by building engaging voice and text-based conversational interfaces powered by . DialogFlow API.AI AI offers many in different programming languages: DialogFlow SDKs But unfortunately, there’s no for SDK Golang But dont be sad, I made an to integrate with : SDK DialogFlow Golang This library allows integrating agents from the natural language processing service with your application. DialogFlow Golang Issue the following command to install the library: go get github.com/mlabouardy/dialogflow-go-client The example below, display list of entities: Note: for more details about the available methods, check the project . Github repository For a real world example on how to use this library, check my , on how to create a in to show list of movies playing in cinema, and tv shows airing on TV: previous tutorial Messenger Bot Golang

DialogFlow (API.AI) Golang SDK

84 Stories To Learn About Chatbot

148 Stories To Learn About Chatbots

Let's learn about via these 46 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Chatbot Development /Learn Repo 1. What I learned from building a chat project with sockets.io and React Well, after some I did some search on Google, I found an article with a developer who had the same issue. One and the awarded response was to use socket. 2. 8 of the Best AI Chatbots for 2023 Thanks to artificial intelligence and machine learning, chatbots are becoming a practical tool in the business world. This is good news for many companies, as chatbots can increase engagement, revenue and ROI. The potential of artificial intelligence is there to be harnessed, and AI-powered chatbots are examples of the effective usage of the technology. However, choosing a chatbot can be overwhelming. Let's take a look at the most popular AI chatbots currently on the market. 3. My Top 4 ChatGPT/AI Chatbot Tools This tool has replaced Google for me... 4. How we built ToDoBot for Slack in 3 days Technically, it was four days, but we were working on it in between taking customer calls and fixing OneBar bugs so, let’s call it three ;) 5. Develop Chatbots for Learning Reinforcement Chatbots are a powerful way to teach and learn, and this course shows you how to build them from scratch. 6. 5 Common Use Cases of a WhatsApp Chatbot A WhatsApp bot is an automated conversational tool that you integrate on WhatsApp using WhatsApp Business API. Read our article about uses of a WhatsApp chatbot 7. 6 Chatbot Mistakes that Scare Your Customers Away Six unforgivable mistakes that scare off your customers and prospects? The Smart Tribune team answers you. 8. Bots + Legaltech = Meet AILIRA Ailira (www.ailira.com) the ”artificially intelligent legal information research assistant”, is an AI chatbot that uses natural language processing. The chatbot has been designed to understand and process sophisticated technical legal questions & search quickly. Ailira was created by Adrian Cartland, the founder of Cartland Tech and the law firm without lawyers. 9. Sea of Transformation: Chatbots in The Logistics Industry The usage of the new age customer support technology bots, popularly known as Chatbots is on the rise. Researches show that more than 80% of the customer communication that is done on websites or mobile apps are done through chatbots. Chatbots are highly valuable for the companies because they can work round the clock, are easy to use and do not make any kind of errors. 10. MLOps & Industrial AI Are Progressing Quickly and Are Unstoppable The continuous evolution in DevOps with the combination of AI and ML for corporate application development is a solid reason for industry transformation. 11. How to Write a Perfect Chatbot Script Writing a script for a chatbot is a challenging process that requires skills. This article discusses how to write an effective chatbot script and gives tips. 12. Top Chatbot Trends That Will Dominate Businesses in 2023 Chatbots are a type of artificial intelligence that is programmed to simulate human communication. They are able to understand the context of a conversation and provide answers in a natural-sounding way. 13. Drive Success with Conversational Marketing: The Feedback-Oriented Approach Conversational marketing can be a solution to achieve faster response times. In this guide, we discuss how to develop effective chatbot applications. 14. Technologies Behind No-code & Low-Code Solutions and How to Build Your Own Let’s find out how no-code / low-code platforms are built and what it takes to create your own solution. We’ll focus on the development approaches, architecture [15. New Way for Business Optimisation is Out Now: Rake System and Their Success Story](https://hackernoon.com/new-way-for-business-optimisation-is-out-now-rake-system-and-their-success-story-v8vy325u) The Rake system understands and manages client requests related to company services. Regardless of the requests: text, voice - Rake’s chatbots understand and process all of them using artificial intelligence. The chatbot has been designed for W5Golf, and is the company that provides customer experience optimisation solutions and helps develop customer experience strategies that deliver results. The company’s solution helps to strengthen relationships with your customers by providing a system that optimises relevant engagements and improved services. 16. Create A Voice Enabled Chatbot [A How To Guide] The advent of AI has made voice-enabled chatbots and voice assistants part of our lives. Imagine the likes of Siris and Google Assistants for your phones, Alexa and Google Home for your house. These aforementioned systems are nothing but voice-enabled chatbots. 17. How Chatbots Are Helping The Fight Against Covid-19 With the recent surge in the number of coronavirus cases and more countries joining those already in self-imposed-quarantines and lockdowns, people have been getting understandably anxious. There has been a surge in the Google Trends for coronavirus related search terms. 18. Chatbots: Yay or Nay? Why and Why Not? This Slack discussion by Sadia Mehmood, Alfredo de Candia, Klein, , Golda Velez, Linh Smooke, David Smooke, Shahmeer Khan and Sidra occurred in slogging's official #general channel, and has been edited for readability. 19. Mobile Application Development Trends In 2020 Technology is changing our way of life. Mobile applications have a particular impact on this. Some facilitate daily activities (reminders, calling an ambulance or simply ordering coffee), while others simply help to kill time (if there is free time at all). But without all of them, it’s hard to imagine today's existence. 20. ChatGPT: What It's Teaching to a +25 Year Senior Programmer To be a decent software engineer, we must be experts at learning, and ChatGPT is an amazing teacher. Not just for juniors. 21. Helpful Tips and Fundamentals About Creating a Better Chatbot Strategy Source: Pixabay 22. 6 Chatbot Builders You Can Use to Emulate Facebook's Messenger This list also includes Api.ai, Chatfuel, the IBM Watson conversation service, and more. Discover how easy it is to build your own chatbot today. 23. Where are the Chatbots and What is the Progress and Limitation of Virtual Assistants [2020 Edition] Cat's out of the bag: it may have been a long while since you’ve last conversed with a human customer service agent. More and more companies have turned to digital assistants to address the needs of customer inquiries. With messaging being the preferred method of communication, chatbots have taken over online facing services, due to their simplicity, affordability, and accuracy. 24. Discussing The Applications of AI Chatbots in Healthcare at the World Economic Forum The World Economic Forum is mostly known for its highly anticipated annual meeting in Davos, Switzerland — a scene of global intrigue and a convergence point for the planet’s most influential politicians, investors, activists, CEOs, and economists. 25. How do Chat Apps improve customer engagement in Businesses? Collaboration and communication in the digital age have come a long way as it is not restricted to emails and messages anymore. Having a platform for the stakeholders involved in a business that enables them to communicate with each other will be a strong driving force. The flawless communication that can be switched to multiple devices without any interruption is an added convenience. 26. Exploring The World of Chatbots What if I told you the 1st time people thought of machines replicating human conversations was almost 70 years ago! 27. The Magic of Conversational AI: 8 Ways Chatbots are Helping Businesses Have you heard stories about chatbots failing to deliver results? Well, we created a list of the 8 most important chatbot benefits that will prove the opposite. 28. How Chatbots Can Help Improve Your Customer Experience Chatbots or customized software can converse with humans through a chat interface. Be it a brand’s website or a mobile app, chatbots can be integrated anywhere to gather useful information and facilitate sales. Platforms like Skype, Facebook Messenger, and Whats App also use chatbots for building reputation and improving customer experience. 29. How To Build Chatbot Project Using Python Chatbots are extremely helpful for business organizations and also the customers. The majority of people prefer to talk directly from a chatbox instead of calling service centers. Facebook released data that proved the value of bots. More than 2 billion messages are sent between people and companies monthly. The HubSpot research tells that 71% of the people want to get customer support from messaging apps. It is a quick way to get their problems solved so chatbots have a bright future in organizations. 30. The 6 Best Platforms To Create Chatbots Without Additional Programming Today I want to share a small review of simple platforms for creating bots without any knowledge of programming languages 31. How To Create a ChatBot on Facebook Messenger Using Flask and Heroku Basic Facebook bot (will chat with you using random phrases you set up) using Flask and Python. You can start with this bot as a basic app to build something more difficult and useful. 32. Chat API Comparison: Sendbird vs TalkJS vs Stream vs PubNub vs Cometchat Choosing the right chat API requires a ton of research. This is a quick guide so you can compare the most well-known chat APIs. 33. Twilio: How to Connect with Existing Voice Assistant Today's post serves the purpose of explaining Twilio's recent bidirectional streaming feature, the very feature which made it possible to receive the call audio while still being able to send audio for playback asynchronously. 34. Black Mirror's 'Be Right Back' in Real Life: Clone Yourself as a Chatbot Replika AI has created a platform where anyone, including people with zero knowledge of machine learning, can create and train a chatbot of their own. 35. Chatbot vs Virtual Assistants: The 4 Key Differences Chatbots vs Virtual Assistants: To know the difference between them check out this space and look for the video in it. 4 major points have discussed here. 36. Enterprise Chatbot: Do You Really Need It? This Will Help You Decide 37. Chatbots: The end of the hype era or a bright new dawn? We live in an age of great innovation and technological marvel. Artificial intelligence and machine-learning technologies are developing at an insanely fast pace, which resulted in the slightly increased performance of digital applications. A few years ago, chatbots formed a new, highly popular trend and have consistently been regarded as the best potential help for the labor market, slightly reducing the need for staff workload. The chatbot sector is now growing fast, and the total market is predicted to reach around 1.25 billion US dollars in 2025, a significant increase from the market size in 2016, which stood at $190.8 million. While becoming more sophisticated over the years, AI-driven bots are being used more often in various fields: marketing, healthcare, CRM [Customer Relationship Management]. This hypetrain resulted in more efficient solutions and brighter light at the end of the tunnel. 38. 10 Best AI Chatbot Builder for Your Business in 2022 Chatbots are on a rise and are rapidly becoming one of the most important assets for businesses these days. From SMBs to Fortune 500 companies, almost every business is investing in chatbots to establish stronger communication and offer the best customer support service. 39. How To Make A Chatbot From Scratch How To Make A Great Chatbot From Scratch Expert tips to create a highly functional chatbot. 40. Best Chatbot Development Companies For SME's and Startups in India, USA| Hire Best Chatbot Developer Which is the best Chatbot development company in India & the United States? This is the most confusing question for modern developers and business owners.  But, not all chatbot companies are fully perfect in terms of quality.This is what creates an uproar among people to find the best when Chatbot is already a hot topic among us. 41. How to Build Basic Chatbot Without Coding and Deploy to Websites Build best automated AI chat bot using Google Dialog flow 42. How Chatbot Development Can Make Technology More Accessible? Disclosure: I work at Value Coders, a company that creates Chatbot Solutions. 43. Eleven Trending AI Chatbot Platforms The artificial intelligence of the chatbots is revolutionizing the customer experience. They can provide useful information to customers when they need it. Hence, a number of companies that use AI Chatbots have grown exponentially. It provides them with proactive assistance to their customers. 44. Create a NodeJS FAQ Chatbot - A Step-by-Step Guide A FAQ Chatbot have the purpose of answering the most common questions asked by users. We will build one using Bard and some of its funtionalities, that will help us to build a smarter chatbot. 45. 11 Of The Best Artificial Intelligence Enterprise Chatbots in 2022 Chatbots for businesses help them engage their website visitors and convert them into potential customers. 46. How to Build a ChatOps-Bot with Slack and Kubernetes ChatOps allows  you to manage your DevOps tasks using chat based interfaces. Learn how to build a simple bot to control a Kubernetes cluster using Slack. Thank you for checking out the 46 most read stories about Chatbot Development on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

46 Stories To Learn About Chatbot Development

Disclaimer: I love no-code tools, I have been using them for about 7 years, and I believe that no-code solutions can really help you build new products and test out new ideas quicker and cheaper. For a very long time, I’ve been planning to write an opus magnum on using no-code solutions to build new products, but all the drafts I’ve had were becoming so lengthy, they’d be considered a novel by most. So let me give you a short intro to no-code tools for Product Managers instead. What is no-code? ‘No-code’ is a term that’s commonly used for building software without actually, you know, coding. This means that the no-code tools (at least in theory) can be used without any knowledge of programming languages, software architecture, etc, and you’ll still get a decent result. I’ve seen the term being used in many different contexts, from the horrific (people online saying that Salesforce is the most powerful no-code ecosystem) to pretty shady (online schools promising you a wild career and lucrative wages if you complete their no-code programme). No-code tools are just tools. Same as with AI tools like ChatGPT: you can use them to make your work less stressful and more impactful, but they won’t do your job for you and just knowing how to create a database with a working API in Airtable will not land you a job at FAANG. My favorite use case for no-code solutions is quickly mocking up working solutions for new ideas me or my team may have, closely followed by building internal tools. Most of these ideas and tasks don’t really require anything special. Of course, not all ideas can be tested with off-the-shelf technology. For example, it’s highly unlikely that some existing no-code solutions would have been able to help me test the efficiency of eye-tracking-based reading analytics. But even advanced projects that need a lot of research and development would benefit greatly from the dev teams not having to create all the boring databases and admin panels for every single test. And it looks like the more high-tech your project is nowadays, the more data you’ll need to collect and manage. Airtable Almost all the projects I have worked on in my life involve in some way. You can do almost anything with Airtable because in its essence it is an incredibly user-friendly database with auto-generated API, built-in integrations (including Gmail) and a great ecosystem of projects that work well with it. Airtable Example use cases Airtable is pushing itself as more of a project-managing solution, with most popular templates focused on PM and Marketing tasks, but that would be underselling itself. My favourite uses for Airtable would be these two: Crowdsourcing Imagine you’re collecting thousands of reading sessions from hundreds of participants for, say, a reading study. What would you normally use? An Excel table? Google Sheets? Google Drive with folders that are impossible to navigate? Since Airtable’s tables explicitly are composed of entities, it’s the best solution for keeping data with simple or complex relations and then actually working with it. In this example we have a simple structure: Respondents, who have Name (Relation) Personality survey they have completed (Relation) List of their reading sessions (Lookup field) List of reading materials mentioned in their reading sessions Personality surveys, consisting of: (Relation) Link to the Respondent that has completed them As many questions as you’d like to ask them Reading materials Name (Attachment) An EPUB file with this reading material (Relation) List of all reading sessions involving this Reading material (Lookup field) List of all Respondents that have read this Reading material (via Reading sessions) Reading sessions (Relation) The respondent that read it (Relation) Reading material that was read Date and time it was started Duration in minutes Try building something like this in Google Sheets, it won’t be easy. Building and maintaining the initial structure would take mere minutes, and you’ll be able to build all the extras on top, like: Easy-to-use data entry forms (less powerful than Google Forms, but built-in) Millions of views and filters for all sorts of purposes Airtable Interfaces (see below) Gmail integration that allows you to send confirmation emails and communicate in other ways One caveat: Airtable is not a data storage solution, so collecting stuff like videos or other larger files won’t really work: even with the premium plans you only get 20 Gb of storage per database. If you want to do that, you’ll either need to ask your dev team to build a custom submission form and some tiny backend that will upload files to S3, or use an Airtable clone like . However, they have their own limitations and integrations won’t be as no-code as I prefer them to be. Baserow Backend for MVP projects What if you have a new product idea but your backend team is super busy? Airtable lets you build your own perfectly functional backend! See, one of Airtable’s features (and in my view, its greatest) is the built-in API generation. This means that for all the tables, fields and records you create in Airtable, there is an API that allows a developer (this part is definitely not no-code) to access them. You can build a fully functional MVP backend in the same amount of time it would take to write a Jira task. Let’s take the same database from the Crowdsourcing scenario and see if we can build an app that would display a list of these Reading materials, download them and let its users read them. Airtable’s API (counterintuitively located away from the databases at ) lets you access this: api.airtable.com Like this: It provides a really well-documented API that uses actual data as examples and is super intuitive to use. This makes trying out new ideas that require storing some data on the backend much easier. You still will need to create a proper backend later on, but that will only have to happen once you’ve proven your idea actually works. Airtable Interfaces While I’m a big fan of the way Airtable looks and functions, I’ve encountered quite a few people that were absolutely overwhelmed by Airtable’s “it’s-a-table-but-not-quite-a-table” look. I guess this is why they’ve introduced Interfaces in 2022. It’s an absolutely fantastic feature that allows you to build great-looking views for your data. Unfortunately, they cannot be shared publicly and can only be used for internal tools. However, there are ways to match some of their functionality (and some more) with miniExtensions. I’ll probably write a separate article on that later. Connecting tools and services At some point in your no-code journey, you’ll want to connect the new stuff to your old stuff. You may want to send new Airtable entries to Mailchimp, or transform new files in a Google Drive folder into Airtable entities. There is one tool to do this that I like and one that I absolutely hate. The one I like: Make (formerly Integromat) lets you build all your connections visually, move them around, change the order of the steps and generally has a pretty good UI. This is probably the best tool to automate all the weird Google Drive to Airtable to Mailchimp dances if you have to make them. Make The one I hate: Zapier Until recently, once you created a flow in , that was it. Need to make changes? Want to reorder the actions? Tough luck, you have to go back to the last step before the action that’s not quite there and redo everything. They changed this at some point, but I’m still not touching Zapier with a 10-foot pole. Zapier Building websites There are so many web-building tools out there that claim to be the no-code solution to all life’s problems, I’ve lost count. But out of all the tools, only one can be easily used by a Product Manager with no design experience. Super: transform Notion pages into a website lets you transform a Notion page and all its child pages into an auto-updating website. It’s perfect for anything public-facing that doesn’t need to look very good, like developer documentation, support portals, terms and conditions and many other applications I can’t even think of. Super There are some competitors, including , but I liked Super the most. Simple.ink Creating internal tools Warning: this is going to be slightly less no-code than the rest of the sections, but will give you great powers. If you have an API or an existing database, but not a good UI to go with it, you can use no-code tools to access these APIs and provide ways to send or receive stuff over them with a pretty nice UX. The only no-code tool for this that I truly liked is . It allows you to build dashboards and CRUD (create, read, update, delete) apps with a WYSIWYG drag-and-drop interface. You need to know how APIs or SQL requests work, but it’s still much less time-consuming than having to develop stuff. Retool Further reading If you want to learn more, I’m a big fan of . It’s a lot more visual and fun than this overview, and while some time has passed since it was first published in 2020, most of the core tools remain the same. Vas3k’s article on No-code I hope this overview has inspired you to try no-code tools if you’ve never used them, taught you about a couple new approaches if you have, or simple hasn’t annoyed you if you consider yourself an expert in no-code solutions. If you are annoyed that your tool hasn’t been listed here, join the conversation in the comments below!

Best No-code Tools for Product Managers

Spoken Language Understanding SLU and Natural Language Understanding NLU aim to help machines understand human language. The main difference is the input data type. SLU deals with understanding speech, whereas NLU deals with understanding text. NLU is a part of SLU whether it’s trained independently or not. Research on NLU started in the 1960s: ’s Ph.D. dissertation Weizenbaum’s , a mock psychotherapist chatbot, and Winograd’s are the pioneer works in this space. SLU’s popularity started with the recent advances in speech recognition powered by deep learning. The query “spoken language” returns over 1000 studies on both and research publications websites. Bobrow ELIZA SHRDLU Amazon Microsoft Conventional SLU Approach The conventional SLU processes utterances in two steps - Speech-to-Text (STT) first, then NLU. Once STT transcribes the speech to text, NLU extracts meaning by processing the transcribed text. The performance relies on independently trained STT and NLU modules. If STT returns erroneous output, then it leads to incorrect NLU predictions. Hence machines cannot capture what humans say. Many voice applications, including voice assistants - Alexa, Siri, and Google use this approach. End-to-End SLU Approach The modern SLU uses an end-to-end model instead of two distinct components. Developers train STT and NLU jointly, resulting in higher accuracy. Picovoice calls this as it infers users’ intents directly from speech. Amazon calls it - Fusing ASR and NLU for SLU. Speech-to-Intent FANS Conventional SLU Approach vs. End-to-End SLU Approach The answer is It depends on the availability of corpora and information. If available, then the answer is modern end-to-end SLU. If not, then the conventional SLU. Text-based understanding (NLU) has been around longer than speech-based understanding (SLU). Thus, it has richer datasets. “it depends.” For domain-specific applications such as IVR systems, menu navigation on a website, or ordering food at a QSR, the modern end-to-end SLU is preferable. Nobody would discuss the meaning of life with a voice assistant while ordering a hamburger. For open-domain use cases such as voice assistants like Alexa, conventional -cascading SLU works better given the variety of topics they cover. One can discuss the meaning of life with Alexa - although there are better options. Top SLU and NLU engines in the market Free and Open-source SLU and NLU Engines: : Rasa is an open-source NLU engine that processes text inputs. The core software is free, and Rasa offers paid support and consulting services. Anyone can choose a speech-to-text service, and run Rasa on transcribed text. Rasa : Snips is an open-source SLU engine that uses the conventional method. Snips no longer maintains it after being acquired by Sonos. Yet the repo is still available on GitHub and used by developers. Snips : Wit.ai is a free platform and now requires a Facebook account after being acquired by Facebook. If one doesn’t (want to) have a Facebook account or deletes it, then they cannot use Wit. Wit.ai Top paid SLU and NLU Engines: : Google, after the API.ai acquisition, named it Dialogflow and offers both chatbot and voicebot tools under the same name. It uses the conventional approach. Dialogflow records and sends voice data to Google’s servers for transcription and then processes transcribed text. It charges based on usage. Dialogflow : Amazon’s Lex is an AWS offering. Like Dialogflow, Lex offers text and voice capabilities, uses the conventional approach, and transcribes speech and understanding separately in its cloud. It charges based on usage. Lex : Picovoice’s Rhino is an SLU engine that uses the end-to-end approach and infers intents and intent details . Rhino is voice-based and does not support text-based services. It charges based on the number of users and offers unlimited interactions per user. Rhino directly from speech

Spoken Language Understanding (SLU) vs. Natural Language Understanding (NLU)

Machine learning models are usually developed in a training environment (online or offline) and then can be deployed to be used with live data.  If you're working in Data Science and Machine learning projects, knowing how to deploy a model is one of the most important skills you'll need to have. Who is this article for? This article is for those who have created a machine learning model in a local machine and want to deploy and test the model within a short time. It's also for those who are looking for an alternative platform to deploy their machine learning models. Let's get started! 🚀 What does it mean to deploy a Machine Learning model? Model deployment is the process of integrating your model into an existing production environment. The model will receive input and predict an output. Machine learning models can be deployed in different environments and can be integrated with different web or mobile applications through an API. “Only when a model is fully integrated with the business systems, we can extract real value from its predictions”. — Christopher Samiullah There are different platforms that can help you deploy your machine learning model. But for most of these platforms, it takes a lot of time and resources to configure the environment and deploy your model. For example, Sagemaker offers a popular library and ML frameworks, but you still have to depend on them for new releases. This might mean that you won't be able to deploy your model on time. Let's say the Sagemaker platform has scikit-learn v0.24 in their environment and you want to train and deploy your model with scikit-learn v1.0.1. You will not be able to do it until Sagemaker upgrades to the new version of scikit learn (1.0.1). In this article, you will learn how to use Aibro to deploy your model quickly and easily. What is Aibro? is a serverless MLOps tool that makes Machine Learning cloud computing cheap, easy, and fast. The tool can help data scientists or machine learning engineers train and deploy machine learning models on cloud platforms within a short period of time. Aibro It currently supports AWS cloud platform and they are planning to support more cloud platforms like Google Cloud, Microsoft Azure, Alibaba Cloud and IBM Cloud. It also supports most of the popular machine learning frameworks in the market like TensorFlow, Pytorch, Scikit-learn, and XGboost. Another advantage of using Aibro is the ability to reduce cloud costs by 85% using an exclusive cost-saving strategy built for machine learning. After understanding Aibro and its services, let's create a simple model and then deploy it. Create a Simple Model The first step is to build the model. We are going to use the to build a model that can classify if a movie review is positive or negative. Here are the steps you should follow to do that. IMDB Movie dataset Import the Important packages We need to import Python packages to load the data, clean the data, create a machine learning model, and save the model for deployment. accuracy_score,
    classification_report,
    plot_confusion_matrix,
) ):
    nltk.download(dependency) # import important modules import numpy as np import pandas as pd # sklearn modules from sklearn.model_selection import train_test_split from sklearn.pipeline import Pipeline from sklearn.naive_bayes import MultinomialNB # classifier from sklearn.metrics import ( from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer # text preprocessing modules from string import punctuation # text preprocessing modules from nltk.tokenize import word_tokenize import nltk from nltk.corpus import stopwords from nltk.stem import WordNetLemmatizer import re #regular expression # Download dependency for dependency in ( "brown" , "names" , "wordnet" , "averaged_perceptron_tagger" , "universal_tagset" , import warnings warnings.filterwarnings( "ignore" ) # seeding np.random.seed( 123 ) Load the dataset from the data folder: # load data data = pd.read_csv( "../data/labeledTrainData.tsv" , sep= '\t' ) And then show a sample of the dataset: data.head() # show top five rows of data Our dataset has 3 columns: Id — This is the id of the review Sentiment — either positive (1) or negative (0) Review — comment about the movie Next, let's check the shape of the dataset: data.shape # check the shape of the data (25000, 3) The dataset has 25,000 reviews. Now we need to check if the dataset has any missing values: # check missing values in data data.isnull(). sum () id 0 sentiment 0 review 0 dtype: int64 The output shows that our dataset does not have any missing values. How to Evaluate Class Distribution We can use the value_counts() method from the Pandas package to evaluate the class distribution from our dataset. data.sentiment.value_counts() # evalute news sentiment distribution 1 12500 0 12500 Name: sentiment, dtype: int64 In this dataset, we have an equal number of positive and negative reviews. How to Process the Data After analyzing the dataset, the next step is to preprocess the dataset into the right format before creating our machine learning model. The reviews in this dataset contain a lot of unnecessary words and characters that we don’t need when creating a machine learning model. We will clean the messages by removing stopwords, numbers, and punctuation. Then we will convert each word into its base form by using the lemmatization process in the NLTK package. The text_cleaning() function will handle all necessary steps to clean our dataset. text = text.split() text = text.split()
        lemmatizer = WordNetLemmatizer() stop_words =  stopwords.words( 'english' ) def text_cleaning ( text, remove_stop_words= True , lemmatize_words= True ): # Clean the text, with the option to remove stop_words and to lemmatize words # Clean the text text = re.sub( r"[^A-Za-z0-9]" , " " , text) text = re.sub( r"\'s" , " " , text) text =  re.sub( r'http\S+' , ' link ' , text) text = re.sub( r'\b\d+(?:\.\d+)?\s+' , '' , text) # remove numbers # Remove punctuation from text text = '' .join([c for c in text if c not in punctuation]) # Optionally, remove stop words if remove_stop_words: text = [w for w in text if not w in stop_words] text = " " .join(text) # Optionally, shorten words to their stems if lemmatize_words: lemmatized_words = [lemmatizer.lemmatize(word) for word in text] text = " " .join(lemmatized_words) # Return a list of words return (text) Now we can clean our dataset by using the text_cleaning() function: #clean the review data[ "cleaned_review" ] = data[ "review" ].apply(text_cleaning) Then split the data into features and target variables like this: y = data.sentiment.values #split features and target from  data X = data[ "cleaned_review" ] Our feature for training is the cleaned_review variable and the target is the sentiment variable. We then split our dataset into train and test data. The test size is 15% of the entire dataset. X_train, X_valid, y_train, y_valid = train_test_split(
    X,
    y, stratify=y,
) # split data into train and validate test_size= 0.15 , random_state= 42 , shuffle= True , How to Create a Model We will train the Multinomial algorithm to classify if a review is positive or negative. This is one of the most common algorithms used for text classification. Naive Bayes But before training the model, we need to transform our cleaned reviews into numerical values so that the model can understand the data. In this case, we will use the . TfidfVectorizer will help us to convert a collection of text documents to a matrix of TF-IDF features. TfidfVectorizer method from scikit-learn To apply this series of steps (pre-processing and training), we will use a from scikit-learn that sequentially applies a list of transforms and a final estimator. Pipeline class sentiment_classifier = Pipeline(steps=[ ]) # Create a classifier in pipeline ( 'pre_processing' ,TfidfVectorizer(lowercase= False )), ( 'naive_bayes' ,MultinomialNB()) Then we train our classifier like this: sentiment_classifier.fit(X_train,y_train) # train the sentiment classifier We then create a prediction from the validation set: y_preds = sentiment_classifier.predict(X_valid) # test model performance on valid data The model’s performance will be evaluated by using the accuracy_score evaluation metric. We use accuracy_score because we have an equal number of classes in the sentiment variable. accuracy_score(y_valid,y_preds) 0.8629 The accuracy of our model is around 86.29% which is good performance. How to Save the Model Pipeline We can save the model pipeline in the model’s directory by using the joblib Python package. #save model import joblib joblib.dump(sentiment_classifier, '../models/sentiment_model_pipeline.pkl' ) Now that we've built our model, let's learn how to deploy it with Aibro. Deployment WorkFlow – a Step by step Guide To deploy your model with Aibro, you need to prepare your model in the properly formatted machine learning model repository. You can quickly take a look at this repository , but we will build the same for the model we have created. https://github.com/AIpaca-Inc/Aibro-examples As you can see from the image of the deployment flow, Aibro will create an inference API from the formatted machine learning model repository, and you will receive a unique API URL and start to make a prediction from your model. All you need to do is to follow these steps. Step 1: Install the aibro Python library To install aibro, run the following command in your terminal: pip install aibro Step 2: Prepare the Model Repository The model repository will be formatted in the following structure. This folder will contain the model you have created. (a) model folder The data folder will have a JSON file that has an input value. For our case, the input will have a text value (review) as follows. (b) data folder { "data": "I loved it, the kids loved it. It shows them that anything is possible but more especially when you have that one person fighting for you. That one person who believes in you without fail. I appreciated the various life lessons included in the film about being humble and thankful but commanding respect at the same time despite where or what background you come from. Success doesn’t see age, race or gender but sadly opportunity often does. Will Smith doesn’t let the lack of opportunity beat them as a family and the family is a team. The bigger picture is always knowing that there is a team involved in most successful people." } Remember there is no restriction on how you want to format your input and output. Note: The python file should contain two python functions. (c) predict.py This function is responsible for loading the machine learning model from the model folder and returning it. In this tutorial, we will use the joblib package to load the model we have created. load_model(): def load_model (): #load model model = joblib.load( "model/sentiment_model_pipeline.pkl" ) return model This function will receive a model as the input and then load the data from the data folder. Finally, it will make predictions and return the result. run(): data = json.load(fp) def run ( model ): fp = open ( "data/data.json" , "r" ) review = text_cleaning(data[ "data" ]) result = { "data" : model.predict([review])} return result Therefore the predict.py will look as follows: data = json.load(fp) run(load_model()) # import important modules import json # load data import joblib # load model from clean import text_cleaning # function to clean the text def load_model (): #load model model = joblib.load( "model/sentiment_model_pipeline.pkl" ) return model def run ( model ): fp = open ( "data/data.json" , "r" ) review = text_cleaning(data[ "data" ]) result = { "data" : model.predict([review])} return result if __name__ == "__main__" : Aibro will first need to install the packages required to run your model before deploying the model itself. You can either manually write the packages and their version number in the requirements.txt or run the following command which will do the same: (d) requirements.txt pip list -- format =freeze > requirements.txt nltk==3.6.7 numpy==1.19.1 pandas==1.0.5 scikit_learn==0.23.1 joblib==1.0.0 It is also recommended to use the pipreqs Python package to generate requirements.txt. This is because it will include Python packages based on imports in your project instead of all packages in your environment. Note: $ pipreqs /home/aibro_project Successfully saved requirements file /home/aibro_project/requirements.txt You can also include other files or folders that will be used by the predict.py Python file. For example, in the model we have created, we will need to clean the input before making a prediction. (e) Other Artifacts The clean.py contains a Python function that will clean the text before making a prediction. nltk.download(dependency) nltk.download(dependency) nltk.download(dependency) text = text.split() text = text.split()
       lemmatizer = WordNetLemmatizer() # import packages import nltk # Download dependency corpora_list = [ "stopwords" , "names" , "brown" , "wordnet" ] for dependency in corpora_list: try : nltk.data.find( 'corpora/{}' . format (dependency)) except LookupError: taggers_list = [ "averaged_perceptron_tagger" , "universal_tagset" ] for dependency in taggers_list: try : nltk.data.find( 'taggers/{}' . format (dependency)) except LookupError: tokenizers_list = [ "punkt" ] for dependency in tokenizers_list: try : nltk.data.find( 'tokenizers/{}' . format (dependency)) except LookupError: from nltk.corpus import stopwords from nltk.stem import WordNetLemmatizer from nltk.tokenize import word_tokenize import re #regular expression from string import punctuation stop_words =  stopwords.words( 'english' ) # function to clean the text def text_cleaning ( text, remove_stop_words= True , lemmatize_words= True ): # Clean the text, with the option to remove stop_words and to lemmatize word # Clean the text text = re.sub( r"[^A-Za-z0-9]" , " " , text) text = re.sub( r"\'s" , " " , text) text =  re.sub( r'http\S+' , ' link ' , text) text = re.sub( r'\b\d+(?:\.\d+)?\s+' , '' , text) # remove numbers # Remove punctuation from text text = '' .join([c for c in text if c not in punctuation]) # Optionally, remove stop words if remove_stop_words: text = [w for w in text if not w in stop_words] text = " " .join(text) # Optionally, shorten words to their stems if lemmatize_words: lemmatized_words = [lemmatizer.lemmatize(word) for word in text] text = " " .join(lemmatized_words) # Return a list of words return (text) How to Test the Repo with Dryrun Before we deploy our model, we can test the repo using Dryrun. Dryrun will locally validate the repo structure and test if the inference result can be successfully returned. The following line of code will test the repo we have created: api_url = Inference.deploy( ) from aibro import Inference artifacts_path= "./sentiment_model_repo" , dryrun= True , The formatted model repository is saved at path “./sentiment_model_repo”. Note: The result shows that the prediction finished without errors. Now we can deploy the model. How to Create an Inference API with One Line of Code To deploy the model, you need to configure the following variables in the inference.deploy() method. The model name should be unique with respect to all current active inference jobs under . In this example, the model name will be "my_sentiment_classifier". (a) model_name your profile This is the id of the machine that will run our model. For this example we will use "c5.large.od".You can see the entire list in the . (b) machine_id_config marketplace This will be the path to your formatted machine learning model repository. For this example, the path is . (c) artifacts_path "./sentiment_model_repo" You can also add a description of your model deployment. (d) description Finally, the one-line code to create an inference API will look as follows. api_url = Inference.deploy( ) from aibro import Inference model_name = "my_movie_sentiment_classifier" , machine_id_config = "c5.large.od" , artifacts_path = "./sentiment_model_repo" , description= "my first inference job" , Once the deployment is finished, an API URL is returned with the syntax like this “ ” http://api.aipaca.ai/v1/{username}/{client_id}/{model_name}/predict if your inference job is public, {client_id} is filled out with "public". Otherwise, {client_id} should be filled out with one of your ' IDs. Note: clients In this tutorial, the API URL will be http://api.aipaca.ai/v1/DavisDavid/public/my_sentiment_classifier/predict How to Test an Aibro API We successfully deployed the model and got the API URL. Let’s test the model and see the result. We will use a Python package called requests to send a request to the API URL and get results. The posted data will replace everything in the data folder. Therefore, your posted data should have the same format as whatever you had in the data folder initially. Note: prediction = requests.post( data=review,
)
 
result = prediction.text import requests import json review = { "data" : "A truly beautiful film that will having you crying with joy and pride. The (few) poor reviews cite a lack of authenticity regarding Richards character and a lack of screen time for the other major family members, including Serena. While I admittedly don’t know exactly the kind of person and father Richard was" } "http://api.aipaca.ai/v1/DavisDavid/public/my_movie_sentiment_classifier/predict" , print (result) The prediction result is {‘data’: array([1])}. As you can see we managed to predict by using the API, and the model predicts that the review is . positive (1) Complete the inference job If you're no longer going to use your inference job, you should shut down the API to avoid unnecessary costs. You can shut it down by passing the inference job id in the Inference.complete() method. rom aibro.inference import Inference id = "inf_cd712f4a-4b59-4e44-8787-9c5b5450ff6d" Inference.complete(job_id= id ) You will receive an output that the inference job successfully completed. Final Thoughts In this article, you have learned the fastest and simplest way to deploy a Machine Learning model to the cloud by using Aibro. You don't need to take a lot of your time and resources to configure the environment – just install aibro and you are good to go. There is a free community edition you can use for your small ML projects. But Alpaca is also giving free credits to new users so you don't need to worry about the cloud costs. There are a lot of features from Aibro that you can use while deploying your model. To learn more you can visit our beautiful designed documentation pages and you can also join our community to get more help. here here You can download the source code used in this article here: https://github.com/Davisy/Aibro-ML-Model-Deployment If you learned something new or enjoyed reading this article, please share it so that others can see it.

How to Deploy Machine Learning Models to the Cloud Quickly and Easily

Innovative technologies like Artificial Intelligence (AI) and Machine Learning are essential enablers of digital transformation. The unique ability to distill all complex data into knowledge, along with judgment (AI) and mechanical rules (ML) undoubtedly makes these technologies stand apart. In order to perform any specific task, AI and ML get to the atom of every job and get it done with comparative ease. In this way, rule-based work separates from knowledge-based work, which typically depends on critical thinking and decision-making skills. This process not only disrupts the current organizational working practices, but also improves the customer experience by reducing time, human resources required, and budget. For instance: AI and ML, along with Data Science, create Inductive Logic programming (ILPs) efficient for image and voice recognition. An ILP is the backbone of chatbots. Robotic Process Automation (RPA) is another specific case, which accurately illustrates a fundamental change in digital technology. RPAs are software robots that first learn and then mimic and perform rule-based tasks. They easily interact with any computer application or system with 100% accuracy. As AI and cognitive computing together erase out the demarcation between the digital and physical worlds, making cognitive systems think, observe, assimilate and learn like humans. It properly understands the human inputs via Natural Language Processing (NLP) and replies using Dialog Management. ML supports this continuous digital conversation. This technological breakthrough gifts us chatbots, which are of great significance in customer care across industries. They can converse by text to text or text to voice, eliminating confusion or a laid-back attitude of an incompetent customer care executive. It is not only customer care, AI and ML have revolutionized other important sections of business, like production and finance too. In order to build a quality chatbot, there are several bot builders available in the market. Although Chatbot4u is one of the archaic ecosystems for chatbots, there are few more quality substitutes, which I'll list in this article. 1. Api.ai (Dialogflow) Api.ai is the most convenient way to get a chatbot-style AI personal assistant. It allows developers to design artificially intelligent models that they can train up with your custom functionality. Founded in 2010, it gives innovative and engaging ways for users to interact with the product. Although it does not allow a visual designer. Benefits: 1. Several secured domains available. 2. Easy to build non-linear bots in no time 3. Integration with FB, Twilio and other platforms is simple. 2. Chatfuel Chatfuel is a quality bot builder as it has a visual development environment. The main USP of Chatfuel is that it requires no code or tech knowledge and anyone can build a simple bot for the business in just a few hours. Benefits: 1. Less time taking process. One can build a simple bot quickly. 2. Deployment to FB Messenger is easy. 3. Outbound webhook support is excellent. 3. wit.ai It is a free tool that anyone can employ. The platform has no visual development environment, so the developer has to be comfortable coding. Facebook acquired the platform, so it makes wit.ai, an excellent choice for those who plan to develop chatbots for Facebook Messenger. It supports about 50 different languages. Benefits: 1. It supports around 50 languages. 2. Training of the engine goes around domain-specific use cases 3. Developer can train the model through a web interface. 4. IBM Watson conversation service IBM Watson delivers a set of APIs and products like Virtual Agent, Explorer, Analytics, and Knowledge Studio. The platform allows developers to define the conversational logic for the bot. i.e logic for what to say and when to say Benefits: 1. Does not require much coding expertise. 2. Effective on smaller training datasets 5. ItsAlive ItsAlive is a free platform used to make Facebook Messenger's chatbots. It enables you to send periodic content each day, week, or month, or manually send a one-time message to each chatbot subscriber. 6. Rasa NLU This platform consists of two units called NLU and Core. Rasa NLU supports HTTP API and Python for intent classification and entity extraction. The platform additionally includes all the features to create contextual, human-like conversations. Industries like insurance, banking, health, telecoms, travel, etc can use this platform. In Conclusion: Chatbots realistically pave the way forward for companies intending to optimize for superior customer service, marketing, and lead generation operations. The unique combination of (AI) and (NLP) has invariably produced some excellent results, and to get the desired results, one needs quality training datasets. Artificial Intelligence Natural Language Processing

6 Chatbot Builders You Can Use to Emulate Facebook's Messenger 

Hello there! Want to create bots but don't know how to do it? Here are the top 6 easiest chatbot platforms to use: a beginner's guide. What I'm talking about in this post When we use the word we talk first of all about dialogue and conversation. This is the real revolution brought about by digital communication, a revolution that has profoundly marked the approach of both brands and, above all, users. It is no longer conceivable to work only on input, perhaps playing on effect commercials or aggressive campaigns. Today the consumer wants or rather demands, a confrontation with companies, trying to establish a relationship with them. chatbot A true paradigm shift that has consequently marked the evolution of technology and communication tools. Chats have in fact gone from being an essential element of people's daily lives to a fundamental marketing tool for brands. WhatsApp, Wechat, Messenger just to name a few. An activity, that of , yes very useful, but also demanding on the company side. A commitment that has led to the development of useful solutions to automate and make less burdensome this type of activity. Chatbots are perhaps the most important innovation in this sense. dialogue and relationship Chatbots, or chatbots, are nothing more than programs capable of simulating a conversation between a robot and a human being. These programs work as chat users themselves or as staff of companies, giving answers to users using the chat. Chatbots work thanks to rules, patterns, or artificial intelligence, allowing people to interact via chat, without human intervention. Not only customer care: request for services, advanced CRM systems, information about news, offers, promotions are just some of the activities that a chatbot can perform. The added value of chatbots is that they are , bringing enormous advantages to users and savings to brands. The evolution of these tools allows you to create truly useful conversations based on a wealth of information and experiences. The chatbot recognizes elements like tastes, interests, age, and language to offer the right answer. The evolution of machine learning makes many bots able to "learn" and improve use after use. Not bad, I would say. active 24/7 Just try, for example, the chatbot of KLM or Pizzahut to understand the potential of this tool. There are even those who have exploited its flexibility of use to make it a storytelling tool. This is the case of Burberry that, thanks to a chatbot, has launched the campaign "The tale of Thomas Burberry". Realizing them requires programming knowledge, but in recent months many platforms have been created that allow even those who do not write a line of code to create their own chatbot. Here are the best ones. Platforms to help you create your own chatbot Born to create chatbots dedicated to Facebook. Just have a business page and we can create one to communicate with our users. In a simple and immediate way, Chatfuel lets you create a real chatbot with all the necessary functions. Inserting automatic responses, links to contents, or web pages are some of the functions we can implement. It is also possible to send push messages to those who have contacted us, keeping the relationship alive. A practical example? List the rooms available in a certain period in our hotel, guiding them step by step in the online booking. Or report the most read articles or categories of our blog, as I did for my Facebook Influencer Marketing Italia page. Through Messenger, you can get news about me or the book, contact me or read the latest articles on my blog. All this is done in a few hours. You can also "train" our bot teaching it how to act in the best way situation by situation and making it more and more performant. Also usable for Telegram, Chatfuel is a tool that you absolutely have to try. All platforms dedicated to the creation of chatbots for Messenger. Chatbots-builder is a tool that makes the simplicity of using its strength, making it possible for anyone to create their own. It only takes a few steps to create a chatbot, choosing from the many functions available. Very interesting, and dedicated to the less experienced, are the templates, "drafts" of vertical chatbots on different sectors and uses (web agency, restaurant, hotel, blogger) to be completed with your own content. Each one is made to meet the needs of the sector: the restaurant has the command to book, the web agency to show services and portfolio. Also in this case the times (and the possibility of error) decrease drastically. This is how very "simple" bots are born, but it is possible to make them more complex depending on the needs and efforts in building them. I tried to make one for the page of Open-Box, my agency and the result, despite the few hours spent, is more than satisfactory. It's a very well-done tool that allows even non-developers to create chatbots. Sequel's added value is the wide range of supported platforms: in addition to Messenger, it's possible to create bots for Kik and Telegram. What makes Sequel stand out is its ease of use. The wizard allows you to create chatbots quickly, providing the user with a set of preset templates that adapt to the needs of brands and professionals. Another interesting feature is the one that allows the customization of chats with the inclusion of colored texts and GIFs. The NPL feature allows you to create very natural conversations, a feature that, combined with training, makes the bots more and more "human". Botsify is a tool to create chatbots dedicated to Facebook Messenger. Again, no programming knowledge is required, allowing anyone, really anyone, to create their own personal bot. A list of templates related to different uses makes it easy to configure a chatbot, as it is equally easy to manage media files such as images, videos, GIFs. The learning ability of the system constantly improves the performance of the bot, ensuring an excellent user experience. Userbot is one of the most innovative platforms for bot creation and usage. The development of the bot is made simple and quick, but giving the possibility to users to add numerous options and customize it according to their needs. Userbot integrates with the main channels used by users today: website, Messenger, Telegram, iOS, Android, on other CRMs. A single bot, but many possibilities of use. The real gem of Userbot is Deep Learning and the use of Artificial Intelligence to analyze messages. This is how it is able to recognize the type of problem, understand the users' state of mind and automatically choose the most suitable response. UserBot is able to understand natural language and any errors that happen while writing in chat. Because it's not enough to have a chatbot, the important thing is that it falls into its role in the most human way possible, putting users at ease and improving their experience. Here's a tool I love. Smooch is a connector between platforms like Slack and Zendesk and messaging apps (Line, Facebook Messenger, Kik, WeChat, and others). Translated it means that you can converge communications coming in on Messenger or website chat, for example, on Slack. A way (I assure you from experience) to make message management and customer care faster and easier. I make converge on a dedicated Slack channel the messages that arrive on one of my Facebook Page. In addition to its core business, Smooch allows creating chatbots that can be connected with the channels used. So we'll have a bot that will respond to chats by automating the most common workflows, such as collecting form data, scheduling, executing payment processes, or any feedback. Here is perhaps the best-known tool to create chatbots without programming knowledge. no of the most effective and well-known tools. ManyChat has the merit of being a tool with great potential, but also very easy to use, an element that makes it at the door of even fewer pro users. The user is guided step by step, depending on the needs thanks to the drag'n'drop builder (as you can see in the video tutorial). Among the most relevant features, I point out auto-posting and scheduling of messages. There is no doubt that Facebook is investing a lot in the chatbot issue. It has made it one of the major innovations of recent years and it was therefore unthinkable that it didn't move to give support in the creation of the bots themselves. Thus, a dedicated platform was born, one that is more advanced than the tools found online, but at the same time more complex to use. In fact, it is necessary to activate some tools before being able to create the bot: Messenger plugin, Messenger codes, and links, customer correspondence, structured templates, welcome screen. Not always intuitive to tell the truth. To overcome this increased complexity, Facebook provides users with a comprehensive guide and most importantly several useful famous case studies to analyze. If you're looking for a really pro tool to create chatbots, API.ai is for you. Dedicated to both developers and non-developers, it allows you to create advanced bots both in terms of functions and performance. Advanced yes, but with a high user experience. It only takes 3 steps to create your own bot. Once it's set up, you'll have to provide the bot with textual examples of how people can talk to it. On this basis API.ai will train the bot for us, making it capable of having the best conversation with users. The use of machine learning is a notable plus. Multilingual support and a wide range of supported platforms complete the offer: The Turin-based company specializing in Bots has recently released a new bot for use in Whatsapp. The system allows in a simple and intuitive way to manage in a completely automatic way the sending of messages, images, videos, and links through the well-known messaging app. Instant News (WhatsApp) was in fact created as a platform to automate the sending of informative newsletters. This Whatsapp bot can also be integrated with other software and platforms (Zapier and WordPress for example), so as to make its adoption and use very flexible. I think (and I believe) that a few lines are enough for you to understand the potential of chatbots. Excellent tools to automate processes and make them more performant, putting us in a position to give constant support to users. Their flexibility and ability to learn have transformed the use of chat from conversational channels to places where we can propose more complex services, including sales. Advantages that, however, must not make us lose sight of an essential element of online communication and chat: the value of the relationship with users. A value that can hardly be totally separated from the human presence and that, if neglected, risks to bring us only problems and bad results. There are activities that cannot be carried out by bots, just as it is not at all conceivable to totally eliminate the human component. The most virtuous examples, in fact, foresee an intelligent coexistence between bots and human personnel: one proposes automated services, the other intervene on issues that go beyond the machine. An excellent example of this is the activity of the aforementioned KLM. Let's talk about specific software for this. We have chosen 6 of them. Here are the best platforms to create bots: they are all easy to use and full of useful features. The 6 Best Platforms To Create Bots 1. Faqbot Faqbot offers advanced customer support options and aims to do away with classic FAQ pages on sites, replacing them with chatbots. Companies can install their own FAQbot page on their website and Facebook in just two clicks, so the user can interact with the company's FAQ via chat or messages. It is a SaaS (Software as a Service), so no programming skills are required to use the service. Just log on to the site and register. 2. Api.ai Api.ai is one of the most widely used platforms for creating chatbots. It offers human-like conversations thanks to the continuous development of machine learning based on natural language. It can also be integrated into all social networks and is super easy to use and implement. 3. Botsify Several plugins are available on Botsify to integrate chatbots on any platform. The advantage is that you can create bots without being an expert in the field thanks to an intuitive and simple drag and drop interface. To get started you can do the free trial by registering with your email address or logging in from Facebook. 4. Paquebot With Paquebot.io anyone can create their own bot community via Telegram, without the need for servers or programming knowledge, but only through the simple interface of the messaging client, but also Messenger, Line, Skype, and WeChat. To learn more about the risks and benefits of Telegram bots here is the Neomobile guide to disable them. 5. Pandora Pandorabots is one of the most popular and long-running chatbot hosting services in the world, so much so that it inspired the movie "Her". The platform offers both text and voice chat support and is used in a variety of fields: advertising, virtual assistants, e-learning, entertainment, and education. Chatbots created on Pandora find their way into messaging apps, games, social, and platforms for teaching and research. 6. ManyChat This is another bot that runs on Facebook Messenger, and it is mainly used in marketing, sales, and customer support. They like it because you can use it for free and it's easy to install. No programming skills are required - just register, sign in and start using it.

The 6 Best Platforms To Create Chatbots Without Additional Programming

is a great project management tool for companies. You can set it up to track projects, tasks, team members, and deliverables, but Airtable doesn’t have a great way to share these projects with your clients securely. Airtable There are some workarounds for this problem. You can create a shareable link to a view in Airtable, but anyone who gets a hold of that link will have access to your client’s sensitive data. Alternatively, you can give clients direct access to your Airtable base. But because Airtable lacks granular access control, they’d be able to see all your other clients’ projects, too. Finally, you could use a no-code interface builder, but then you’re limited by the features their editors support. WYSIWYG In this tutorial, you’ll see how to build a scalable, secure, and flexible client portal on Airtable using , , and . Sync Inc Cotter Next.js You’ll set up a custom application that allows your clients to log in securely and access only the data you want them to access. Finally, you’ll see how to make this application interactive so that your clients can sign off on projects directly from the portal. Each step will be outlined in this tutorial, but if you’d like to get a working copy of the final code, you can . find it on GitHub Setting Up the Airtable Base This demo project will start with the . Copy this template to your Airtable account and open up the base. Airtable Project Tracker template This base includes three tables: , , and . Tasks are for internal use only, so in this tutorial, you’ll focus on the projects and clients. Design projects Tasks Clients You’ll use Cotter to authenticate users by their email address, but this template doesn’t come with a client email field. So, you need to add a new column to the table called . Clients Email Add some dummy data to each of the fields, but . This will be your test client account so you can verify that the web app works. use your own email address for one of them Connecting Sync Inc to Airtable While you could build a client portal that queries the Airtable API directly, this has some major drawbacks, including the following: Airtable’s API limits you to just five requests per second, so it won’t scale well. Querying related records using the Airtable API is cumbersome and often involves multiple API calls. This can significantly reduce your app’s performance, especially when coupled with the API limit mentioned above. Postgres allows you to write much more powerful queries than Airtable’s API. If you haven’t already, sign up for a . Sync Inc account Once you’re logged in, click the button in the top right corner. Add your Airtable API key, select the base you want to replicate (it’s called by default), select , and make the destination for the replica . Add Base Project tracker Sync all tables in this base New Sync Inc database When you’re done, hit , and within a few seconds, you’ll have a Postgres replica of your Airtable data. Create Be sure to save the Postgres connection string shown, as you’ll need it for your web application. Creating a New Next.js Application is a React-based web development framework designed to run seamlessly on . While you could set up a new React application with a backend, Next.js makes the setup and configuration process simpler, so it’s a great starting point for building simple frontend applications like this one. Next.js Vercel much Assuming you’ve got a recent version of Node.js installed (version 10+ is recommended), use `npx` to create a new application from your terminal: npx create-next-app Enter a name when prompted (I used ), and the required base packages will be installed. project-tracker This project includes one API endpoint and one frontend route, which you’ll modify later in this tutorial. For now, navigate into the new project folder: project-tracker cd And open the project in your text editor or IDE of choice. Build a Custom Client Portal on Airtable Using Cotter Logins Setting Up Cotter for Authentication To allow clients secure access to your portal, you need a way to authenticate them via their email addresses. While you could build this feature yourself, you can also use a third-party authentication provider such as Cotter to set this up with almost no custom code. Setting up Cotter is pretty straightforward, but there’s a if you get lost. detailed tutorial for setting up Cotter on Next.js on their blog First, sign up for Cotter and get your API key ID and secret. Next, from your terminal, you need to install Cotter and a few other dependencies required for this demo application. npm i --save cotter cotter-node cotter-token-js Next, create a file in the root directory of your project. This will allow you to securely store your environment variables without checking them into version control. .env.local # .env.local file
NEXT_PUBLIC_COTTER_API_KEY_ID="..."
COTTER_API_KEY_SECRET="..."
PG_CONNECTION_STRING="..."
AIRTABLE_API_KEY="..."
AIRTABLE_BASE="..." Replace each with the corresponding environment variable from each of the services used in this tutorial. ... Note that the Cotter API key ID must be prefixed with . NEXT_PUBLIC_ This signals to Next.js that the variable should be made , while the other environment variables will be kept securely on the server only. available in the browser Finally, update the file to use Cotter and display a login form. pages/index.js Head styles Cotter ; { useEffect, useState } ; cotterApiKeyId = process.env.NEXT_PUBLIC_COTTER_API_KEY_ID; { [isLoggedIn, setIsLoggedIn] = useState( ); useEffect( { cotter = Cotter(cotterApiKeyId);
        cotter
            .signInWithOTP()
            .showEmailForm()
            .then( {
                localStorage.setItem( , payload.oauth_token.access_token);
                setIsLoggedIn( );
            })
            .catch( .log(err));
    }, []); useEffect( { (localStorage.getItem( ) != ) {
            setIsLoggedIn( );
        }
    }, []); logOut = {
        localStorage.removeItem( );
        setIsLoggedIn( );
    }; ( <Head>
                <title>Client Portal</title>
                <link rel="icon" href="/favicon.ico"/>
            </Head>

            <main className={styles.main}>
                <h1 className={styles.title}>Welcome to Your Client Portal</h1>
                {isLoggedIn ? (
                    <div>
                        <p style={{textAlign: "center", cursor: "pointer"}} onClick={logOut}>Log Out</p>
                    </div>
                ): (<p>Log in to view your projects.</p>)}
                <div id="cotter-form-container" style={{ width: 300, height: 200 }} />
            </main>
        </div>
    )
} import from 'next/head' import from '../styles/Home.module.css' import from "cotter" import from "react" const export default ( ) function Home const false // Shows the Cotter Login form and sets Access Token when authenticated => () const new => payload "ACCESS_TOKEN" true => err console // Sets local isLoggedIn variable => () if "ACCESS_TOKEN" null true // Deletes Access Token and logs user out const => () "ACCESS_TOKEN" false // Display the client portal page return < = > div className {styles.container} One note on the above code: I’ve opted to use localStorage instead of cookies for simplicity, but there’s . Cookies have some security benefits, especially in JavaScript-heavy applications like this. a good case for using cookies in a production environment If you’d like to test the login functionality at this point, you can run your Next.js application from your terminal. npm run dev Go to , where you should see a login form like this: localhost:3000 After logging in, you’ll see the Cotter success message. You’re now ready to integrate the frontend with Sync Inc to retrieve data for each client. Querying Data Stored by Sync Inc Now that your clients can be authenticated with Cotter, you can use the email address of each authenticated user to make a PostgreSQL query that retrieves only the projects belonging to that client. In order to accomplish this, you’ll need to create an that calls your Sync Inc database. API endpoint in your Next.js application First, install the package using NPM. node-postgres npm i --save pg Since you don’t want to expose your Postgres connection string in the browser, you need to connect to Postgres from a server-side application. NextJS API routes allow you to add backend code in the same repository as your frontend application by adding serverless functions to your folder. ./pages/api Create a new file at and connect to your Postgres database there: pages/api/projects/index.js {CotterAccessToken} ; {Pool} = ( ); connectionString = process.env.PG_CONNECTION_STRING; pool = Pool({
    connectionString,
}); import from "cotter-token-js" const require 'pg' const const new Next, you need to export a function that NextJS will call when the route is called. /api/projects ...
export (req, res) => { } default async // Authorization and database connection code will go here To get the current user’s authorization token, you can use the (imported above). Add the following to your exported function: Cotter Token JS library ... (!( req.headers)) {
        res.statusCode = ;
        res.end( );
    } auth = req.headers.authorization; bearer = auth.split( ); token = bearer[ ]; // Check that the authorization header exists if "authorization" in 401 "Authorization header missing" // Extract the token string const await const " " const 1 Decode this , to get the user’s email. If the user doesn’t have an email or the token is invalid, this code will throw an error, so wrap it in a try/catch block. JWT ...
    try { decoded = CotterAccessToken(token); } (e) { .log(e);
        res.statusCode = ;
        res.end( );
    } // Decode the Cotter JWT. Note that "decoded.payload.identifier" is the user's email const new // Get design_projects by clients.email here catch // Handle any errors console 500 "Server error. Something went wrong." Finally, you can use the following code to get all this client’s projects. Because Airtable (and therefore, Sync Inc) stores the relationship between clients and projects as an array of IDs, you can use to join clients and projects. Postgres’ ANY clause query = ; {rows} = pool.query(query, [decoded.payload.identifier]); res.statusCode = ;
        res.json(rows); // Get design_projects by clients.email const `select design_projects.*
                       from design_projects
                                join clients on clients.id = ANY (design_projects.client)
                       where clients.email like $1;` const await // Respond with results 200 This endpoint is now able to query directly from Sync Inc, so you can avoid Airtable’s rate limits. Having your data in Postgres also allows you to create more dynamic and efficient queries to get your data from Airtable. Calling the Project’s Endpoint Now that you’ve got an endpoint set up, you need to call it from your frontend, but only after a user logs in. At the top of the class you created in , add the following: Home pages/index.js … { [clientProjects, setClientProjects] = useState( ); getClientProjects = () => { token = localStorage.getItem( ); resp = fetch( , { : { : },
        });
        setClientProjects( resp.json());
    };
… export default ( ) function Home const null // Gets this client's projects when they're logged in const async const "ACCESS_TOKEN" const await "/api/projects" headers Authorization `Bearer ` ${token} await Now, in the same file, update the Cotter login form effect to call the method after the user is authenticated. getClientProjects …
        cotter
            .signInWithOTP()
            .showEmailForm()
            .then( {
                localStorage.setItem( , payload.oauth_token.access_token);
                setIsLoggedIn( ); getClientProjects();
            })
            .catch( .log(err));
… => payload "ACCESS_TOKEN" true // Add this line: => err console If you restart your Next.js application and log in again with your browser’s inspector open, you can see that a call is being made to . /api/projects In the next step, you’ll use the results from that API call to populate your client portal. Displaying Projects in the Portal Now that you’re able to authenticate a user and retrieve their projects from Sync Inc’s Postgres replica, you’re ready to display the results in the UI. Next.js already includes some basic styling, but don’t feel limited by it. One of the big advantages of building a custom portal like this is that you have complete control over the user interface and experience. Open your file again and add the following within the code that checks whether a user is logged in: pages/index.js …
                {isLoggedIn ? ( <div className={styles.grid}>
                                {clientProjects.map(project =>
                                    <div className={styles.card} key={project.id}>
                                        <h3>{project.name}</h3>
                                        <img src={project.project_images[0]} style={{maxWidth: "100%"}} />
                                        <p>Led by {project.project_lead.name}</p>
                                        <p>Due on {project.due_date.split('T')[0]}</p>
                                    </div>
                                )}
                            </div>
                        ) : (<p>You currently have no projects attached to this account.</p>)}
                        <p style={{textAlign: "center", cursor: "pointer"}} onClick={logOut}>Log Out</p>
                    </div> <p>Log in to view your projects.</p> {clientProjects ? ( < > div ): ( )}
… Start the app again and log in, making sure to use your email address that you attached to one of the client accounts in Airtable. You should see a list of all this client’s projects like this: You now have a working client portal that will allow your clients to securely access limited data about their projects only. But what if you want to allow clients to interact with the projects in the portal? In the last section of this tutorial, you’ll see how to allow clients to save data to Airtable using . Sync Inc’s write proxy Writing Data with Sync Inc Your clients will probably need to sign off on each project as it’s completed. To let them do this in your new portal, you can add a checkbox on each project that lets clients mark projects as complete. Sync Inc gives you a read-only Postgres replica of your Airtable base. This ensures that you have a single source of truth for your data, but it means that you can’t use typical Postgres to make changes in Airtable. queries UPDATE Fortunately, Sync Inc has a solution to this limitation. By using instead of the standard Airtable API server, your updates will be instantly saved to both Airtable and your Postgres database. their proxy server To use the Sync Inc proxy in JavaScript, install the Airtable NPM package: npm i --save airtable Next, create a new endpoint in your Next.js application that will handle update requests. Make a new file at and add the following: pages/api/projects/[projectId].js {CotterValidateJWT} ; Airtable ; base = Airtable({ : process.env.AIRTABLE_API_KEY, : ,
}).base(process.env.AIRTABLE_BASE); (req, res) => { { projectId } = req.query; (!( req.headers)) {
        res.statusCode = ;
        res.end( );
    } auth = req.headers.authorization; bearer = auth.split( ); token = bearer[ ]; { valid = CotterValidateJWT(token); (!valid) {
            res.statusCode( );
            res.end( );
        } base( )
            .update([{ : projectId, : { : }}]); res.statusCode = ;
        res.end();
    } (e) { .log(e);
        res.statusCode = ;
        res.end( );
    }
} import from "cotter-node" import from "airtable" // Instantiate the Airtable client using the Sync Inc proxy const new apiKey endpointUrl "https://proxy.syncinc.so/api.airtable.com" export default async // Get the project ID from the URL const // Check that the authorization header exists if "authorization" in 401 "Authorization header missing" // Extract the token string const await const " " const 1 try // Check that the JWT is valid const await if 403 "Authentication token invalid" // Update project complete status await 'Design projects' "id" "fields" "Complete" true // Respond with a 204 204 catch // Handle any errors console 500 "Server error. Something went wrong." This endpoint validates the user’s authentication JWT from Cotter to ensure that unauthenticated users cannot access this endpoint and then uses the Airtable API library to update the field to true. Also notice that at the top, we specified the Sync Inc proxy URL as the API’s . This routes requests through Sync Inc to keep your Postgres database up-to-date at the same time as the Airtable base. Complete endpointUrl Next, you need a checkbox in your template and a method to call the new endpoint from the frontend. Add this method to your component before the statement: Home return … markProjectComplete = (e) => { completeProjectId = e.target.value;
        setClientProjects(clientProjects.map( { (project.id === completeProjectId) {
                project.complete = ;
            } project
        })); token = localStorage.getItem( ); fetch( + completeProjectId, { : { : }, : ,
        });
    };
… // Allow clients to mark a project as complete const async const => project if true return const "ACCESS_TOKEN" await "/api/projects/" headers Authorization `Bearer ` ${token} method "PUT" Finally, add this paragraph just below your due date inside the loop that displays all your clients’ projects in the same file: …
<p> … Project complete < = = = = = = /> input type "checkbox" name "complete" value {project.id} onChange {markProjectComplete} disabled {project.complete} defaultChecked {!!project.complete} </ > p Start your Next.js application again and log in at . This time you’ll see a checkbox next to each project. Check one of the records, and you’ll see that the checkbox will be disabled. This prevents clients from approving the same project multiple times, but of course, you can modify this behavior to fit your use case. localhost:3000 To make sure the synchronization works, go to your Airtable base to see if the record has been synced yet. If you’re fast, you can see Airtable marking the project complete in the base. Next Steps In this tutorial, you’ve seen how to build a flexible, scalable client portal on top of Airtable. You used to replicate your data to Postgres, Cotter to authenticate users via email, and Next.js to build a frontend with two serverless endpoints. Sync Inc As you adapt this demo to your use case, you might consider adding pages for each project so that clients can see more details about each of them. Or you might connect multiple emails to each client to allow different stakeholders to get access to their portal. You could even integrate Stripe to allow clients to make payments directly in your customer portal. Many thanks to Karl Hughes for contributing this tutorial for Sync Inc. Karl is a former startup CTO and the founder of Draft.dev Previously published at https://docs.syncinc.so/playbooks/client-portal

How To Create A User Portal On Airtable With Sync Inc And React

In my previous , I went through how to create a maintenance mode page for your application, and how to implement it using Terraform and github pages. But the website is just one part of an Application, and often there’s also a public (or private) API that also needs to have a maintenance mode. Let’s see how we can do that using Terraform on API Gateway. blog post Architecture As previously mentioned, we host all of our infrastructure on AWS, with a clear separation between the Application and the API: The front end is a React application, hosted on S3 with CloudFront as a CDN. The Backend services are mostly Serverless using AWS Lambda with API Gateway that manages our public API. DNS is managed by Route 53. Implementing a Solution Beyond the requirements , we had one new one: When the API is in maintenance it should return “503 Service Unavailable” response This led us led us to the following solution: for our webpage maintenance mode with an informative message. Create a new API Gateway that will be dedicated to the maintenance mode This API will use a mock integration It will return the same response for all endpoints using proxy resource This mocked API will co-exists with our real API. We will use and change the base mapping between the real API and the mocked one. custom domain Based on that, let’s see the Terraform code in action: Mocked API Gateway Looking at the code you are able to see that we are using ANY method together with “{proxy+}” to achieve the ability to cover all resources with a simple configuration, and using the response template to generate the “503 Service Unavailable” response with a clear message to the end user. resource {
  name        = description = } {
  rest_api_id = aws_api_gateway_rest_api.maintenance_mode_api.id
  parent_id   = aws_api_gateway_rest_api.maintenance_mode_api.root_resource_id
  path_part   = } {
  rest_api_id   = aws_api_gateway_rest_api.maintenance_mode_api.id
  resource_id   = aws_api_gateway_resource.maintenance_mode_resource.id
  http_method   = authorization = } {
  rest_api_id          = aws_api_gateway_rest_api.maintenance_mode_api.id
  resource_id          = aws_api_gateway_resource.maintenance_mode_resource.id
  http_method          = aws_api_gateway_method.maintenance_mode_method.http_method = timeout_milliseconds = 29000
  passthrough_behavior = request_templates = { = <<EOF
    { : 503}
EOF
  }
} {
  rest_api_id = aws_api_gateway_rest_api.maintenance_mode_api.id
  resource_id = aws_api_gateway_resource.maintenance_mode_resource.id
  http_method = aws_api_gateway_method.maintenance_mode_method.http_method
  status_code = } {
  rest_api_id = aws_api_gateway_rest_api.maintenance_mode_api.id
  resource_id = aws_api_gateway_resource.maintenance_mode_resource.id
  http_method = aws_api_gateway_method.maintenance_mode_method.http_method
  status_code = aws_api_gateway_method_response.maintenance_mode_response_503.status_code

  # Transforms the backend JSON response XML
  response_templates = { = <<EOF EOF
  }
} {
  depends_on  = [aws_api_gateway_integration.maintenance_mode_integration]
  rest_api_id = aws_api_gateway_rest_api.maintenance_mode_api.id
  stage_name  = } "aws_api_gateway_rest_api" "maintenance_mode_api" "maintenance-mode-API" "This is my Maintenance mode API" resource "aws_api_gateway_resource" "maintenance_mode_resource" "{proxy+}" resource "aws_api_gateway_method" "maintenance_mode_method" "ANY" "NONE" resource "aws_api_gateway_integration" "maintenance_mode_integration" type "MOCK" "WHEN_NO_MATCH" "application/json" "statusCode" resource "aws_api_gateway_method_response" "maintenance_mode_response_503" "503" resource "aws_api_gateway_integration_response" "maintenance_mode_integration_response" to "application/json" #set($inputRoot = $input.path('$')) { "message" : "Sorry for the inconvenience but we are performing some maintenance at the moment. We will be back online shortly!" } resource "aws_api_gateway_deployment" "maintenance_mode_deployment" "prod" Now using a custom domain we can control the maintenance mode, so the base path mapping will either point to the real API and in case of a maintenance mode it will point to the mocked API. resource {
  certificate_arn = var.certificate_arn
  domain_name     = var.domain_name
} {
  api_id      = var.is_maintenance_mode ? aws_api_gateway_rest_api.maintenance_mode_api.id : aws_api_gateway_rest_api.api.id
  stage_name  = var.is_maintenance_mode ? aws_api_gateway_deployment.maintenance_mode_deployment.stage_name : aws_api_gateway_deployment.deployment.stage_name
  domain_name = aws_api_gateway_domain_name.domain_name.domain_name
  base_path   = } "aws_api_gateway_domain_name" "domain_name" resource "aws_api_gateway_base_path_mapping" "base_mapping" "/" Also in AWS, we want to ensure that Route53 is pointing in the custom domain we’ve created. As opposed to the application maintenance mode, here our custom domain switches on and off our maintenance mode and not our DNS record. resource {
  zone_id = name    = type    = alias {
    name                   = aws_api_gateway_domain_name zone_id                = aws_api_gateway_domain_name evaluate_target_health = false
  }
} "aws_route53_record" "api_dns_record" var .route53_zone_id var .route53_suffix_domain_name "A" .domain_name .regional_domain_name .domain_name .regional_zone_id ⚠️ Pay attention that this Terraform code does not create the Route53 hosted zone, nor the SSL certificates — you need to complete those as appropriate for your own setup ⚠️ Deployment Now that our system is all configured, all I have to do is change the Terraform variable of the maintenance mode to be true/false and deploy the environment (in our case via the env0 UI). The complete template source code can be found in this which includes all the Terraform code. We hope you find this useful, or get other ideas for more ways to use Terraform for your deployment workflows. github repo About env0 env0 lets your team manage their own environments in AWS, Azure and Google, governed by your policies and with complete visibility & cost management. You can learn more about env0 and you can also . here try it out yourself Feel free to drop us your thoughts below! Previously published at https://www.env0.com/blog/creating-a-maintenance-mode-for-your-api-gateway-with-terraform

Building Maintenance Mode for your API Gateway Using Terraform

is an alternative to the provided to Amazon Associates. If you are thiking of building sites with Amazon links and you don’t have an , or if you want to build a lot of pages very quickly without limitation, using is the answer. If you are serious about earning money as an Amazon Affiliate and want to make do yourself a favor and start the project off right. Rainforest API Amazon Product API shopping comparisson API key Rainforest API thousands of pages, limit is tied to your and number of . The last thing you need is Amazon your site and limiting your revenue. Consider building using the . Amazon’s API revenue calls throttling Rainforest API Many companies choose to run no matter what the project. Creating engines or are not the first thing most people think of when they think of the CMS. However, when you look at and other highly functional plugins, you can see why companies are ensisting WordPress be used in all applications even if its not the easiest integration. has excellent documentation, but their documentation begins with the and ends with the . The guide is for the . WordPress shopping comparison top product lists WordPress WooCommerce Rainforest API call output WordPress user How To This “ ” guide will walk you through creating and displaying data on a page. By the end of the guide you will have a the for the category “Musical Instruments”. Once you have completed this guide you will be comfortable working with the to output data to How To API calls WordPress page displaying Top 10 products API Wordress pages. What You Need Domain Name Cloud Instance With Installed ( Is Great). WordPress Vultr Free Account From .Free Rainforest API Json-Content-Importer Plugin for WordPressCode and Instructions Provided Below Getting Started Sign into WordPress as .Click on , Then Plugin. Admin Plugins Add New Search for , and . Json Content Importer Install Activate If you are using a make sure it is setup to automatically or make sure you when testing. caching plugin detect changes clear your cache Click on then “ “, give your page the title . Pages Add New Top 10 Musical Instrument Best Sellers List Click on . , it should be empy with showing. Publish View your page no errors Leave the tab with your WordPress site open. and On one go to and the other go to . open two additional tabs. rainforestapi.com amazon.com How To Get Your API Link 1. At click on “ ” and you used when you signed up. and . rainforestapi.com Log in enter the credentials If you haven’t signed up, do so now login 2. Click on on the left side of the screen. API Playground 3. Go to in your other open browser tab and navigate to the Amazon.com Best Sellers https://www.amazon.com/Best-Sellers/zgbs/ 4. Click on on the left hand side. Musical Instruments 5. from the Musical Instruments Best Sellers page and navigate back to the tab thats open in your browser. Copy the URL Rainforest API You should still be in the API Playground (if not click on it). 7. The first box in API Playground says and has set by default. Select Dropdown Type Product BestSellers from the drop down list. 8. In the box from the Musical Instrument Best Seller list we copied from : URL paste the link Amazon.com https://www.amazon.com/Best-Sellers-Musical-Instruments/zgbs/musical-instruments/ref=zg_bs_nav_0 9. The rest of the boxes on this page should be blank except for which should be and which is your . You can find this ID by logging in to your Amazon Associates account, or leave blank if you dont have one yet. output JSON Associate ID Amazon Associate ID 10. Press the button. Send API Request 11. Scroll up to the . You should have the from the displaying on the right hand side. You will see in the something called , this contains all the information needed. on this and on one of the to display the single product information. top of the page output API request output bestsellers array Click array click numbers * Note that inside bestsellers there is another array called price. The code accesses the price array to demonstrate this with the JSON Content Importer shortcode for WordPress. 12. In the Rainforest API dashboard on “ “. click Code Sample 13. Rainforest API offers in , Curl, Node.JS, Python and PHP. For our purposes, and click the to copy the to . , the should begin with — the Amazon link from earlier. Code Samples URL select URL copy button URL clipboard Paste this URL somewhere safe URL https://api.rainforestapi.com NOT Configuring WordPress For Rainforest API 14. back to the browser tab that has your open. the you created earlier called . Go WordPress session Open page Top 10 Musical Instrument Best Seller List 15. Copy the code between the leading /* and ending */ comment tags: /* [jsoncontentimporter ”https://api.ra orestapi.com/request? XXXXXXXXXXXXXXXXXXX&amp; bestsellers&amp; quadrant0d- &amp; json&amp; https% A% F% Fwww.amazon.com% FBest-Sellers-Musical-Instruments% Fzgbs% Fmusical-instruments% Fref% Dzg_bs_nav_0”] & ;div & ; & ;table & ; & ;tr& ;& ;td& ;& ;hr& ;& ;/td& ;& ;/tr& ; {subloop-array:bestsellers: }{subloop:bestsellers.price: } & ;tr& ; & ;td& ;& ;b& ;& ;center& ;{bestsellers.rank}. & ;/b& ;& ;a & ;{bestsellers.title}& ;/a& ;& ;/center& ;& ;/td& ; & ;/tr& ; & ;tr& ; & ;td& ;& ;center& ;& ;a & ;& ;img & ;& ;/a& ;& ;/center& ;& ;/td& ; & ;/tr& ; & ;tr& ; & ;td& ;& ;center& ;& ;b& ;Rating: {bestsellers.rating}& ;/b& ;& ;/center& ;& ;/td& ; & ;/tr& ; & ;tr& ; & ;td& ;& ;center& ;& ;a & ;& ;b& ;{bestsellers.price.raw}& ;/b& ;& ;/td& ; & ;/tr& ; & ;tr& ; & ;td& ;& ;center& ;& ;img & ;& ;/center& ;& ;/a& ;& ;/b& ;& ;/center& ;& ;/td& ; & ;/tr& ; & ;tr& ;& ;td& ;& ;hr& ;& ;/td& ;& ;/tr& ; {/subloop:bestsellers.price}{/subloop-array:bestsellers}& ;/table& ;& ;/div& ; [/jsoncontentimporter] */ <code class="markup--code markup--pre-code"> url= inf api_key= type= associate_id= 20 output= url= 3 2 2 2 2 2 2 3 <br> lt style= "overflow-x:auto;" gt <br> lt class= "tenstyletable" gt <br> lt gt lt gt lt gt lt gt lt gt <br> 10 10 <br> lt gt <br> lt gt lt gt lt gt lt gt lt href= "{bestsellers.link}" rel= "nofollow" gt lt gt lt gt lt gt <br> lt gt <br> lt gt <br> lt gt lt gt lt href= "{bestsellers.link}" rel= "nofollow" gt lt src= "{bestsellers.image}" gt lt gt lt gt lt gt <br> lt gt <br> lt gt <br> lt gt lt gt lt gt lt gt lt gt lt gt <br> lt gt <br> lt gt <br> lt gt lt gt lt href= "{bestsellers.link}" rel= "nofollow" gt lt gt lt gt lt gt <br> lt gt <br> lt gt <br> lt gt lt gt lt src= "https://i.ibb.co/wMt3hy2/homebtn-1.jpg" gt lt gt lt gt lt gt lt gt lt gt <br> lt gt <br> lt gt lt gt lt gt lt gt lt gt <br> lt gt lt gt <br> </code> 16. the after with the you copied from when we sent the request for the . At this point the code should start displaying products if you preview the post. to see the finished example. Replace URL [jsoncontentimporter url=” URL Rainforest API Top 10 Musical Instrument Best Seller List Click Here As an alternative , you can simply replace the XXXXXXXX’s in the above code with your API key . 17. The product list will likely look malformed, but the data should show up. If you look at the code, is defined by the tag. We need to to to style the table. class=”tenstyletable” table add CSS Worpress 18. On your page, click on the WordPress , then click on , and paste the following code: Top 10 Musical Instruments customize Admin bar Additional CSS < class= > {<br> : collapse;<br> : table-cell;<br> : middle;<br> : ;<br>}</code> code "markup--code markup--pre-code" table .tenstyletable td border-collapse display vertical-align border 0 19. Your table should now be showing the list. If your formatting is off simply adjust the CSS. to see an example page. Top 10 Click Here This guide provides the logic to build out more complicated pages using the and . With a few to the above, you can display other information the feed provides or change the way the is handled. If you want to increase the the number of products displayed for example, simply the in and — instead of 10 use a another number. Rainforest API WordPress minor changes boilerplate code JSON output change numbers {subloop-array:bestsellers:10} {subloop:bestsellers.price:10} For more be sure to read the documents. advanced configurations JSON-content-importer

Using Rainforest API With WordPress [A How-To Guide]

Chatbots are becoming a very viable customer support solution that allows automated interactions in real time. Bots are in trends with business practices that have become one of the attractive platforms in today’s time. There are many Startups with their own framework and functional that are offerings chatbots to interact, engage and even handle the users. Big Giants like Facebook and Microsoft have already released extensive bot frameworks. With demand, there are many chatbots being developed on Facebook Messenger. Likewise, many have signed up for the Facebook Bot Engine to integrate with their own model. mobile app developers What are Bot Frameworks? Bot Framework is where bots are built. Here bots are defined with behavior according to the usage. Talking about they develop messaging platforms and SDKs for Chatbot development. The Bot development framework comprises the Bot Connector, Bot Directory, Developer Portal, and Bot Builder SDK. These frameworks are software frameworks that reduces much of the manual work that is involved in building chatbots. Chatbot Developer Some Bot Frameworks are: Facebook Bot Engine: Having Messenger platform and ownership of WhatsApp, Facebook is the leading player in messaging services. This is the reason why it has invested so heavily in communication bots. Facebook Bot Engine is based on Wit.ai technology. Talking about Wit.ai it runs from its own server in the cloud. And the Bot Engine is a wrapper built to deploy the bots in Facebook Messenger platform. Facebook’s is all about the number of the users connected to it. Due to the power of the social media network, Facebook doesn’t need any other Bot development platform. In simple words, we can say that Facebook Messenger itself is a humongous space on its own. Facebook is trying to adopt new strategies with the Facebook Bot Engine hence Facebook Messenger users are going to get a variety of specialized chatbots experience. The Facebook Bot Engine is dependent on Machine Learning which provides power to handle many different replies to the same questions. The potential of Wit.ai offers certain options to developers that could improve their chatbots. Microsoft Bot Framework: Microsoft bot has the same popularity as Facebook, it was declared at the same time when Facebook bot Engine came into the market. Microsoft had a different philosophy with the approach and it offers Microsoft’s SDK that can be viewed as two independent components: Bot Connector and LUIS.ai. LUIS.ai is the natural language understanding component and Bot Connector is the integration Framework. The best part of these components is remarkable. Moreover, the Microsoft Bot Framework’s integration component can be integrated with Slack, Facebook Messenger, Telegram, Web chat, SMS, email and Skype. Microsoft Bot Framework offers features to build and deploy good quality of chatbots for users. The focus is to make the user interact naturally wherever they are chatting to other platforms. Microsoft Bot Framework offers what we need to build, connect, manage and enjoy our favorite conversation experiences. The user can easily connect with different platforms like Slack, Skype, Facebook Messenger, Kik, etc. API.ai: API.ai is another web-based bot development framework that is popular for building conversational interfaces. It offers pre-built Agents that developer can import to project and customize depending on needs. If your Chatbot is supposed to be fully unique you don’t need most of the extra agents due to the pre-built Agents. However, you can still import a few modules with common topics like “hello,” “goodbye,” “emotions,” or “courtesy,” and make your bot interactive. Apart from that API.ai provides some of the SDKs and libraries for bot development such as Android, iOS, Webkit HTML5, JavaScript, Node.js, Python, etc. Highlights about API.ai as follows: Agents: Agents match up according to the applications. Once an agent is trained and tested it can be integrated with app or device. Entities: It signifies the concepts that are often specific to a domain. It helps in mapping NLP (Natural Language Processing) phrases to approved phrases that catch their meaning. Intents: It is all about the coordination between what a user says and what action should your internal software takes. Actions: Actions correspond to the steps that your application will take when intents are triggered by user inputs. Contexts: Contexts are strings that are useful for differentiating phrases. API.ai clarifies the current context of the user expression that might be confusing and have different meaning depending on what was spoken previously. It is well-organized and possesses a friendly user interface. Due to the pre-built agents, it is really easy to start building a chatbot. Moreover, it’s a good engine to develop a simple or a middle-level chatbot. The best part is that it fits many platforms at once. Aspect CXP and Aspect NLU Aspect CXP and Aspect NLU are two blends of an interface that offer human-like conversational whenever user chats with them. Talking about Aspect Customer Experience Platform (CXP), it is a platform for designing, implementing, and deploying multichannel customer service applications. And Aspect NLU is a component which gives the sense of human language while having the chat. Aspect CXP helps to design, implement and deploy customer service applications effortlessly. When we talk about Multiple communication channels like text, voice, mobile web, social media networks like Twitter, Facebook, etc. can be easily processed using Aspect CXP. Whereas, Aspect NLU allows scaling through automation, with a robotic feel of chatbots. Apart from that, it offers the human-like conversational tone to self-service dialogues on Facebook Messenger. It tries to engage the user without distracting the continuous conversation. Wrapping Up… Chatbots have created a very wide range of services that help users to interact with a computer using a simple chat-like interface. There are many platforms and frameworks offering services to assist users if anyone is having trouble in anyways. Above we discussed some of the Bot frameworks available in the market for developers to build bots according to the customer utilities. There are many bot frameworks provide an opportunity for developers to deploy code anywhere. With the integration of artificial intelligence, these chatbots provide an advanced experience. Chatbots are engaging customer in every manner. As a result, it has drastically changed many business processes and strategies. There are many in the industry that are offering Chatbot featured service to their client. App development companies Originally published at bigstartups.co .

The Most Popular Chatbot Frameworks For Building Intelligent Business Bots

There are many platforms with NLP, such as: chatbot Rasa: Open source conversational AI Dialogflow Bot Framework Wit.ai Amazon Lex — Build Conversation Bots We evaluated most noteworthy of bot platforms for building chatbots for customer support and service industry. Finally, and Rasa came on top in our priority list. Dialogflow This article covers the differences between Dialogflow and Rasa, and helps you understand which one to choose. Dialogflow Dialogflow is a Google-owned product. They have developed human-computer interaction technologies based on natural language conversations. Dialogflow is a complete closed source product with API and web interface. Dialogflow was previously known as api.ai and got by Google in 2016. acquired Rasa Rasa is an open source machine learning tool for developers and product teams to expand bots beyond answering simple questions.Rasa comes with Rasa NLU and Rasa Core. The NLU handles intents and entities while the Core handles dialogues and fulfillment. Dialogflow vs Rasa — Major Differences First of all, we found Dialogflow to be super easy to use. Almost everything is available in the user interface and you can create a bot without writing even a single line of code. Dialogflow provides everything from Entities, Intent, Training, Analytics, History to Integrations. They are available in the user interface. It is like a full-fledged ready to use service. In contrast, you will have to build things up on top of Rasa. Also, it requires python development for customizing the bot. Projects providing UI in Rasa Articulate Rasa UI Dialogflow meet everyone’s demand and it is more generalized. In Rasa, you can customize the bot and it requires python development. Free and paid plans are available in both. How to migrate from Dialogflow to Rasa? Migrating from Dialogflow to Rasa is easy. Dialogflow provides a way to export the agent in zip files. You can then train Rasa NLU using the same downloaded data. Then modify the API URL to point to Rasa NLU server. Detailed instructions are available . here Conclusion We wanted more control over customization so went ahead with Rasa for building our custom bots such as . For basic bots and customers who are already using Dialogflow, we added support for easy . Liz dialogflow integration How do you rate Dialogflow vs Rasa and why? Let us know in the comments below, we would love to hear them. This article was originally posted here.

Stories, News & Mentions about API7AI

Api7ai’s Stories on HackerNoon