Designing Chatbot Conversations

1. Introduction to Copilot Studio and Topics

Microsoft Copilot Studio (formerly known as Power Virtual Agents) is a low-code platform for creating powerful chatbots. As a developer, you can think of it as an environment where you define the logic and flow of a conversation that a user will have with an AI agent.

The fundamental building block of any conversation in Copilot Studio is the Topic. A topic is a self-contained conversation path designed to handle a specific user intent. For example, you might have one topic to handle questions about store hours, another for checking an order's status, and a third for booking an appointment.

When you create a new copilot, you'll see two types of topics:

• Custom Topics: These are the topics you will create to handle the specific needs of your business.
• System Topics: These are pre-built topics that handle common conversational events like greetings (Conversation Start), escalations, errors, and goodbyes. You can customize most of these.

To get a quick overview of what topics are and see how to customize the initial greeting, please watch the first couple of minutes of the following video.

2. The Anatomy of a Topic

From a developer's perspective, a topic is like a function or method. It's invoked by a specific trigger, it executes a series of steps (nodes), and it uses variables to manage state.

The following resource provides a clear, developer-focused breakdown of a topic's components.

Let's break down these components:

1. Trigger: This is what starts the topic. It's how the copilot recognizes the user's intent.
2. Conversation Nodes: These are the building blocks of the conversation flow. The most common nodes are:
   • Send a message: Displays text, images, or cards to the user.
   • Ask a question: Prompts the user for input.
   • Add a condition: Creates branching logic, similar to an if/else statement in C#.
   • Call an action: Invokes a Power Automate flow or another action to perform tasks, which we'll cover later.
3. Variables: These store information collected from the user or retrieved from other systems. Just like in your C# development, variables are essential for creating dynamic and stateful applications.

3. Triggering a Conversation

A copilot needs to understand when to start a particular topic. This is handled by the trigger. Copilot Studio offers two primary methods for this.

Method 1: Trigger Phrases (Classic Orchestration)

This is the traditional method. You provide a list of 5-10 short phrases or keywords that a user might type to express their intent. The copilot's NLU (Natural Language Understanding) model uses these phrases to match the user's input to the correct topic.

Method 2: Generative Triggers (Modern Orchestration)

This is the more advanced, AI-driven approach. Instead of a list of phrases, the trigger is based on the topic's name and description. The underlying large language model (LLM) uses the semantic meaning of your description to determine if a user's query matches the topic's purpose. This is more flexible and powerful than relying on exact phrase matching.

The video below demonstrates both creating a topic with the modern generative approach and then explains how to enable it if you're starting from the classic phrase-based method.

For a comprehensive list of all available trigger types, which is useful knowledge for the exam, you can refer to the official Microsoft documentation.

4. Building the Conversation Flow

Once a topic is triggered, the conversation flows from one node to the next on the authoring canvas. This is where you visually build the logic.

The following video provides a fantastic, in-depth walkthrough of building a complete topic from scratch. It covers adding triggers, asking questions, saving the response to a variable, and using conditional logic.

Key Steps in Building the Flow:

1. Start with the Trigger: Define your trigger phrases or description.
2. Ask for Information: Use a Question node to gather input from the user. You can specify what kind of information you expect (text, number, date, etc.).
3. Store the Response: Every question node needs to save the user's answer into a variable. It's a best practice to give your variables meaningful names (e.g., userEmail instead of Var1).
4. Implement Logic: Use a Condition node to create branches based on the value of a variable. This allows your copilot to respond differently in various scenarios.
5. Provide an Answer: Use a Message node to give information back to the user. You can insert variables directly into messages for a personalized response (e.g., "Thank you, {userName}!").

This image from the documentation perfectly illustrates a simple flow with a message, a question, and a condition based on the user's input.

As you build more complex copilots, it's a best practice to break down large, monolithic topics into smaller, reusable ones. You can use a Redirect action within one topic to call another, passing variables to maintain context. This is analogous to calling a helper function in your code.

Conclusion

In this lesson, you've learned the fundamental principles of designing conversational flows in Microsoft Copilot Studio. You now understand that topics are the core building blocks, how they are activated by triggers, and how to construct a conversation using nodes for questions, messages, and conditions.

Key Takeaways:

• Topics are self-contained conversational paths that handle a specific user intent.
• Triggers activate topics, either through classic trigger phrases or modern AI-driven generative descriptions.
• The authoring canvas is where you visually build the conversation flow using nodes.
• Question nodes are used to collect user input, which is stored in variables.
• Condition nodes use variables to create branching logic, enabling your copilot to handle different scenarios dynamically.

What's Next?

We've only scratched the surface of what you can do with user input. In the next lesson, we will go deeper into managing the conversation's state. You will learn how to manage conversation state using variables and extract user information with entities. This will allow you to capture more structured data from a user's free-form text, such as dates, email addresses, and custom patterns, making your copilot even more intelligent.