Author: Franz Malten Buemann

If you’ve spent any time testing your Dialogflow ES or CX while creating agents, working with webhooks, and integrations with other platforms, you’ve probably seen various error messages. In this post, we cover some of the most common errors, and how to resolve those errors.

Dialogflow ES erros & solution

API call mentions an unknown project

The error would be like,Dialogflow API has not been used in the particular project id error for API call.

Solution

To resolve this issue, ensure you have done the following.

Set the GOOGLE_APPLICATION_CREDENTIALS environment variable and then also check if you have provided the correct project ID to the API call. Please refer to this doc for setting environment variables.

Unable to delete project

When trying to delete a GCP project, you might get a notification that the project cannot be deleted, It is due to different ownership property, and one of the liens is related to Dialogflow.

Solution

You should delete the Dialogflow ES agent linked to the project.

Open Dialogflow console. If you get a notification that the agent doesn’t exist, it means your agent has been deleted. Otherwise, check if you no longer need the agent and delete it.

Console fails to set up a project

Sometimes you might get the console error Failed to set up GCP project error when creating an agent within the console.

Solution

The permission might have been restricted to create GCP projects. Check if your account/role has permission to create a GCP project directly from the GCP Console. If you are not able to create a project, follow the recommendations provided in the error message or recommend the admin to provide the permissions.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

API call gets permission denied

The API call received a PERMISSION_DENIED response. This might happen on both ES & CX.

Solution

To resolve the error, please ensure you have set up Dialogflow ES authentication and the roles correctly. Also, ensure you have done the following:

Created a service account earlier and didn’t delete it.

Then provided the service account with a role that grants permission to call the desired method.

Downloaded the service account private key file of the project.

Set the GOOGLE_APPLICATION_CREDENTIALS environment variable to the private key file.

Please refer to this doc for setting environment variables.

DEADLINE_EXCEEDED

If you are using webhooks for actions integration then the Dialogflow agent acts as conversational fulfilment for your Actions on Google. For the back-end webhook. Some of the requests might be receiving this error Webhook call failed. Error: DEADLINE_EXCEEDED Request timed out

Webhook timeout limit for Actions on Google integration is 10 seconds. For all other integrations, including self-developed implementations sending requests to the Dialogflow API, webhook timeout is 5 seconds. These values are not customizable. The timeout limit includes time for Dialogflow requests to your webhook endpoint, the webhook processing time, and webhook response time back to Dialogflow.

Conversational interfaces are meant to be designed as a continuous message exchange between the end-user and the app/bot. If the web service requires more time for executing operations in the background and this cannot be optimized, consider redesigning the conversation flow in such a way that end-users don’t wait for the app/bot reply for more than 5 seconds (10 for Actions on Google).

Suggested read: A complete overview of Dialogflow CX vs Dialogflow ES

Dialogflow CX erros & solution

Dialogflow Console fails to create an agent

If you have not enabled Dialogflow API for the project then you will receive the error.
Code: FAILED_PRECONDITION error when creating an agent with the console.

Solution

You just need to enable the Dialogflow CX API for the particular project. Please refer to this doc for enabling the API for Dialogflow CX.

Dialogflow CX no response

No agent response for Dialogflow CX interactions when integrated with other messaging or bot platforms.

Solution

If you are not seeing any responses from Dialogflow CX, you should enable billing and Dialogflow API on the project. Please refer to this doc for enabling the API for Dialogflow CX.

Disclaimer: This blog was originally published here.

Don’t forget to give us your 👏 !

---

Handle Dialogflow Errors (ES & CX) was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

Expo, React native… on boarding chatbot : Part two

How onboard user, simply and efficiently.

This is the second part of my chatbot article.
This time we will focus on making an input animation, indicating that your interlocutor is typing.
If you missed the first part, it’s over here !

As I explained in the first part, the chatbot and the user use bubbles, but there is a big difference… this famous animation.

This little animation gives life to the chat, and allows to simulate an interaction with a person and not a machine.

For this animation, we will create 2 components.

• The first one, chat-typing which will be the animation component. A kind of animated bubble with an opening and closing animation.
• The second component, chat-bubble, will look like the user-bubble but with the management of the chat-typing component.

At the end we will modified the chat-bot screen created in the part one, to used the chat-bubble component.

Chat-typing

Let’s take a closer look at the design.
We can see 3 black circles, spaced one from the other, and with different opacity. You have to imagine this animated board of course …

We will break this down into three components. Dot, AnimatedWrapper, and finally the exported component ChatTyping.

Dot :

const Dot = ({ color = 'black', size = 8 }) => (
    <View
style={{
            width: size,
            height: size,
            borderRadius: (size || 0) / 2,
            backgroundColor: color
        }}
    />
)

A simple component with 2 props with default value, that can be easily modified.

AnimatedWrapper :

const AnimatedWrapper = ({ delay, children }) => {
const [timing] = useState(new Animated.Value(0))

    useEffect(() => {
const animation = Animated.sequence([
            Animated.delay(delay),
            Animated.loop(
                Animated.timing(timing, {
                    toValue: 1,
                    duration: 987,
                    useNativeDriver: true
})
            )
        ])
        animation.start()
return () => animation.stop()
    }, [])

const opacity = timing.interpolate({
        inputRange: [0, 0.5, 1],
        outputRange: [0.2, 1, 0.2]
    })

return (
        <Animated.View
style={
                {
                    justifyContent: 'center',
                    alignItems: 'center',
                    width: 18,
                    opacity
                }
            }>
            {children}
        </Animated.View>
    )
}

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

This component is more complex. We will use the children props which is available for all react components to reuse the animation logic. We wrap children, in this case the circle, to animate it :

<Animated.View
style={
        {
            justifyContent: 'center',
            alignItems: 'center',
            width: 18,
            opacity
        }
    }>
    {children}
</Animated.View>

For the animation we use the Animated library of react native. If you have never used this library I advise you to look at the documentation and play with it a bit.

Let’s start our animation…

We create a state variable (timing), to animate the opacity of the encapsulated object, the circle. We initialise its value to 0. We find this variable in the object loop and in the interpolate function.

const [timing] = useState(new Animated.Value(0))

During the component initialisation, in the useEffect. We create the animation variable. It is an animation sequence, in our case, a delay, and a loop, with start and stop method.

• The delay will allow us to starts animation after the given delay.
• In the loop method, we pass a time animation with the timing method… this method will in a given time (duration), update our state variable, up to the desired value (toValue).

We will now interpret the value of our state variable with the interpolate method. Here is an excellent article explaining in details, the principles of this method. (https://eveningkid.medium.com/interpolation-with-react-native-animations-853e467fe5c1) :

const opacity = timing.interpolate({
    inputRange: [0, 0.5, 1],
    outputRange: [0.2, 1, 0.2]
})

The principle is to interpret the value of our state variable, using an array representing different input points (inputRange) to obtain a value according to the array we pass to it (outputRange).
In our case, for the value 0 we will get 0.2 in output, for the value 0.5 we will get 1, etc.

this way our state variable opacity will oscillate between 0.2 to 1 depending of the timing value.

ChatTyping :

Let’s put that togever…

function ChatTyping () {
const delayValues = [0, 300, 600]
return (
        <Fragment>
            <View style={styles.bubble}>
                <View style={{ flexDirection: 'row' }}>
                    {delayValues.map((delay) => (
                        <AnimatedWrapper key={delay} {...{ delay }}>
                            <Dot/>
                        </AnimatedWrapper>
                    ))}
                </View>
            </View>
        </Fragment>

    )
}

We declare a array of delay values, then use it with a map function and for each value as a millisecond delay, we pass it to the AnimatedWrapper as a de-structured object props :

{delayValues.map((delay) => (
    <AnimatedWrapper key={delay} {...{ delay }}>
          <Dot/>
    </AnimatedWrapper>
))}

Dot is wrapped by AnimatedWrapper and will be animated.

Chat-bubble

In the first part of this article, we have created a user-bubble component. Chat-bubble have the same approach with the chatTyping management.

We initialise de component by starting the chatTyping animation :

useEffect(() => {
let timer
if (!isTyping) {
        Opening.start()
    } else {
        FadeIn.start(() => {
            timer = setTimeout(() => {
                FadeOut.start(() => {
                    setTypingVisibility(false)
                    Opening.start()
                })
            }, 1000)
        })
    }
return () => { timer && clearTimeout(timer) }
}, [])

Like in the user-bubble component, opening is a parallel function used to change the opacity and horizontal position.

FadeIn and FadeOut are both animations created to display the chatTyping animation. You can easily guess their roles…

IsTypingVisibility state variable is used to display either the chatTyping animation or the bubble.

The start method of the animated library takes a completion callback that will be called when the animation is done. So, at the end of the FadeIn animation, we create a setTimeout method called timer. This will represent the duration of the chatTyping animation display. By setting isTypingVisibility to false we simply display the bubble.

return (
    <View style={styles.container}>
        {isTypingVisibility
            ? <Animated.View style={{ opacity: typingOpacityAnimated }}>
                <ChatTyping />
            </Animated.View>
            : <Animated.View style={{ ...styles.bubble, opacity: opacityAnimated, transform: [{ translateX: positionAnimated }] }}>
                <Text style={styles.textBubble} >{data.text}</Text>
            </Animated.View>}
    </View>
)

Few Chatbot Screen modification to finish

useEffect(() => {
if (data) {
        setComponents([
<BubblesFactory data={data?.chatBot.messages} bubble={<ChatBubble/>} interval={3000}/>
        ])
    }
}, [])

We add the chat-bubble component in the components array and modify the interval by adding 2s more to display the chatTyping animation. This way we have the typing animation and then the bubble just after.

You can find the all source code here.

Next step !

It’s finish for today… Thank you for taking the time to read this article. Don’t hesitate to leave comments, ask questions, improvements.
The next part, will be on the mechanics or how to make all the components communicate together and…

Don’t forget to give us your 👏 !

---

Expo, React native… on boarding chatbot : Part two was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

Expo, React native… on boarding chatbot : Part one

How onboard user, simply and efficiently.

The purpose of this article is to share my approach from start to finish to create software that exactly meets the demand. Examples have always been a great help for me. It is also important to share experience to evolve and exchange.

Prerequisites :

You need to know React and React-native’s ecosystem and familiar with react hooks, functional component and their life cycle. I’ll provide source code for each part of this article, but you can easily create you own project using Expo CLI.

While building a React Native application for car rentals, we needed users to validate some options and provide us some documents.

The solution found is to simulate exchange with us, through an interface where the user could interact with us and send us some documents.

I had a Figma board for the full scenario from the designer team :

What the design shows us is a scrollView with the chatbot’s bubbles on the left and the user’s bubbles on the right. A button positioned at the bottom fixed and therefore not part of the scrollview.

Starting from there, i was able to identify several things, but mostly a repetitive process :

• The bot asks for something and the user answers with an action.
• For each chatbot bubbles we have a typing animation.
• For each bubbles we have opening animation.
• At the end of chatbot messages the bottom button appear.
• Each time the user click the button we have a user’s bubble with a new part of the scenario.

The idea is to identify recurrent processes allowing us to reuse components.

For this first part of the article we will look at the bubbles. From the user to the bot, how to simplify the development.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

Make a Bubbles Factory !

Users and bot are both use bubbles to display messages, but both bubbles are not the same. To simulate a discussion we need to find a way to make each message display independently with a delay. ChatBot bubble need animation before show message.

We need to take all this specification to build our factory.
For this part we create a bubble component, user-bubble, and the factory component, bubbles-factory. Finally we display them in a screen named Chat-bot.

User-bubble

It’s a simple component that displays the message we pass in its props (data) and some styling to match the design. I added an opening animation using the native react library, animated. I used animated’s parallel method to start an array of animations, opacity and x position.

const UserBubble = ({ data }) => {
const positionAnimated = useRef(new Animated.Value(10)).current
const opacityAnimated = useRef(new Animated.Value(0)).current

const Opening = Animated.parallel([
        Animated.timing(
            opacityAnimated,
            {
                toValue: 1,
                duration: 100,
                useNativeDriver: true
}
        ),
        Animated.timing(
            positionAnimated,
            {
                toValue: 0,
                duration: 200,
                useNativeDriver: true
}
        )
    ])

    useEffect(() => {
        Opening.start()
    }, [])

return (
        <Animated.View style={{ ...styles.bubble, opacity: opacityAnimated, transform: [{ translateX: positionAnimated }] }}>
            <Text style={styles.textBubble} >{data.text}</Text>
        </Animated.View>
    )
}

Bubbles-factory

Bubbles-factory is more complex. We have 2 very important props, data, bubble.

• Data is a simple array of objects. Each object represent a bubble, with a text object property.

{
  "chatBot": {
    "messages": [
      {
        "text": "test 1"
      },
      {
        "text": "test 2"
      },
      {
        "text": "test 3"
      }
    ]
  }
}

• Bubble props is the component to use to display the message. for now we use user-bubble only.
• Interval is just the delay we want to show the next message by default i have set this props to 1000 (1 second).

This is the code for the Bubble-Factory component :

const BubblesFactory = ({
    data,
    bubble,
    interval = 1000
}) => {
const [bubbles, setBubbles] = useState([])
const [index, setIndex] = useState(null)
const componentsLength = useMemo(() => { return data?.length }, [data])

    useEffect(() => {
let count = 0
const timer = setInterval(() => {
if (count === componentsLength) {
                stopBubbles()
                clearInterval(timer)
            } else {
                setIndex(count)
                count++
            }
        }, interval)
    }, [])

    useEffect(() => {
if (index !== null) {
            setBubbles([
                ...bubbles,
                data[index]
            ])
        }
    }, [index])

const stopBubbles = () => {
console.log('stopBubbles - end of sequence')
// Code here to dispatch next action
}

return (
        <Fragment>
            {bubbles.map((component, index) => {
return cloneElement(bubble, {
                    key: index,
                    data: component
                })
            })}
        </Fragment>
    )
}

First, we declare 2 stateful values, and a functions with the useState hook :

const [bubbles, setBubbles] = useState([])
const [index, setIndex] = useState(null)

• Bubbles is an array that we will use to display components as we go.
• Index is a number used to increment the data array props and to push the component is the bubble array.

At the initialisation of the factory, I create a SetInterval method which will allow me to increment the index variable. I set up a conditional logic to stop the SetInterval method according to the length of the data array.

useEffect(() => {
let count = 0
const timer = setInterval(() => {
if (count === componentsLength) {
                stopBubbles()
                clearInterval(timer)
            } else {
                setIndex(count)
                count++
            }
        }, interval)
    }, [])

As the useState is asynchronous, I use a second useEffect hook only when the index value changes to add the next data value.

useEffect(() => {
if (index !== null) {
        setBubbles([
            ...bubbles,
            data[index]
        ])
    }
}, [index])

I use a map function in the renderer, to display all the bubbles, and use a cloneElement method to return a new React element from the original element sent by props.

return (
    <Fragment>
        {bubbles.map((component, index) => {
return cloneElement(bubble, {
                key: index,
                data: component
            })
        })}
    </Fragment>
)

Make Bubbles !

You can find the all source code here.

With a bit of imagination you can modify and play with the factory and create your own effect. You can use different bubble styles, different components to use, even tried to use a decelerating interval ? Is that possible ? 😉

Next step

For the next part, i will show you how to add type animation for the chatbot bubble component.

Congratulations ! Thank you for reading this article, don’t hesitate to leave me comments on possible improvements, your opinions, your modifications, your tests.

Don’t forget to give us your 👏 !

---

React native onboarding chatbot : Part one was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

When you think to build quick chatbot with an open source framework system the first framework might pops will be Rasa. No doubt its a great framework, provide you to develop chatbot application with very easily with nice organization of documentation. After all the setup and training, the application seems to perform well. But when you go for the load testing of the application things starts to look messy : Response time increases, concurrency drops etc.

So based upon this, here in this blog I will be writing few things which I observed should be taken care off while setting up the configuration of Rasa.

1.Is there a way to solve concurrency issue?
Ans : One solution I came up with is by increasing the Sanic workers. Rasa 2.x use Sanic web server. As per my exposure I haven’t found any command line argument predefined by Rasa to change the workers. But you can the change the worker of Rasa and Rasa-sdk by making hard-coded changes of the Sanic Workers values in the Constant.py of both or writing a wrapper function to set the environment variable ACTION_WORKER_SANIC_SERVER = #Desired Worker.
Same to be done for Rasa.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

2. How to handle increasing response time?
Ans : There are various reasons which can be looked upon but I guess most ignored reason while doing any testing is consideration of sender id. The tracker of event is build based upon the sender id. As the list increases so do increase of response time.
One could think of using setting up a Session timeout variable but problem is, it only works in cases of inactivity for that sender id after a period of time which is set in config. So question arises is how to solve it.

I will answer this question in my next blog. Thank you for your time.
Please let me know if you have any suggestion and thought, or if I have misinterpreted.

Don’t forget to give us your 👏 !

---

Challenges faced with Rasa Chatbot Scaling was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

submitted by /u/SaturnRingMaker
[link] [comments]

Now that the digital and real worlds are merging, having an online presence is critical. Consistency is one of the most significant means for businesses to set themselves apart from their competition. Brands may establish themselves as thought leaders in their sector by producing high-quality, consistent content. The consistency of your material has a direct impact on people’s perceptions of your credibility. The more consistent you are, the more credible you are.

We have an incredible chance to harness automation to boost our productivity many times over in today’s digital and data-driven society. The audience will return for more if the content is compelling. They may offer their own user-generated content if it is really intriguing. However, if a company does not produce it on a regular basis or does not keep the same personality, it is more likely to lose its audience. It’s worthwhile, though, because keeping existing customers engaged can result in more revenue and is less expensive than acquiring new consumers. This emphasizes the significance of maintaining consistency in content, not just in frequency but also in tone. The usage statistics are eye-opening, and posting your material at the right moment can improve the accuracy and efficacy of your Twitter marketing efforts significantly.

High levels of user interaction can be extremely beneficial to your company, particularly in the following ways:

• Increased audience attention
• Increased audience attention
• A better emotional connection with customers
• More long-term recurring customers
• Brand advocacy from your strongest followers
• Shorter sales cycles

In this article, we’ll show you how to make a bot using Bot Libre, a free open source chatbot platform that lets you automate your Twitter engagement with your audience through your own Twitterbot.

Click 1 — Create a bot

First you need to create your own bot, this only takes a few clicks

Click 2 — Create a Twitter account

You need to create a Twitter account for your bot. If you are automating your own account, then you can use your existing account. You can create your own Twitter account from the Twitter website here.

Click 3 — Authorize your Twitter account

From the Bot Libre website browse to your bot and click the

Admin Console button. This will take you to the Admin section that provides several tabs of administrative functions. Click on the Twitter tab. From the Twitter tab click the Authorize button.

This will give you a link to Twitter. Click on the link, this will bring you to Twitter where you must accept the application authorization request, you will need to login to Twitter if you are not already logged in. Twitter will give you a code, you must go back to the Bot Libre page and enter the code, and click Done. This will return you to the Twitter properties page, next click on the Connect button.

Click 4 — Configure your Twitterbot

You can configure your bot’s Twitter usage in several ways. Use caution when configuring your Twitter bot, do not use your bot for spam, or to violate the Twitter terms of service.

Tweet when someone chats with the bot

This property configures if the bot should tweet when someone chats with it on Bot Libre. It will tweet some like “Talking with anonymous on #botlibre”.

Reply to mentions

A mention is when another Twitter user tweets to you, or about you using your Twitter ID, i.e. @brainchatbot. This configures your bot to reply to all tweets that mention it. The bot will reply the same way it replies to chat messages.

Reply to direct messages

A direct message is private message from another Twitter user. This configures your bot to reply to all direct messages. The bot will reply the same way it replies to chat messages.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

Read friends status updates

Configures if your bot will process its friends tweets. The bot will only process its friend’s tweets that include one of its ‘Reply Keywords’ sets. If the tweet does not include any of the keywords, it will be ignored. The bot will process the tweet like a chatroom message, it will only respond to the status update if it knows a good response, (requires a 90% match to respond). Scripted responses will also be used for tweets that are questions. The ‘Read-only’ option can be used to have the bot read all of its friends tweets, but not reply.

Max Status Updates

Configures the maximum number of friend tweets to process in one cycle.

Reply Keywords/Hashtags

The bot will only process its friend’s tweets that include one of its ‘Reply Keywords’ sets. If left blank, the bot will not process any of its friend’s tweets, unless the ‘Read-only’ option is used.

Tweet Search

Configures if the bot should search and process tweets that match a certain criteria. The bot will process, and possibly reply to the tweet, or retweet the tweet. Use this feature with extreme caution, and do not spam. Tweet search uses Twitter’s search API which can include a list of keywords, and some other advanced syntax.

Retweet Keywords/Hashtags

Configures if the bot should retweet certain tweets from its friends, or its tweet search results. If the tweet contains any of the keyword sets, the bot will retweet it. Note, this use only keyword set, not Twitter’s search syntax. Since the retweet keywords are apply on top of the search results, you only need to include the keywords, as the results have already been filtered.

Follow Messages

Follow Messages configures if your bot will listen to ‘follow me’, or ‘unfollow me’ requests. If the bot gets a direct message, or tweet mention that request a follow, or unfollow it will perform the request. The purpose of this is to allow the bot to provide some service to users that subscribe with it. Be careful in enabling this, it should not be used to allow Twitter users to increase their follow counts. The bot will only follow at most 100 users.

Welcome Message

You can set a welcome message to be sent as a direct message to anyone who follows your bot.

Max Friends

You can configure the maximum number of friends your bot will follow on its own. The maximum is 100 friends. You can still add more friends manually if you wish.

RSS Feed

Configures the bot to process an RSS feed, and post each new feed item to Twitter. An RSS feed is a standard XML format for news and posts. You can get an RSS feed link from your blog, or from many news and forum services. Make sure you give the full HTTP link to your RSS feed, this should be an XML file, not a webpage or HTML file.

RSS Keywords

You can filter the RSS feed results using keywords. To post the entire RSS feed, leave this blank.

Auto Tweet

You can configure your bot to tweet every set number of hours. The bot will tweet a random tweet from its ‘Auto Tweets’ list.

Auto Tweet Hours

The number of hours to wait between auto tweets. Note, if you bot only checks it status once per day, it will only auto tweet once per day, even if you put 1 hour here. To force your bot to auto tweet every time its checks its status, you can put -1 here.

Auto Tweets

You can enter a list of tweets here. Each tweet is separated by a new line. You can use formulas and AIML template to construct dynamic tweets.

Click 5 — Train your bot

You can train your bot how to answer tweets, mentions, and direct messages through several mechanisms.

• You can chat with your bot, and correct any incorrect responses it gives.
• You can add question answer pairs, or default responses from the Training & Chat Logs page in your bot’s Admin Console.
• You can review your bot’s chat logs, or upload or import chat logs, response list, or AIML.
• If you are a programmer, you can script your bot’s responses in Self, or AIML from your bot’s Scripts page.

That’s it, now your bot is ready to start tweeting.

A Twitter account can be linked to any Bot Libre bot. The bot will take care of your Twitter account, including checking status updates, maintaining followers, responding to mentions, retweeting key articles, tweeting your blog entries or RSS feed, and auto-tweeting. No programming is required, and you can train the bot using natural language.

Don’t forget to give us your 👏 !

---

Create your own Twitterbot to automate your Twitter presence. was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

What is a Bot?

Bots are automated software program that runs predesigned tasks over the Internet. They are automated which means they run according to the instructions they receive without a human user needing to manually start them every time. Bots imitate humans and replace human behavior.

More than half of all internet traffic can be credited to bots. For some e-commerce stores, bot traffic can be even higher than 90%. Bots scan content, interact with sites and social media accounts, or chat with users.

Bots are typically networked; bots account for more than half of Internet traffic, reading material, interacting with webpages, conversing with people, and searching for attack targets.

Some bots, such as search engine bots that index content for search or customer service bots that assist users are valuable.

Other bots are “evil,” and they’re programmed to hack into user accounts, search the web for contact information to send spam, or do other destructive things.

Types Of Bots –

• Chatbots: These bots are typically used to strengthen a company’s customer care department. A chatbot is an artificial intelligence (AI) software that can imitate a natural language discussion (or chat) with a user via messaging apps, websites, mobile apps, or the telephone. A chatbot is often described as one of the most advanced and promising forms of human-machine interaction.

• Social Bots: These bots are used on social media platforms for a range of tasks, including account creation and increasing the number of followers for specific accounts. For example, they’re designed to respond to certain words and phrases in social media posts automatically, either by reposting the messages or replying to them all at once. As a result, they can be used to influence public opinion and promote a particular point of view. On Twitter, such bots are widely used.
• Web Crawlers/ Spider Bots: The friendly spider bots crawl the web for indexing and retrieval of web material by following hyperlinks. They’re designed to run in the background and continuously fetch data from websites and APIs. The Google Bot is the best example of a spider bot, as it crawls the web to make content search simple and convenient.
• Spam Bots: A spambot is a computer application that sends spam emails in enormous quantities automatically. It gathers email addresses from a variety of online sources automatically. A spambot compiles mailing lists and sends junk mail, often known as spam, using the vast number of email addresses obtained.
• Transactional Bots: Transactional bots allow customers to complete a transaction while conversing.
• Monitoring Bots: This type of bot is used to monitor the health of a website or system. Downdetector.com is an example of an independent site that provides real-time status information, including outages, of websites and other kinds of services.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

Advantages Of Bot

• Bots help you in getting to know your customers: Conversational bots can help you learn even more about your customers. They assist you in determining their queries and requirements, as well as the items or services that they are interested in, and in making strategic decisions to improve the experience.
• Bots are a selling machine: Your bot could be the ideal partner for promoting new products and sending proactive alerts. They can also provide rapid support to your prospective customers, speeding up the decision-making process.
• Customer service at any time: One of the most significant advantages is that bots are available to assist customers 24/7. Additionally, they react to every question promptly. This ensures that no matter what time of day it is, your audience will always be able to solve their concerns.
• Improves client satisfaction: People are all diverse, and their communication styles are as well. As a result, it’s important to respond to each query with the proper and empathic response.

How businesses can use Bots?

People nowadays prefer messaging as compared to other forms of communication. The vast majority of individuals want to engage with a company via messaging. That’s when understanding how to create a business bot comes into use. Bots enable businesses to engage with customers automatically using chat applications, SMS, and text. Messenger bots have a high open-rate and are effective at converting clients without being annoying.

Using a marketing bot for your company will certainly result in a higher return on investment. Facebook Messenger is the most popular chat app used in the United States.

Determine a purpose for using Messenger bots in your business, such as increasing engagement, discovering leads, or generating sales. Then write personal bot copy that educates and entertains users throughout the user experience.

How do bots work?

Bots, in most cases, operate across a network. Bots that can speak with one another will do so through internet-based services such as instant messaging, Twitterbots interfaces, or Internet Relay Chat (IRC).

Bots are made up of algorithms that assist them in doing their tasks.

Examples and uses of bots:

• Facebook Messenger, WhatsApp, Slack, and Telegram are a few examples of Instant Messaging apps that use chatbots.
• Google Assistant and Siri are examples of chatbots.
• The World Health Organization created a WhatsApp bot to provide public information about the coronavirus outbreak.
• To promote their show Genius, National Geographic created a talking software that purportedly spoke like Albert Einstein.
• Users can use Facebook Messenger to search and share tunes on Spotify.

Consumers now expect firms to have some kind of automated channel so that they can talk to 24/7.

The modern consumer does not want to be put on hold or wait for a callback. Customers want to interact with your brand when they need it, not when you’re available or ready to reply. Adopting a bot-building strategy as a business today makes sense.

So what are you waiting for? You can Contact Us if you need any help! We’re always there to help you 🙂

Don’t forget to give us your 👏 !

---

Everything you need to know about Bots was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

The lessons we learned from our first foray into the world of chatbots

It is mid-2018. The air here at XIMNET is abuzz with a nervous excitement — we had just landed our first chatbot project.

‘Artificial intelligence — the future of tech!’

‘NLP — the next big thing in business automation!’

Up until now, these were just things we had watched grow from the sidelines, with equal amounts of skepticism and trepidation. Just words we’d throw around the office: “AI? Yeah, we’ll see.” But now we were going to have a stake in it.

But where do we begin?

Choosing a Platform

Even way back then, there were plenty of Natural Language Understanding (NLU) platforms to choose from, and no shortage of advocates for each provider.

Google’s Dialogflow seemed like an obvious choice: Creepily accurate answers to our sometimes nonsensical questions is basically their whole business model.

On the other hand, IBM’s Watson had already made big waves with their Jeopardy win, and was now poised to revolutionise healthcare (a promise still pending).

And what about Microsoft’s Azure Bot?

In retrospect, it really didn’t matter which one we chose — we ended up trying them all anyway as we ventured deeper and deeper into our chatbot journey, eventually going beyond the platforms to explore the underlying models for ourselves (Huggingface is a great resource for this).

Our takeaway: You can’t go wrong with either platform. Do a quick comparison and just get started.

Identifying the Problems

Despite what our optimistic selves would have us believe, chatbots are not magical, omniscient beings. By this point, everyone in the team had had their own horror stories about having to deal with an ineffective chatbot — creating a meaningful one was going to be a deliberate effort.

Having a long history of building solutions for the web, we knew we needed to prioritise.

Enter, the 80–20 rule. For the uninitiated, here’s a quick breakdown from Investopedia:

The 80–20 rule, also known as the Pareto Principle, is an aphorism which asserts that 80% of outcomes (or outputs) result from 20% of all causes (or inputs) for any given event. In business, a goal of the 80–20 rule is to identify inputs that are potentially the most productive and make them the priority.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

In chatbot terms, if we identify the right 20% of problems to address, we will be able to satisfy the needs of 80% of users. But how do we find those problems? Here are a few things we did to get the conversation going:

1. Profile the users: Who will be using the chatbot? Is it going to be on a public-facing channel, or will it be behind a log-in screen? Taking a user’s point of view serves as a good starting point into identifying what would be most helpful without the bias of being on the inside.
2. Speak to the stakeholders: When speaking to stakeholders, there are bound to be specific problems that they need addressed. Is there a painful but key business process, long overdue for automation? What are the repetitive tasks bogging them down from more productive work?
3. Get down to the sources: How are the users currently communicating with the brand? If there are any logs available (e-mail trails, Messenger chat histories, etc.) it will be good to get a look through as this will not only help in identifying problems, but also serve as a guide to building a feasible solution.

Once we had pinpointed the problems we wanted to address, it was time to get to work.

Establishing a Foundation

While we were designing our chatbot, it was very tempting to become mired in the world of utterances, intents, entities, dialogs and responses. And for a while, it felt like duty for us to educate and encourage more people to do the same.

But reality doesn’t quite work that way, and we found that it made discussions tedious and frustrating for everyone involved. If we were going to come up with something great, we had to start communicating effectively, and fast.

In the end, we boiled down the problems into a series of process flows: The idea being that each dialog could be essentially reduced to a flow chart. Sure, it does leave out quite a bit of the nitty-gritty (e.g. How does a user tell the chatbot to get recent transactions?), but it gives all stakeholders a chance to be involved even at the early stages of chatbot building.

Developing Human-First

Over the course of building our chatbot, it started to become painfully apparent that the old adage is really true: ‘No two humans are alike’. From slight variations in word choice to complete changes in sentence structure, when it comes to developing intents, you really need to catch ’em all. It pays to be thorough, and it is always a good idea to involve more than a few brains.

On the other hand, when it comes to responses we found it best to keep it short and sweet. While it is always tempting to provide all the information at one go in a chatbot message, often times all this does is overload the user, resulting in skimming and subsequent confusion. As a rule, it is much better to provide only information that is necessary, directing users to additional information when prompted.

And as always, when it comes to anything human — test, test, and test.

We launched our first chatbot — Affin Hwang AM’s NADIA in late November, 2018 to great results. Over the years we have built new chatbots and improved upon our overall solution: Teaching our chatbots new tricks every now and then, and in turn, learning some new tricks ourselves.

XIMNET is a digital solutions provider with two decades of track records specialising in web application development, AI Chatbot and system integration.

XIMNET is introducing a brand new way of building AI Chatbot with XYAN. Get in touch with us to find out more.

Don’t forget to give us your 👏 !

---

How we designed and developed an AI chatbot for the first time was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

Is it just us or are virtual assistants actually becoming quirkier and sassier by the day? If you remember your first interaction with a virtual assistant like Siri, Cortana, or Alexa, you would recollect bland responses and plain execution of tasks.

However, their responses are not the same they used to be. Over the years, they have grown to become sarcastic, witty, and in simple words — more human-like. It’s like they are just a step away from cracking the Turing Test. But this has been a journey, hasn’t it?

To get here, close to a decade of AI training has happened at the backend. Thousands of data scientists and AI experts have meticulously worked for hours together to source the right datasets to train their speech projects, annotate key aspects and make machines learn them intact. From tagging parts of speech to teaching machines quirkiness and funny responses, tons of complex tasks have happened in the development phases.

But what is the process actually? What does it take for experts to train and develop speech projects? If you’re working on a speech project, what are the factors you need to keep in mind?

Know-How Your Audience WIll Interact With Your Solution

One of the first steps in training speech modules is to understand how your audience will interact with them. Work on getting insights on what they would say to activate your speech module, use it through dictation, and listen to results. So, in this case, know the triggers, responses, and output mechanisms.

For this, you need to collect massive volumes of representational data that are accurately close to your source. From call transcriptions to chats and everything in between, use as many volumes of data as possible to zero in on these crucial aspects.

Domain-specific Interactions

Once you have a general understanding of how your audience will interact with your speech module, realize the specific language they would use that is in line with your domain of operation. For instance, if your speech project is for a mhealth application, your system needs to be familiar with healthcare jargon, processes, and diagnostic phrases to accurately do its job. If it’s a project for an eCommerce solution, the language and the terms used would be completely different. So, know the domain-specific language.

Develop A Script And Record It

By now, you have a compilation of phrases, sentences, and text of value with you. Now, you need to turn these into a solid script and record it from humans for your machine learning modules to understand and learn. In every piece of recording, you could ask recorders to specify their demographics, accent, and other useful information you could use as metadata during data annotation.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

Who Will Record Your Script?

How accurately your speech module responds to triggers depends on your recording data. Meaning, it should have data from your actual target audience. Using the same example of mhealth application, if it’s a specialized module for the elderly, you need to have data recorded from older people for your module to understand precisely.

Their accents, the way they talk, diction, pronunciation, modulation, and command are all different from people who are younger than them. That’s why we mentioned that your data should be as close to your source.

Collect As Many Datasets As Possible

Depending on your domain and market segment, collect as much data as possible. Compile call recordings, schedule real-time recordings from people, crowdsource, approach training data service providers and do more to get datasets.

Transcribe Your Recordings To Eliminate Errors

Your contributors are not trained professionals (mostly). When they talk, there are bound to be some mistakes such as the use of errs and umms. There could also be instances of repeating words or phrases because they couldn’t get them right the first time.

So, manually work on eliminating such errors and transcribe your recordings. If manual labor sounds too much like a task, use speech-to-text modules. Save them as documents with proper naming conventions that accurately define the type of recording.

Start The Training Process

You have a good source of speech data with you now. With the data you compiled in step 2 and with the actual recordings and transcriptions, you can trigger the training process for the development of your speech module. As you train, test your module for accuracy and efficiency and keep making iterations for optimization. Do not let go of errors because it takes another round of training. Fix all loopholes, gaps, and errors and make way for an airtight module in the end.

We understand that this could be quite overwhelming at first. Speech modules require complex efforts over a period of time to train conversational AI / virtual assistants. That’s why such projects are tedious as well. If you find this too technical and time-consuming, we recommend getting your datasets from quality training data vendors. They would source the most relevant and contextual data for your project on time that are machine-ready.

Social Media Description: Sourcing quality data for speech projects is tough. You need to know your audience, how they speak, how they access solutions, and more to develop an airtight solution. For those of you getting started with a speech project, here are effective steps on how you could approach data sourcing.

Description: Acquiring data for speech projects is simplified when you take a systematic approach. Read our exclusive post on data acquisition for speech projects and get clarity.

Author Bio Vatsal Ghiya is a serial entrepreneur with more than 20 years of experience in healthcare AI software and services. He is the CEO and co-founder of Shaip, which enables the on-demand scaling of our platform, processes, and people for companies with the most demanding machine learning and artificial intelligence initiatives.

Don’t forget to give us your 👏 !

---

An Extensive Guide To Data Collection For Speech Projects was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

submitted by /u/g64mat
[link] [comments]