Conversation State & User Information Extraction

1. Advanced Variable Management: Building Modular Conversations

In programming, you don't write all your code in a single, monolithic function. You create smaller, reusable functions that call each other and pass parameters. The same principle applies to Copilot Studio. Large topics can become difficult to manage. The best practice is to break them down into smaller, focused topics that can be called from other topics. This requires a robust way to manage and pass variables to maintain the conversational state.

To understand these concepts, we'll refer to the official Microsoft documentation, which provides clear, step-by-step examples.

Let's break down the key patterns from that reading.

Passing Variables to Another Topic

This is analogous to calling a function with input parameters. It's essential for preventing your chatbot from asking for information it already has.

Scenario: A Greeting topic asks for the user's name. It then redirects to a Talk to Customer topic. Instead of asking for the name again, the Talk to Customer topic should use the name already collected.

How it works:

1. In the Destination Topic (Talk to Customer):

   • You have a Question node that asks for the user's name and saves it to a variable (e.g., customerName).
   • You open the Variable properties for customerName and enable the setting Receive values from other topics. This "opens the door" for this variable to be populated from an external source.

2. In the Source Topic (Greeting):

   • After collecting the name into its own variable (e.g., customerNameFromGreeting), you add a Redirect node pointing to the Talk to Customer topic.
   • In the Redirect node, you add an input mapping. You map the destination variable (customerName) to your source variable (customerNameFromGreeting).

When the conversation flows, the Greeting topic passes the value of customerNameFromGreeting into the customerName variable in the Talk to Customer topic. The copilot sees that the customerName variable is already filled and intelligently skips the question that asks for it.

Returning Values from a Topic

This pattern is like a function that has a return value. A topic can be designed specifically to find a piece of information and then give it back to the topic that called it.

Scenario: The Talk to Customer topic now also asks for the user's city. The original Greeting topic needs this information to finish the conversation.

How it works:

1. In the "Called" Topic (Talk to Customer):

   • You add a Question node that asks for the city and saves it to a variable (e.g., customerCity).
   • In the Variable properties for customerCity, you enable Return values to original topics.

2. In the "Calling" Topic (Greeting):

   • The Redirect node that calls Talk to Customer will now automatically show an output variable.
   • You can store this returned value in a new variable within the Greeting topic and use it in subsequent messages.

Mastering these two patterns is fundamental to creating scalable and maintainable copilots.

2. Extracting Structured Data with Entities

So far, we've mostly stored the user's entire response in a text variable. But what if a user says, "I'd like to book a flight to Paris for next Tuesday"? That single sentence contains three critical pieces of information:

• Intent: Book a flight
• Destination: Paris (a City)
• Date: next Tuesday (a Date and Time)

Entities are the mechanism Copilot Studio uses to identify and extract these specific pieces of information from a user's input. Think of an entity as a data type that helps the NLU model recognize real-world objects.

When you create a Question node, you'll see an Identify field. This is where you specify the entity. Instead of leaving it as "User's entire response", you can choose a specific entity.

Slot Filling: The Key to Natural Conversation

A powerful feature related to entities is slot filling. If the user provides information that matches an entity before the copilot asks for it, the copilot intelligently fills the corresponding variable (the "slot") and skips the question.

For example, if the first thing a user types is "I need to reset my password for the CRM system", and your topic has a question "Which system do you need help with?", the copilot will recognize "CRM", fill the variable, and skip the question, making the interaction much faster and more natural.

Types of Entities

Pre-built Entities

Copilot Studio includes a rich set of pre-built entities for common data types like Age, City, Color, Date and time, Email, Number, URL, and more. You should always use these when they fit your needs.

Custom Entities

When pre-built entities are not enough, you can create your own. This is where your developer skills become particularly valuable.

1. Closed List Entities: Use these for a known, finite set of items. For example, product categories (Hiking, Camping, Climbing) or departments (HR, IT, Finance). A key feature here is synonyms. You can define that "trekking" and "mountaineering" are synonyms for "hiking", so the copilot will understand them correctly.

2. Regular Expression (Regex) Entities: This is a powerful tool for any developer. You can define a pattern to capture consistently formatted data. This is perfect for things like:

   • Employee IDs (EMP-\d{5})
   • Order Numbers (ORD-\d{4}-\d{4})
   • License Plates
   • Case Numbers (CASE-[A-Z]{3}-\d{6})

Your background in programming and scripting makes you well-equipped to leverage Regex entities to handle complex, domain-specific data extraction.

Conclusion

In this lesson, you've elevated your copilot development skills by moving beyond simple conversation flows. You now have the tools to manage a conversation's state effectively and to extract precise, structured data from user input.

Key Takeaways:

• Variable Passing: You can create modular, reusable topics by passing variables to them (like function parameters) and returning variables from them (like return values).
• Entities are Data Types: Entities are the key to unlocking Natural Language Understanding, allowing your copilot to identify specific information within a user's message.
• Pre-built vs. Custom: Always leverage pre-built entities for common data types. For domain-specific needs, create Closed List entities for finite sets or Regex entities for pattern-based data.
• Slot Filling: This intelligent feature makes conversations more efficient by capturing information proactively and skipping unnecessary questions.

What's Next?

Now that we can capture structured data from the user (like an email address or a product ID) and store it in variables, the next logical step is to perform actions with that data. In our next lesson, we will learn how to integrate Copilot Studio with Power Automate flows to perform backend actions. This will bridge the gap between conversation and execution, allowing your copilot to create records in Dataverse, send emails, start approval processes, and interact with hundreds of other systems.