Kate Michel

Building a Cognitive Customer Service Bot

Kate Michel — Sun, 02 Oct 2016 09:12:44 GMT

If there is something being talked about with more passion and frequency than "customer 360" or "internet of things" it is certainly "bots." Bots are taking shape to play a significant role in our lives and have a vital role to play in customer service interactions. In the past, bots or virtual assistants were considered little more than a chat-based IVR system but more and more these A.I. entities are becoming smarter, more helpful and empowering us to do greater things. When it comes to customer service the bot conversation is simple: One bot can do the work of 1,000 agents at a fraction of the price taking less time to train. As customer expectations for response times, 24/7 availability and simplicity increase, bots are fast becoming an integral part of support teams around the world. This blog will illustrate some of the ways in which Microsoft Bots can be built to facilitate customer conversations like never before. Sample code provided in this blog is written to the Microsoft Bot Framework V3. I code my bots using Node.js, please see my colleague Geoff Innis' blog for related .NET content and samples.

Bots are like Onions

Just like an excellent Customer Service Representative, a Cognitive Service Bot is comprised of layers of intelligence. The foundation rests on the Microsoft Bot Framework, an extensible platform that allows you to easily build bots and connect them to several (10+) channels so that your bot is as responsive to customer needs and touch points as a real agent. The Bot Framework consists of a number of components including the Bot Builder SDK, Developer Portal and the Bot Directory. Features of the Bot Builder SDK include dialogs, prompts, built-in connection to Artificial Intelligence frameworks and the ability to run on nearly any bot platform. I choose to build my bots using the Bot Builder for Node.js. There is an excellent beginning tutorial to get started with a "Hello World" bot within the Bot Framework Documentation here. While a basic bot can be a lot of fun, Customer Service has unique challenges and a bot tasked with having a conversation with real customers needs to be more versatile and intelligent than your average bot.

Language Understanding Intelligent Service (LUIS)

This is where LUIS comes to the rescue. Part of the Microsoft Cognitive Services and natively built in to the Microsoft Bot Framework, LUIS allows your bot to interpret natural and conversational language to understand intentions and entities that relate to your organization. An entity in the context of natural language is something that exists as a subject or as an object. An intention is just what it sounds like, an inferred intention behind the communication given to or read by the bot. Let's walk through an example. Sometimes a customer may need help finding documentation or FAQs. When my bot understands a customer's intention is to get information, it runs a search into the Microsoft Dynamics Knowledgebase to retrieve relevant content. It uses the entity to ensure the search it is performing is relevant. First, I'll need to create a LUIS Model for my bot. I do so by signing in to Luis.ai and creating a new application for my bot. I will create a new Intent entitled "Search" and a new Entity titled "SearchTopic." Now, I need to train LUIS by entering phrases that I think my customers might say and tagging them appropriately. I then must tag the utterance with the appropriate intent (Search) to train my LUIS model how I would like it to interpret the intention. I can then highlight and tag the entity from the utterance. This tells LUIS what portion of this message should be treated as the SearchPhrase. I will enter several different examples into the LUIS interface (this can also be done via bulk upload) in order to effectively train the model. The more content and training you give your model the more effectively it will be able to interpret intentions and entities. Once the LUIS model has been appropriately trained, it should start making accurate assumptions about novel utterances as seen below: You can also test your queries live against the LUIS API after publishing your application. This allows you to retrieve the JSON response so that you can code your bot appropriately. The above yields the following JSON response

{
"query": "what is the claims process?",
"intents": [<
{
"intent": "Search",
"score": 0.973099649
}
],
"entities": [
{
"entity": "claims process",
"type": "SearchPhrase",
"startIndex": 12,
"endIndex": 25,
"score": 0.938603938
}
]
}

As you can see, this allows us to single out the search phrase so that we can work with the entity most effectively. I can then pass the entity "claims process" to the Dynamics Knowledgebase to return a result.

Search the Microsoft Dynamics Knowledgebase using LUIS

Now that we have our LUIS Model built out for our application, we need to make sure our bot is able to communicate with it.

//=========================================================
// Connect to LUIS Model for dialog
//=========================================================
var model = process.env.model || 'https://api.projectoxford.ai/luis/v1/application?id=XXX&subscription-key=XXX';
var recognizer = new builder.LuisRecognizer(model);
var intents = new builder.IntentDialog({ recognizers: [recognizer] });
bot.dialog('/', intents);

Now, for every intention we have registered in our LUIS Model, we need to tell the bot how we want it to behave. In this case, if our customer's message is interpreted by LUIS as a "Search" intention we want to identify the entity and query the Dynamics Knowledgebase. We can find the entity using the EntityRecognizer Class.

intents.matches('Search', [
function (session, args, next) {
var searchPhrase = builder.EntityRecognizer.findEntity(args.entities, 'SearchPhrase');
if (!searchPhrase) {
builder.Prompts.text(session, "What can I help you find?");
} else {
next({ response: searchPhrase.entity });
}
},function (session, results) {
if (results.response) {
// Do some data validation
session.send('I think I may have a Knowledgebase article that might help you...');
// Pass entity to callback function to fetch article information...
getArticle(results.response,function(kbLink, kbTitle, kbDesc){
// Format and send article details - renders differently in each channel!
var msg = new builder.Message(session)
.attachments([
new builder.HeroCard(session)
.title(kbTitle)
.subtitle(kbDesc)
.tap(builder.CardAction.openUrl(session, kbLink))
]);
session.send(msg);
session.endDialog();
} else {
session.send("Ok");
}
}
]);

In the code above, the entity SearchPhrase is stored as a variable which is then passed into our getArticle() callback function to retrieve the matching Knowledgebase article. It is important to remember to use callback functions whenever asynchronous requests are needed! Here is an example of a simple function that queries the Microsoft Dynamics Knowledgebase via the WebAPI. In this example, I am returning one KB article (title, id and description) where the title includes the entity phrase.

//=========================================================
// Fetch Dynamics CRM Knowledge Article 
//=========================================================
//Get KB Article by Title API Syntax: knowledgearticles?$select=title
//require 'CRMWebAPI'
function getArticle(phrase, fn){
var apiconfig = { APIUrl: 'https://kamichel01.crm.dynamics.com/api/data/v8.0/', AccessToken: myAccessToken };
var crmAPI = new CRMWebAPI(apiconfig);
var queryOptions = { Top:1 ,
FormattedValues:true,
Select:['title', 'description', 'articlepublicnumber'],
Filter:"contains(title,'"+phrase+"')",
OrderBy:['articlepublicnumber']};
crmAPI.GetList("knowledgearticles",queryOptions).then (
function (response){
var kbPortalLink = portalurl_kb + response["List"][0]['articlepublicnumber'] + "/en-us";
var formatedTitle = "[" + response["List"][0]['title'] + "]("+ kbPortalLink +")";
console.log(response["List"][0]['articlepublicnumber'] + formatedTitle);
fn(kbPortalLink, response["List"][0]['title'], response["List"][0]['description']);
},
function(error){console.log(error)});
}

Recognizing Images using Computer Vision

So far we have a bot who can recognize intention and entities from text but not all customer correspondence takes the form of language. In many cases, it may become necessary for a customer service bot to interpret images, videos and sound and respond appropriately. In the example above, the bot asked for a photo of a car. The customer provided a picture of a dog and the bot was not only able to recognize that there was no car in the photo but it was also able to give a dynamic and vivid description of what it did read in the image. Your bot can accomplish the above by leveraging Microsoft's Computer Vision APIs.

//=========================================================
// Interpret Picture
//=========================================================
Requires 'Unirest'
function getPicture(myPic, fn){
console.log(myPic);
unirest.post('https://api.projectoxford.ai/vision/v1/analyses?visualFeatures=Description&')
.headers({'Content-Type': 'application/json', 'Ocp-Apim-Subscription-Key': 'XXXX'})
.send({"visualFeatures":"Description","Url": myPic})
.end(function (response) {
var imageTags = JSON.stringify(response.body.description.tags);
//Returning if there is a car and a description of image 
fn(imageTags.includes("car"), response.body.description.captions[0]['text']);
});
}

Recognizing Customer Sentiment

A valid fear when implementing bots in the Customer Service Space is that they will become just another IVR system leading to the same types of frustrations customers report today. Imagine your customers typing "Representative!" furiously to your chat bot. Now, LUIS could certainly pick up on that intention and initiate a warm transfer to a live agent but it should never come to that. By reading customer sentiment throughout their interaction with your service bot will become emotionally intelligent and can decide when a live agent may be required to help an unhappy customer. Additionally, if there are points in your bot's dialog where customers are regularly logged with negative sentiment it allows you to adjust the bot scripts and/or your company's policy to improve CSAT and sentiment scores. Practical application to equipping your bot with sentiment awareness:

Log customer emotional reactions to your bot in easy to consume numerical data, excellent candid feedback
Allow the bot to respond with different language or tone (ie. more empathy) in response to customer sentiment
Escalate to a live agent when customer sentiment dips below a specified threshold
Identify and address bottlenecks or issues with existing bot dialogs

//=========================================================
// Check Sentiment
//=========================================================
// Requires 'Unirest'
function getSentiment(myText, fn){
unirest.post('https://westus.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment?')
.headers({'Content-Type': 'application/json', 'Ocp-Apim-Subscription-Key': 'XXXX'})
.send({ "documents": [{"language": "en", "id": "bot", "text": myText}]})
.end(function (response) {
var myScore = response.body['documents'][0]['score'];
fn(myScore);
});
}

Other Differentiating Capabilities

The Microsoft Bot Framework and supporting Cognitive Services provide the intelligence to empower a Customer Service Bot to hold meaningful conversations with your customers whether as a Tier 0 agent or as an end to end service provider. While there will be many more developments and blog posts here and elsewhere around Bots, here are some additional capabilities for further learning and to build on what was built for this post.

Customer Service Collaboration and Swarming

Kate Michel — Tue, 26 Jul 2016 08:31:33 GMT

Many Customer Service teams struggle to find the most effective way to use their top skilled and knowledgeable resources. Traditionally, Support teams have implemented a tiered approach for problem resolution, allowing a case to be routed and reassigned to individuals or queues with the appropriate level of expertise. Leveraging skills-based routing and escalation workflows, Microsoft Dynamics can facilitate the tiered model as well as any enterprise case management solution. Many organizations are looking to shake up the traditional tiered model and, instead, leverage a collaboration-based approach in order to increase CSR engagement, share knowledge and increase problem solving skills. This collaboration-based model is often known as "Swarming." The following post will explore the ways in which Swarming can be accomplished using Microsoft Dynamics and some of the benefits that Customer Service teams can glean from such a model.

Intelligent Swarming methodology has been defined by the Consortium for Service Innovation and we will be leveraging their definition to explore how to implement swarming to facilitate collaborative problem solving using Microsoft Dynamics.

Who is the best person to help?

Defining User Profiles and Skills

Microsoft Dynamics allows for user profiles to be defined with custom attributes that can be used to facilitate collaboration and to help identify the best resources to solve challenging problems. Information to build into a robust user profile includes:

Language(s) spoken
Channel preference (email, phone, chat)
Competencies and Skills
Product Specialization or Certification

Fields and attributes can be easily configured in Microsoft Dynamics by an administrative or business user without the need to deploy code or IT resources!

Defining Teams

Microsoft Dynamics supports the concept of teams which allow users from different business units in an organization to collaborate on an issue or record. Users can belong to multiple teams and membership to a team can give a user additional rights and permissions, providing necessary visibility and accountability on relevant issues. For example, a user who has the right to read and update cases they own can also read and update relevant cases for collaboration when associated to a team that user belongs to. Microsoft Dynamics differentiates between owning teams and access teams. Owning teams allow a record such as a case to be assigned and owned by a group of users as opposed to an individual. This can be especially beneficial for reporting purposes and allows for a CSR to reassign an issue to a team for resolution. While this can be an effective escalation path, swarming is most impactful when ownership and responsibility for a case or issue does not transfer hands. This is where access teams come in. Access teams in Microsoft Dynamics are temporary, created and dissolved as needed. This allows for users to swarm a problem, collaborate and then disband once the swarm has completed. Since different types of issues may require teams comprised of different skills and resources, access teams allow for the most relevant users to be tagged to help for specific problems. As the image above shows, an access team allows different users from different business units and roles to be temporarily linked together in order to collaborate and solve a problem. The access team can be disbanded once a resolution has been reached. Access teams can be created manually by users who need assistance as well as leveraging team templates to auto-create access teams with necessary permissions when appropriate.

Capturing Reputation and Metrics

User profiles support Subgrids and Charts to show historical collaboration data and reputation information in an easily readable graphical format. As with all fields on a Microsoft Dynamics form, user permissions can be defined for visibility and read/write access to these data points as appropriate.

Requesting Help

One of the most important aspects of Swarming is making it simple and seamless to request help. The user who needs assistance should be able to very quickly ask a question or raise their hand to engage a Swarm.

Asking Questions of Teams

Sometimes, a CSR working on an issue encounters a question or problem they want Swarmed. Using Microsoft Dynamics Activities directly within the case form, a question can be posed to a Swarm Team and assigned with defined priority, resolution date and other configurable information.

Once the activity has been created, the team and/or user(s) are notified of the request for help and any actions taken against the activity and case are logged. If an organization leverages Microsoft Yammer, questions can be posed and shared directly within the case form as well and different groups, teams and people can be tagged to assist.

Assign to Teams

As described above, Microsoft Dynamics allows for the creation of Owning Teams to which cases and problematic records can be assigned. This transfers ownership of the record to a team to swarm and resolve. Security Roles for users on the Owning Team are applied as though they are the owner of the case or record . Once the problem has been addressed, the team can reassign the case back to the original owner or return the case to a queue. When an organization does not want to transfer ownership of the case to a team, an Access Team can be defined to share the record with a team to swarm and resolve. As we saw before, Access Team Templates can be defined for specific entities. A CSR can use views to search for users with particular skillsets or characteristics to add to an Access Team in order to Swarm. You can also leverage workflow in Microsoft Dynamics to assemble Access Teams automatically when the CSR who owns the case needs help. For example, a CSR changes the status of the case to "Hand Raised" to indicate that the case needs Swarming assistance as seen in the screen shot above. The status change can trigger a workflow that shares case access to individuals or teams which meet specific criteria. Then, when the status of the case changes, and the CSR's hand is no longer raised, the sharing can be removed and Access Team automatically dissolved.

// Grant a team read/write access to a case. var caseReference = new EntityReference(Incident.EntityLogicalName, _incidentId); var teamReference = new EntityReference(Team.EntityLogicalName, _teamId); var grantAccessRequest = new GrantAccessRequest{
PrincipalAccess = new PrincipalAccess{

AccessMask = AccessRights.ReadAccess | AccessRights.WriteAccess, Principal = teamReference

},

Target = caseReference
}; _serviceProxy.Execute(grantAccessRequest);

Offering Help

List Views and Dashboards can be configured to help Subject Matter Experts and Resources identify areas where they can be of assistance. Users who can proactively offer help and collaboration assistance should be assigned SME Resource security roles that allow them to monitor cases owned by other users. Some ideas of criteria to define for list views and dashboards include:

Cases related to SME product that have been open for more than X hours/days
Cases close to violating resolution SLA
Cases in the "hand raised" status

Microsoft Office Groups within Microsoft Dynamics

Customers with a Microsoft Office 365 Subscription are able to leverage the power of Office 365 Groups directly within Microsoft Dynamics. Office 365 Groups are a shared workspace for email, conversations, files, and events where group members can Swarm to collaborate. You can use groups to Swarm with people across your company, even if they don’t have access to Microsoft Dynamics. For example, you can create a group for a software defect Swarm and invite other Office 365 users to join the group, and then share documents, conversations, meeting notes, and OneNote information related to that specific issue, defect or product.

Bringing Gamification to Customer Service

Kate Michel — Fri, 10 Jun 2016 22:49:19 GMT

Solutions like Microsoft's FantasySalesTeam are driving measurable results, positive behavior change, enthusiasm and teamwork to sales teams and companies around the world. Leveraging both individual and team based games, FantasySalesTeam helps keep reps motivated, challenged and engaged. This impactful gamification should not be limited to sales teams and in this post we will be discussing how customer service organizations can leverage these tools for real impact. We'll be discussing some best practices and development ideas around gamification in the call center and customer service space in two main areas:

Gamification Service Metrics
Unified Service Desk Integration

Gamification Service Metrics

The most critical component of a gamification strategy is deciding what metrics to use when awarding points. In sales, we commonly leverage metrics like booked revenue, number of outbound phone calls or emails, opportunities created, and leads converted. In service, our game board and points look a bit different. One of the most important things to keep in mind is the behavior these metrics are designed to drive. Gamification isn't about tracking rep behavior as much as it is about changing it. What are the behaviors you want to drive for your customer service team?

Behavior: When agents encounter an issue that isn't documented, they should suggest a Knowledgebase article be created.
Gamification Metric: Articles Created. Number of Articles Created, leveraging the Created By value to credit CSRs

Behavior: Improve CSR Knowledgebase submission quality by rewarding suggested articles that inevitably get published. Quality over quantity.
Gamification Metric: Articles Published which were originally created by this CSR.

Behavior: Drive thoughtful submissions which likely take more time and effort by awarding bonus points for articles with high adoption or feedback scores.
Gamification Metric: Knowledge Article Views or Feedback originally created by this CSR.

Behavior: Increase case resolution rates.
Gamification Metric: Number of cases resolved by the CSR.

Behavior: Responding to customers in a timely manner
Gamification Metric: Responding to (or resolving) a case within the specified Service Level Agreement time

Behavior: Increase resolution of complex, time consuming or unpopular types of issues, eliminate cherry picking.
Gamification Metric: Number of cases resolved by the CSR that meet custom parameters.
Note the use of a "Saved View" in this example. You can create a view related to Cases that defines special criteria to be considered for this metric. This allows you to specify the cases which are generally difficult, time consuming or picked over. For example, cases related to returns, to complaints or to complicated product defects.

Behavior: Drive upsell/crossell opportunities from the call center
Gamification Metric: Number of leads or orders created by service CSRs. You can use views to make this more specific and only capture the orders or leads related to specific call center upsell campaigns.

Behavior: Drive customer satisfaction KPIs
Gamification Metric: Positive interaction survey responses related to the CSR
Note: If using a solution like Voice of the Customer, you will need to enable Change Tracking on the entity you want to include as a metric.

What to avoid with gamification in the call center?

Some gameification models can promote bad habits in your CSRs. The metrics we've discussed so far are geared towards driving positive behavior but some metrics may need to be avoided or adjusted with concepts like floors, ceilings and weighting points. For example, if the only metric you are scoring is how many phone calls a rep answers in a day you may unintentionally be promoting bad habits where your reps hurry to get a customer off the phone. It's important to balance these volume metrics by giving more weight to activities like CSAT performance or by leveraging point ceilings based on the typical amount of calls your CSRs receive in a day. That way, they get points for completing a high number of calls, but not to excess. Floors allow you to specify a bottom limit before points begin to be awarded. For example, the first 10 calls a CSR handles don't receive any points but they will start to receive game credit on their 11th handled call. Ceilings are upward limits that keep the CSRs acting within appropriate ranges. In this example, the CSR will only earn points in the game until they have finished their 100th call. Any excessive calls beyond that will not count towards their game participation. You can also weight points so that calls handled for complex issues (which may be more time consuming) receive a higher number of game points than a call that is a simple issue. This helps prevent cherry picking, especially in the case of chats, cases and emails.

FantasySalesTeam and Microsoft's Unified Service Desk

Once you have established the teams, metrics and prizes for your customer service team's game you need to make sure that your CSRs remain engaged as the game progresses. Keeping the games top of mind includes visual leader boards, automatically sharing accomplishments and a live stream of progress made by your reps. For customer service and call center reps working in Microsoft's Unified Service Desk, there are a number of ways to keep them engaged with FantasySalesTeam and encourage participation. It is important to note that FantasySalesTeam reads data directly from your Dynamics CRM system and does not require Unified Service Desk to operate! This integration allows you to keep your CSRs engaged, showing their game play and progress directly within their workstations.

Display FST TV within USD

Why? Keep your CSRs engaged in the game and motivated by their team's progression and competition. Keeping the games and score board relevant and top of mind to your reps will help build enthusiasm and participation.
How? Create a Standard Web Application Hosted Control and assign it (in this example) to the RightPanel. Then, trigger an event that navigates to your FST TV URL from the Unified Service Desk Toolbar or at USD load using the System Event DesktopReady.

Automatically Post Smack Talk and BAM! Alerts

Why? By automatically sharing individual contributions and successes with the broader game you encourage participation, recognize performance and drive excitement and appreciation for reps who do great work. While the Smack Talk and BAM! posts can be manually triggered, some actions taken warrant immediate acknowledgement and praise! Additionally, this saves time for the game administrators who would otherwise manually trigger BAM! notifications.
How? While APIs are being developed for FantasySalesTeam to streamline this process in the future, we can still trigger events through the FST interface. We'll do this by leveraging a Hidden Panel Hosted Control and RunScript type action calls triggered by events that take place in the Unified Service Desk.

Create Hosted Control in a Hidden Panel. This Hosted Control is going to load the Smack Talk board and take action behind the scenes. An agent won't be aware of it's existence and the functionality will trigger and execute appropriately within the hidden panel. We can use this Hidden Panel to perform many behind the scenes functions including Single Sign On but in this example we will be focusing on taking action on the Smack Talk board, posting comments about events that have taken place by the agent. Create Action Calls to load the Smack Talk Board The first thing that we need to do is load the Smack Talk Board into our Hidden Panel Hosted Control. We do that by creating an action call that Navigates to the appropriate URL. The most important thing about this action call is when to load it. Since this is an action that takes place "behind the scenes" we need it to be ready to go whenever a CSR performs a share-worthy event. To that end, we should add this Action Call to the System Event DesktopReady so that it is run and the appropriate pages are loaded when USD starts. Create Script to Process Outbound Messages Next, we'll need to post our messages to the SmackTalk board. We will be doing this using RunScript actions against the FST Hidden Hosted Control we created above. This is a code snippet we will need to execute multiple times and from different areas of our solution so best practice would be to create an Option that allows us to reuse the same code whenever applicable. This is especially important when working with RunScript actions that may need to change as APIs are developed or the User Interface you are manipulating changes. This Javasript Code is identifying the Comment Box element on the Smack Board page and inserting a custom variable, 'usdtext.' It is then essentially clicking the "Post" button to submit the custom message to the Smack Talk board. This will post a message as the authenticated user, allowing the Unified Service Desk to share successes or milestones with the game on their behalf. We can now call this code snippet by using the Replacement Parameter [[$Global.FSTPostSmack]] in our application. Create an Action Call to Trigger Outbound Messages Now that we have established the code to process our messages, we can create action calls to trigger the actual posting of messages. While you can make dynamic action calls, it may be simpler to create one Action Call for each type of message you want to send. That way, you can activate and deactivate the specific Action Calls depending on the games you have running at any given time. As you can see, we are defining the Javascript variable "usdtext" with the message we'd like to post to the Smack Talk Board. We are then including the code snippet stored in our FSTPostSmack option defined above. I am also using some additional Replacement Parameters to make this message Dynamic. For example, [[$User.fullname]] is going to use the CSR's name and [[account.name]] will reference the Account Name of the Customer they are working with in that particular session. When this Action Call runs, it will produce the following Smack Talk Post: Now, you can add this Action Call to Events or other Action Calls as appropriate. For example, triggered when a CSR creates an Order within USD from a Service Call.

Extending the Unified Service Desk: Co-Browse

Kate Michel — Fri, 27 May 2016 22:31:32 GMT

One of the most powerful and differentiating aspects of Microsoft Dynamic's Unified Service Desk is the ability to interact with Third Party tool-sets and applications that empower your agents to serve customers across diverse channels and interaction points. In this post, we will be exploring how you can apply the concepts of Hosted Controls, Action Calls, Window Navigation Rules, Replacement Parameters and Events to integrate a Co-Browse solution into a USD Environment.

We will be working with a Co-Browse technology called Realtime, developed by Recursive Labs. Realtime allows for a secure, no-download co-browsing experience as well as Open APIs for simple development. Please contact Recursive Labs to schedule a demonstration if you are interested in this technology.

Before we get started, I'd like to share a brief video demonstration of this example integration in action. As you can see, I am able to initiate a Co-Browse session directly from the Unified Service Desk. I have also integrated a Chat solution and can post messages directly into the chat interface related to Co-Browsing. The Co-Browse session itself will launch in the central panel for easy viewing and my chat deployment will move to the right, enabling me to continue to chat with the user while engaged in screen sharing. [video width="800" height="600" mp4="https://msdnshared.blob.core.windows.net/media/2016/05/cobrowse2.mp4"][/video]

This tutorial is meant to illustrate a real world example of building an integration within the Unified Service Desk by applying the learnings and concepts discussed in this blog. These concepts are applicable to a wide variety of scenarios, allowing you to extend the Unified Service Desk with a number of different solutions. My hope is to share the concepts and best practices involved in customizing USD so that you can create your own integrations.

Prerequisites

- Microsoft Dynamics CRM 2013+

- Unified Service Desk Installed

- Administrative User Rights

- Co-Browse Solution (we'll be using Realtime)

Step 1: Understand the Requirements

It sounds simple enough but when building anything in the Unified Service Desk it is important to have a clear objective and plan of what you want to build and how you want it to interface with the rest of the Microsoft Dynamics and USD. Brain storm with stakeholders, leveraging user stories to map out your high level requirements and help to guide the development process.

Here some example user stories for Co-Browse integration we will be building in this blog.

As a customer, I want to share my screen with a customer service agent in order to get help with a process.
As an agent, I want to generate new Co-Browse Sessions to engage with customers
As an agent, I want the option to start a Co-Browse from any session.
As a supervisor, I want co-browse sessions to be logged as activities and tied to the relevant contact, customer or case.

Step 2: Assemble and Understand Third Party Resources

In this post I will be working with a web based Co-Browse solution. This solution has two interfaces that I need to work with: the Initiation Widget which generates the unique session to support a Co-Browse between agent and customer and the screen sharing Application itself.

The Initiation Widget will be a Web Resource hosted within CRM that allows a CSR to initiate the application. The Application itself is our web-based Co-Browse Solution.

Step 3: Create Hosted Controls

A Hosted Control within the Unified Service Desk can be thought of as the "building blocks" of your application. For our purposes, you can think a Hosted Controls as where you can host .NET components, Dynamics CRM pages as well as Web Applications. You can also think of Hosted Controls as Objects. We will discuss Hosted Controls in more detail in another post.

As we discussed in Step 2, there are two application interfaces we need to add to support our Co-Browse experience: the Initiation Widget and the Co-Browse Application. We need to create a Hosted Control for each.

To create our Hosted Controls we will log in to Dynamics CRM, navigate to Settings and select the Unified Service Desk menu item.
From the Unified Service Desk Administration area, select the Hosted Controls item.
In the Hosted Control entity ribbon, click New to create a new Hosted Control.
Create a Hosted Control for the Initiation Widget.
Give your Hosted Control a name. Best practice is to name your custom USD Components in a similar fashion. For example, I might prepend the word "Co-Browse" or "CB" to elements that relate to the Co-Browse application I am building. This will allow you to find the elements easily for configuration, troubleshooting or even updates in the future as well as make your components easier for future developers to work with.
The display name is what will be shown to CSRs within the USD application. If no display name is selected, the name of the Hosted Control will be shown instead.
The USD Component Type allows us to specify what this Hosted Control will be used for. In this example we selected a Standard Web Application which allows us to load a non-CRM webpage. By default, USD will use the Windows Presentation Foundation (WPF) WebBrowser to load the page but based on your need you can use IE Process as well.
We need to make sure the Application is Global box remains unchecked as we want this Hosted Control to only exist within the context of a customer session. Checking the box means that your Hosted Control will exist irrespective of any one session.
Finally, we will selecte the Display Group "LeftPanelFill" which will add our Hosted Control beneath the Agent Script Panel in the standard USD Layout.
Save your Hosted Control and click the New button to create another for the Co-Browse Application.
As before, we are creating a Standard Web Application Hosted Control, adhering to our naming conventions and specifiying that it is session context specific, not global. This will be the Hosted Control where our Co-Browse Application lives. To give the agent the best view of their customer's screen, we will specify the MainPanel Display Group which will put our Hosted Control in the center of USD.

Step 4: Action Call to Instantiate The Applications

Now that we have created the object references for our Co-Browse Initiation Widget and Application, we need to instantiate them. Basically, we need to tell USD what to load. We do this using Action Calls. Action Calls can be thought of as function calls, triggering UII Actions within the Unified Service Desk. We will use these Action Calls to load our Web Applications as well as to communicate with other Hosted Controls within USD, as we will see in the next steps.

We now want to load our Initiation Widget which will point to a Web Resource that contains the logic to generate the Co-Browse session. The creation of the Web Resource is outside the scope of this post as it will vary depending on the type of solution you are integrating with. If you are deploying the Realtime Co-Browse solution, your Web Resource will be available to you in the installed Solution File.

Return to the Unified Service Desk Administration area (Settings -> Unified Service Desk). You can also use CRM Breadcrumbs to go back to this page from within a USD component.
Click on the Action Calls item.
As before, click the New button to create a new Action Call. The first action call we will create will be to load our Web Resource for the InitiatIon Widget.
We will give our Action Call a name that is logical and describes the function of the action to take place. We will also continue our naming conventions so that it is easy to identify which Action Calls relate to our Co-Browse integration.
We then need to select a Hosted Control that the defined Action will apply to when the Action Call is invoked. Since we are loading our Initiation Widget, we want to leverage the Co-Browse Initiation Widget Hosted Control that we defined in the Step 3.
The Action defines what type of action will be performed when the Action Call is invoked. Different Actions will be available depending on the type of Hosted Control you have selected. In this case, we want to load a web resource into a Standard Web Application Hosted Control and so we can use the available Navigate UII Action.
Finally, we need to provide some Data for the Action to use. Data is accepted as name value pairs. You can input multiple data parameters, separated by line breaks. In this case, we just need to provide a URL where the Hosted Control should be Navigated to. The URL provided will then be loaded using the Hosting Type browser defined in the Co-Browse Initiation Widget Hosted Control.
Save your Action Call.

But wait, why didn't we create an Action Call to load the Co-Browse Application as well? In this example, the Co-Browse Initiation Widget launches the Application when an agent engages in a session with a customer. We cannot manually navigate to the Application as it is session-based but we do need to help route the launch into the right place, which we will do in Step 5 below. Let's Test Our Action Call In another blog post, we talk about using the Unified Service Desk Debugger tool to test and troubleshoot Action Calls. This is a great way to do unit testing and validate that the custom code or integrations you are building works as expected in the USD environment.

Launch Unified Service Desk and log in to Microsoft Dynamics
In the top-right corner of the application, select the Debugger toolbar button to launch the Debugger control which will load in the center area of USD known as the MainPanel.
At the top-left of the Debugger (in blue) you can expand and collapse the Direct Action area. This allows you to run action calls manually from within the Unified Service Desk. From the list available (in orange) we will select our newly created Co-Browse Navigate To Initiation Widget. In green, you can see we have the ability to run (green arrow) or edit (yellow pencil) this action call. This allows us to test and make modifications to our Action Call without having to save those changes or reload USD.
Now, because this is not a Global Hosted Control, it will only open and exist within the context of a session. So before we can run our test, we have to start a session. To do this, I will open a random contact in USD.
When I run my Action Call I will see that the Web Resource loads in the LeftPanelFill pane, right under the Agent Scripting area.
We have now confirmed our Action Call loads the appropriate Hosted Control and that it Navigates to the specified Web Resource that we defined in the Data.

Step 5: Launch Co-Browse Application Our Web Resource for Initiating a Co-Browse triggers the launch of the Realtime application. If we loaded this page in a Web Browser it would launch in a new window. USD, however, does not handle pop-ups, new windows or tabs in the same way a browser might. So if we want to launch the application with tall the appropriate session information that was created by our Initiation Widget, we need to tell USD how to behave. Window Navigation Rules are a key component to working across applications and panels within USD. When you click a link within a Hosted Control, you need to define the behavior you want. For example, if I click a link to open a Contact record within a Dynamics CRM Page Hosted Control, USD will not only load the Contact's profile but will also start a Session. The logic that handles this behavior is called a Window Navigation Rule.

Navigate back to the Unified Service Desk Administration Area (Settings->Unified Service Desk)
Click on the Window Navigation Rules item
Click the New button to create a new Window Navigation Rule. The first WNR that we will create will be a Default Rule
As before, use your established naming conventions when selecting the Name for your Window Navigation Rule. It should be descriptive of what the rule is meant to do. In this case, we want to launch the Co-Browse Application from the Initiation Widget.
As with other entities within USD, specifying an order ensures that, when multiple rules are being run, they are executed in the correct order.
Now, let's talk about the Route Logic that defines when this rule is called. We have a number of different WNR being used within USD and we only want to apply this rule in a specific situation. The Rule Logic, in conjunction with the Order field, lets USD know when this rule is applicable.
The From field specifies which Hosted Control this WNR can be initiated from. Since we specified the Co-Browse Initiation Widget Hosted Control as the From field, only that Hosted Control can trigger this specific rule.
Now, we have to specify a CRM Entity or URL. This allows us to be more specific about when the rule should run and what kind of information will be displayed when it does. Since we are routing a Web Application, we can enter a partial URL of that application (example.com) or a wildcard character (*) to allow all URLs from the originating Hosted Control.
Now that we've defined when this rule should run, we can tell USD how to behave. In this case, we want to route the new window into the Co-Browse Application Hosted Control. To do that, we specify the Route Type as a Popup, the destination as a USD Tab and the Action as Route Window. If we chose the Action of "In Place" the Application would load within the Initiating Widget Hosted Control.
Finally, we want to specify which Hosted Control we want to Target for our Route Window Action. Since we want the Application to load in the Co-Browse Application Hosted Control, that is what we will selected here. We can also specify if a particular Hosted Control should get "focus" or shown within USD when this rule runs. We want to automatically see our Co-Browse session, so we will select the Application Hosted Control to be shown when this rule runs.

Pretty simple, right? Again, the logic to open the Application in another browser window exists in the Initiation Widget Web Resource. With our WNR, we are telling USD how to behave when the Popup or new window request is initiated that matches our Route Logic. Let's Test Our Window Navigation Rule As before, we can test our changes within the Unified Service Desk Debugger.

We first will launch the Unified Service Desk, log in to our Dynamics CRM instance and open the Debugger.
Remember that our integration can only work within the context of a session so we will need to start a session before we can test.
Just like before, we will run the Co-Browse Navigate to Initiation Widget Action Call from the Debugger. As before, this will load the Hosted Control that contains our Initiate Co-Browse Web Resource.
Once the Initiation Widget Hosted Control loads, I will try to start the Co-Browse Application by generating a link and clicking the "Join Session" button. This functionality, again, is defined by the Web Resource we have loaded within this Hosted Control.
When we click "Join Session" the Web Resource will try to load a new browser window or Tab. This will be picked up by our Window Navigation Rule, since it is originating from our specified Hosted Control, and the Co-Browse Application Web Resource will be routed to the Co-Browse Application Hosted Control.

Looks good! We can now initiate a new Co-Browsing session and start the Application directly from within USD.

Step 6: Record Co-Browse Activity within CRM

Now that we have the ability to initiate a Co-Browse session from within USD, let's address the next user story. As an agent, I want all my Co-Browsing sessions to be saved as Activities within CRM.

First, you'll need to create an Activity Entity for your Co-Browse sessions. Entity creation is outside the scope of this blog post but is hopefully something you are familiar with. If you have Realtime by Recursive Solution files installed in your Dynamics CRM Instance, you will already have the necessary entity and fields created.

Make note of your Entity Name and any relevant Field Names as you will need these to create records from within USD.

Alright, now lets get on with the process of creating entity records from within USD. Earlier in this post we covered Action Calls which act as functions within the Unified Service Desk. We will be using Action Calls to create entity records within Dynamics CRM.

Navigate back to the USD Administration Screen (Settings -> Unified Service Desk) and select the Action Calls item.
Select the New button to create a new Action Call. This action call will create an entity record for our Co-Browse Activity and save that activity to the contact record.
As before, we will follow our naming conventions and make sure that the name of our Action Call is descriptive.
The Hosted Control we are invoking with this Action Call is going to be CRM Global Manager. This special Hosted Control is the brain behind USD and does everything from loading and interpreting data to providing multi-lingual capabilities. The CRMGlobalManager Hosted Control also has special UII Actions that can be used by your USD Customizations. In this example, we will use the special UII Action of CreateEntity.
The Data field, just like before, specifies what information we want to use when invoking the Action. Previously in this example we passed a URL value. Now, we are defining what kind of entity we want to create and what data we want to pre-populate it with. Just as before, the Data consists of name=value pairs seperated by a line break.
The LogicalName correlates to the "Name" field of the CRM Entity. If you aren't sure what to use here, look at the entity record to find the system name.
The regardingobjectid allows you to associated this Activity with a particular record. In this example, we are saving the activity to the contact record associated with our current Session in USD. We can use the CRM Implicit Method EntityReference() to specify the type of entity (contact) and the entity's ID.
The rest of the data included are name/value pairs that align with specific fields on the Co-Browse Activity Entity. We are using just a few basic fields as an example here including the text string "subject" and the DateTime() field that specifies when the Co-Browse Activity Started.
You can retrieve data from USD using Replacement Paramters. Replacement Parameters are basically variables that can be invoked using [[VariableName.Value]] syntax. System parameters will start with a leading $ as in [[$User.fullname]] which references the CSR's name. You can also use keys between the last two brackets for special handling of Replacement Parameters. This is a topic we will dig deeper into in a later post.
Now, we can Save our Action Call and test it once again in Unified Service Desk.

Step 7: Tie it All Together

At this stage we have a custom integration build that allows us to view a widget, launch and route our application and create an activity entity. While these are all the components of a complete solution, we still need to tie it all together so that our agents can take advantage of the integration.

So far we have been invoking our Action Calls manually using the Debugger in Unified Service Desk. It's now time to make these actions available to our agents.

First, we'll want to launch the Co-Browse Initiation Widget every time a Session starts.

We've already created our action call to load our Initiation Widget, now we just need to tell USD when to invoke it. Going back to the Unified Service Desk Administration page, lets select the Events item.
Events are notifications that something has occurred within USD. You can tie Action Calls to Events to trigger behavior in USD.
Locate the Event called "Session New." This is a default Event in USD that indicates a new session has been started. Any Action Calls associated to this event will be invoked when the Event runs. Now, you can see where the Order value on Action Calls comes into play. The Action Calls are evaluated in the order indicated by the Order field.
Now, let's add our Co-Browse Navigate to Initiation Widget Action Call to the Session New Event.
Remember how I said to name things in a predictable way? This is where that comes in handy. I can search for the beginning part of my naming convention and see all Action Calls related to Co-Browse. I can then select the correct Action Call and easily add it directly to the Event.
Now, when a new Session starts in USD, my Initiation Widget will load in area specified by the Hosted Control. We can test this, again, by launching USD and starting a session.

Now, we'll want to automatically create a Co-Browse Session Activity Record when the Co-Browse Application launches. We will do this using Events that are tied to specific Hosted Controls.

Recall that the Co-Browse Initiation Widget is what routes the Popup via Window Navigation Rules to the Co-Browse Application Hosted Control. As such, we will be using the Initiation Widget Hosted Control Events to trigger the creation of our activity when a Popup is routed.
Open the Co-Browse Initiation Widget Hosted Control (Settings->Unified Service Desk->Hosted Controls). Like many other components of Dynamics CRM, Hosted Controls have associated information including their own Events.
In your Dynamics Menu, select the carrot next to your Hosted Control's name. This will expand the additional details about your Hosted Control. In this example, we will be working with Events and will select that menu item.
Two default Events will already exist for a Hosted Control: BrowserDocumentComplete (fires when the Hosted Control completes loading) and PopupRouted which is, of course, the Event we will be using here.
Opening the PopupRouted event we can see that the Hosted Application field is tied to the Initiation Widget. This event only fires when a Popup is routed from this specific Hosted Control.
Here, we will add the Co-Browse Create Activity Record for Contact Action Call..

There we have it, in seven easy steps we have integrated an application into USD and have reviewed many of the fundamental components required to customize a USD instance.

Too Long, Didn't Read? Here is the abbreviated version:

We created two Standard Web Application Hosted Controls: One for the Co-Browse Initiation Widget and one for the Co-Browse Application.
We created an Action Call to Navigate the Co-Browse Initiation Widget Hosted Control to a specified URL of our Web Resource
We also learned how to use the USD Debugger to test Action Calls
We then created a Windows Navigation Rule to take Popups from the Co-Browse Initiation Widget HC and route them to the Co-Browse Application HC.
We then created an Activity Entity in CRM to log our Co-Browse Sessions
Then, we created an Action Call that leveraged the CRMGlobalManager special Hosted Control to create records for our Co-Browse activities and associate them with a Contact record.
We then added our Action Call to load the Initiation Widget to the Session New event, invoking it every time USD starts a new Session.
Finally, we added our Record Creation Action Call to the Popup Routed event for the Initiation Widget Hosted Control so a record will be created every time a CSR starts to Co-Browse with a customer.

But wait, how did you incorporate Chat into the story? The extra components that work directly with the web chat as shown in the demonstration video include:

Toolbars associated with the Co-Browse Initiation Widget HC that trigger Javascript to submit a pre-defined chat message.
Action Call that triggers the action "MovePanel" on the Chat Hosted Control, automatically moving it from the MainPanel to the RightPanel. This Action Call should be invoked when you load another MainPanel application that you want to view alongside the chat window.

A New Blog for the Customer Obsessed

Kate Michel — Tue, 24 May 2016 19:34:10 GMT

Greetings and welcome to my blog. My name is Kate Michel and I am a Microsoft Certified CRM Specialist focusing on Call Centers, Customer Care and Engagement in the Enterprise space. In my current role at Microsoft I have the opportunity to match customer problems with technology solutions and I am passionate about finding the right answer to challenging or unique business questions. I have presented at such events as Convergence and Microsoft ISU in addition to hosting several webinars around solution integrations and customer best practices. My background in the Customer Service space ranges from implementing SaaS solutions to managing teams of technical support agents supporting over 55 million registered end users. Having worked on all sides of Customer Service software and projects I have a unique perspective on the industry, the software and the implementations that truly drive success, cost reduction and better customer relationships. In this blog we will focus on empowering customer obsessed organizations with innovative technology solutions and integrations powered by the Microsoft Service Cloud. You will find best practices, code samples and re-usable assets to engage with and delight customers of all industries.