My lovely little London Bus “app” (possibly the most basic web page you can imagine + connection to the Transport for London API) broke recently, and given the tube strike today I felt I the urge to fix it.
The error occurred when the web page called the proxy (to avoid Cross Origin Request errors there needs to be a server-side api proxy on the same domain as the html page) which calls the TFL API. The proxy is THE WORLD’S MOST BASIC PROXY
It’s just “File -> Add -> New Item -> Web Service (ASMX)”, with this single method:
public string getMeTheDataFrom(string here)
using (var response = new System.Net.WebClient())
Having a botframework chatbot up and running and responding to user messages is one thing, but how can you send a new message to bring the user back into the conversation if they haven’t just sent a new message for you to reply to?
The botframework documentation and other tutorials will point you towards using Azure Functions and the new
ActivityType.Trigger to handle this which, although being a great use case for Azure Functions, make the underlying implementation harder to understand. It also means you couldn’t easily implement this on AWS, for example.
In this article I’ll show you how to easily implement Proactive Botframework Messaging just using BotFramework fundamentals.
I’m extremely pleased to announce that I’ve just received the Microsoft Most Valuable Professional (MVP) Award!
Microsoft Most Valuable Professionals, or MVPs, are technology experts who passionately share their knowledge with the community.
They are always on the “bleeding edge” and have an unstoppable urge to get their hands on new, exciting technologies.
MVPs are driven by their passion, community spirit and their quest for knowledge. Above all and in addition to their amazing technical abilities, MVPs are always willing to help others – that’s what sets them apart.
During 2016 I discovered – and became quite obsessed with – the concept and development of chatbots; I’m am excited with the possibilities. Microsoft’s own product is the BotFramework and various Cognitive Services.
In the previous article we dissected an Alexa Skill down to the JSON request and Response, and pointed it to an HTTPS endpoint (your laptop) to get a basic end to end Skill working.
In this article I’ll show you how to link that skill into your botframework chatbot.
Creating a botframework reply
Let’s dip back into BotFramework in order to create something that can respond to the incoming request.
Calculating a Chinese Zodiac animal based on the year is really simple; just get the remainder from dividing by 12 and apply a
The rise of the conversational interface shows no signs of slowing down; chatbots are the new apps, Siri is getting old already, and although it’s still awkward to say “Ok Google” at your watch or “hey cortana” to your phone, somehow we’re happy to ask “Alexa” for the news, weather, or to play something by Bruno Mars.
The Amazon Echo looks like the first generation of a socially acceptable, almost natural, voice controlled conversational interface.
It’s that first step towards the Star Trek computer; you can’t quite say “Alexa, locate Commander Data” (although you can ask her to beam you up, and for earl grey tea, hot) but you can get a decent answer to “Alexa, where is my phone?” (assuming you’ve installed the relevant app).
All of the tutorials out there for developing your own Alexa Skill require a lot of digging around on Amazon Web Services, learning some nodejs*, and getting knee deep in lambdas (Amazon’s Functions as a Service/Server less architecture solution).
In this article I’ll show you how to easily understand how to develop your own Alexa Skill with just your laptop and a json file
* Actually, AWS Lambdas now support C# too…
We’ve already looked at how a botframework bot receives messages, and even how to save those messages.
In this article I’ll show you how to handle files that are sent to your botframework chatbot.
When a user interacts with your bot, unless they’re responding to a prompt, they will cause the
Post method to fire with an activity.
This will send a message through to your underlying
The method that receives the message will have the signature (though the parameter names and method name could be different):
In my previous article I showed how to override various methods within botframework such that you could run some logic to save your bot’s dialogues.
In this article I’ll give an example implementation of the
In the last article I introduced an
IMessageRepository concept in order to show how it would be possible to hook into botframework’s various
MessageReceived methods, and create our own version of
PostAsync to save outgoing messages also.
Saving both incoming and outgoing messages passed an
IMessageActivity object (“context”) to a
Now that you’ve deployed your well structured, exception handling, language understanding chatbot, how do you know just what people are saying to it?
Sure, you could copy and paste some logging code all over the place, but there must be a cleaner way.
In this article I’ll show you a few simple tricks to be able to save each message going to and from your botframework chatbot.
Let’s start off by saving messages going to any dialog that implements
In order to implement
IDialog<T> you only need to implement the
StartAsync method; however, this isn’t much use on its own, so let’s get the dialog into a conversation loop by adding in a
MessageReceivedAsync method and calling that from
StartAsync and from itself:
I had an awesome time presenting my session at the second LDNBotframework meetup!
This time I ordered the correct amount of pizza, and let people loose on it at the right time; so no fridge full of pizza for breakfast the next day!
From Zero to Echo via BotFramework
Having scheduled this session weeks ago, unfortunately my preferred presenters were not able to make it; as such I had just over a week to decide what to do about the already scheduled meetup: should I cancel it and lose momentum, or should I do a session myself?
In the last article I touched on how IoC is used within botframework using Autofac.
If you’re comfortable with IoC, you probably started to enhance your dialogs using constructor injection, so that you can put your conversation logic outside of your entry point and just start coding without needing an implementation to exist yet, e.g.,
public class ResolvingDialog : IDialog<object>
private readonly IMessageRepository _messageRepository;
public ResolvingDialog(IMessageRepository messageRepository)
_messageRepository = messageRepository;
public async Task StartAsync(IDialogContext context)
public async Task MessageReceivedAsync(IDialogContext context, IAwaitable<IMessageActivity> argument)
var message = await argument;
await context.PostAsync($"working now");