Fusion Dev Insights

Material Procurement Copilot Agent built using Anthropic Claude & Dataverse

Wed, 05 Nov 2025 14:30:00 +0530

Introduction
Technologies Involved
Overall Flow
Step 1: Get the Anthropic Claude Keys
Step 2: Create a Custom Connector for Anthropic Claude
Step 3: Create and Populate the Dataverse Table
Step 4: Creating the Agent in Copilot Studio
- Enable Generative Selection of Topics
Step 5: Create Topics
Testing the Agent
Conclusion

Introduction

In manufacturing and supply chain environments, maintaining optimal stock levels is critical. To address this, we’ll explore building a Material Procurement Agent that leverages Anthropic Claude to assess real-time inventory data from Dataverse. This Agent will analyze stock levels and reorder thresholds, providing actionable insights to help identify materials that need timely procurement.

Technologies Involved

Microsoft Copilot Studio: The platform to design and manage the conversational flow, adaptive card interface, and data retrieval from Dataverse.
Anthropic Claude: Claude will process and analyze selected material data from Dataverse, generating recommendations for procurement.
Dataverse: Stores the inventory data, including Material Name, Current Stocks, and Reorder Levels, serving as the central data source for material status and procurement needs.

Overall Flow

User Selects Materials: The process begins when the user initiates the Agent. An adaptive card is displayed, allowing the user to select materials from a list.
Data Retrieval from Dataverse: Based on the selected materials, the Agent fetches data from Dataverse, specifically the Material Name, Current Stocks, and Reorder Levels fields.
Claude Analysis: Using Anthropic Claude, the Agent analyzes the material data. The model reviews current stock levels against reorder thresholds to determine if procurement is necessary.
Results Displayed: The Agent displays a list of materials that need replenishment. Users receive clear recommendations on which items to prioritize for procurement.

Step 1: Get the Anthropic Claude Keys

Head over to Anthropic Console - Keys and Click on Create Key.
Save the key as we will use it to create the connection from Agent.

Step 2: Create a Custom Connector for Anthropic Claude

Go to Power Automate and select Custom Connector to create a connector that will issue POST requests to Anthropic Claude.
Select New Connector and Create from Blank.
Specify the connector name and click on Continue.

Click on Swagger editor and paste the below swagger definition on the left pane. Then Click on Create Connector.

swagger: '2.0'
info:
  title: Anthropic Claude Messages API
  description: >-
 Claude is a large language model (LLM) built by Anthropic. It's trained to
 be a helpful assistant in a conversational tone.
  version: 1.0.0
host: api.anthropic.com
basePath: /v1
schemes:
  - https
consumes:
  - application/json
produces:
  - application/json
paths:
  /messages:
 post:
   summary: Send Messages to Claude
   description: >-
     Send a structured list of input messages, and the model will generate
     the next message in the conversation.
   operationId: ClaudeMessagesPost
   parameters:
     - name: anthropic-version
       in: header
       required: true
       type: string
       description: The version of the Anthropic API to use.
       default: '2023-06-01'
     - name: body
       in: body
       required: true
       schema:
         type: object
         properties:
           model:
             type: string
             description: The model that will complete your prompt.
             default: claude-3-5-sonnet-20240620
             enum:
               - claude-3-5-sonnet-20240620
           messages:
             type: array
             items:
               type: object
               properties:
                 role:
                   type: string
                   description: The role of the message sender (user or assistant).
                   enum:
                     - user
                     - assistant
                 content:
                   type: string
                   description: The text content of the message.
               required:
                 - role
                 - content
             description: List of input messages for the conversation.
           max_tokens:
             type: integer
             format: int32
             description: The maximum number of tokens to generate.
             default: 1024
           temperature:
             type: number
             description: >-
               Controls randomness in the response, with values ranging from
               0.0 (deterministic) to 1.0 (highly random).
             default: 1
           stop_sequences:
             type: array
             items:
               type: string
             description: Custom sequences that will cause the model to stop generating.
           system:
             type: string
             description: A system prompt providing context and instructions to Claude.
           stream:
             type: boolean
             description: >-
               Whether to stream the response incrementally using server-sent
               events.
   responses:
     '200':
       description: Successful text generation
       schema:
         type: object
         properties:
           id:
             type: string
             description: Unique identifier for the message.
           content:
             type: array
             items:
               type: object
               properties:
                 type:
                   type: string
                   description: The type of content generated (e.g., text).
                 text:
                   type: string
                   description: The text generated by the model.
             description: The content generated by the model.
           model:
             type: string
             description: The model used for text generation.
           stop_reason:
             type: string
             description: The reason the model stopped generating.
             enum:
               - end_turn
               - max_tokens
               - stop_sequence
               - tool_use
           stop_sequence:
             type: string
             description: The stop sequence that was triggered, if any.
           usage:
             type: object
             properties:
               input_tokens:
                 type: integer
                 format: int32
                 description: Number of input tokens used.
               output_tokens:
                 type: integer
                 format: int32
                 description: Number of output tokens generated.
             description: Token usage information.
securityDefinitions:
  apiKeyHeader:
 type: apiKey
 in: header
 name: x-api-key
security:
  - apiKeyHeader: []

   

Step 3: Create and Populate the Dataverse Table

Create the table Raw Material Stocks in Dataverse and add fields for Material Name, Current Stocks, and Reorder Levels.

Step 4: Creating the Agent in Copilot Studio

Go to Copilot Studio and Click on Create. Select New Agent to create one from scratch.
Describe the Agent functionality and provide any specific instructions, then Click on Create to provision the Agent.

Enable Generative Selection of Topics

Click on Edit to update the Agent details like name, icon, and description. Then Click on Settings, to enable Generative selection of topics
Choose High - More precise for Content moderation.Save the settings and Close to return to the Agent’s main page.

Step 5: Create Topics

Go to the Topics section in the navigation menu.
Click on Add a Topic and choose Create from description with Copilot.
Provide the topic description, then Click on Create to provision the topic.

Adding Material Selection Card

In the Procurement Analysis topic, add an adaptive card asking which materials to analyze for procurement.

Add the below adaptive card schema in the node properties.

{
 "type": "AdaptiveCard",
 "version": "1.4",
 "backgroundImage": {
     "url": "https://copilotai29.blob.core.windows.net/copilot/bg.jpg"
 },
 "body": [
     {
         "type": "Image",
         "url": "https://copilotai29.blob.core.windows.net/copilot/in-stock.png",
         "size": "Small",
         "horizontalAlignment": "Center"
     },
     {
         "type": "TextBlock",
         "text": "Material Stock Check",
         "weight": "Bolder",
         "size": "extraLarge",
         "color": "Warning",
         "horizontalAlignment": "Center"
     },
     {
         "type": "TextBlock",
         "text": "Select the materials you want to check the stock levels for:",
         "wrap": true,
         "weight":"Bolder",
         "spacing": "Small",
         "color": "Good",
         "horizontalAlignment": "Center"
     },
     {
         "type": "Input.ChoiceSet",
         "id": "selectedMaterials",
         "style": "expanded",
         "isMultiSelect": true,
         "choices": [
             {
                 "title": "Aluminium Sheets",
                 "value": "AluminiumSheets"
             },
             {
                 "title": "Copper Wires",
                 "value": "CopperWires"
             },
             {
                 "title": "Silica Beading",
                 "value": "SilicaBeading"
             },
             {
                 "title": "Zinc Plates",
                 "value": "ZincPlates"
             }
         ]
     }
 ],
 "actions": [
     {
         "type": "Action.Submit",
         "title": "Check Stock Levels",
         "style": "positive",
         "data": {
             "action": "checkStock"
         }
     }
 ],
 "minHeight": "200px",
 "verticalContentAlignment": "Center"
}

Set the output variable as selectedMaterials to store user-selected materials.

Adding Dataverse Data Retrieval

Add the Dataverse connector action to retrieve records from the Raw Materials Dataverse table.
Configure the connector by specifying the Environment, Table name, and required table columns.
Store the fetched data in the rawMaterials variable for further processing.
The returned data from dataverse will contain additional system columns. Lets Initialize a variable (filteredStockDetails) to hold filtered data with only necessary columns. For this we will use the below Power Fx expression to loop through the Dataverse returned data and filter it.
```
ForAll(
 Topic.rawMaterials.value,
 {
     MaterialName: ThisRecord.crd69_materialname,
     CurrentStockLevels: ThisRecord.crd69_currentstockkg,
     ReorderLevels: ThisRecord.crd69_reorderlevelskg
 }
)
```
We will Test the filteredStockDetails variable to verify that only relevant information is retrieved by outputting in a message node.

Formatting Data for Analysis

We will further format the above JSON output of the filteredStockDetails variable for better understanding by the Claude model by formatting it as < Material Name > : < Current Stock Levels > : < Reorder Levels >.
```
Concat(Topic.filteredStockDetails, "Material Name : "&MaterialName & " - " & " Current Stock Levels : " & CurrentStockLevels & "-" & "Reorder Levels : "&ReorderLevels," , " )
```

Adding the Anthropic Claude Connector

Now lets add the Anthropic Claude custom connector to the copilot canvas using the Call an action option. Select the Anthropic Claude Custom Connector that we had previously created.
Provide the API key saved earlier for authentication.
Configure the connector fields with the below parameters:
- Anthropic-version: 2023-06-01
- Model: claude-3-5-sonnet-20240620

In the message field, add the prompt formula to be sent to Claude. Here we sent the dataverse data as well as the instruction to identify low stock from the data.

Table(
 {
     role: "user",
     content: Concatenate(
         "Analyze the given stock levels and determine whether procurement is needed based if the current stock levels is less than the reorder levels. \n\n",
         "**Stock Details**\n",
         Topic.serializedStockDetails,
         "\n\n**User Input:** - The user has selected the following materials for stock check: ",
         Concat(Topic.selectedMaterials, Value, ", "),
         ". Based on the current stock levels and reorder levels for each material asked by the user, identify which materials need to be reordered by checking if the current stock level is less than the reorder level. Ensure that this calculation is accurate. Provide a list of only the materials that need procurement and the reason for each in a bulleted format in less than 100 words.Strictly follow the Bulleted format   Material Name :Current Stock Level : Reorder Level : Procurement Needed ? : "
     )
 }
)

Store the output response from Anthropic Claude in the variable OutputResponse and configure a Message node to display the response back to the user using the below formula.
```
First(Topic.OutputResponse.content).text
```

Testing the Agent

Initiate the conversation and select materials to analyze from the adaptive card.
Click on Check Stock Levels. This action invokes Anthropic Claude to analyze the data and provide recommendations.

Conclusion

We have successfully created the Procurement Analyzer Agent, which leverages Anthropic Claude and Microsoft Copilot Studio to simplify inventory management. By analyzing Dataverse data, this Agent allows users to make data-driven procurement decisions in real-time, ensuring inventory remains optimized and responsive to changing needs.

PII Detection Copilot powered with AI Prompt Action

Wed, 29 Oct 2025 17:31:35 +0530

Introduction
Overview
- Features:
Step-by-Step Guide to Building the Supply Chain Copilot
Conclusion

Introduction

Businesses can now automatically scan and detect sensitive PII within their customer registration Dataverse tables.This capability empowers organizations to flag records containing personal information and take appropriate actions, such as masking sensitive fields, notifying compliance teams.

Overview

PII Detection Copilot helps businesses identify and take actions on personally identifiable information (PII) within their customer registration data.

Features:

Fetch Data: Retrieves customer registration data from Dataverse.
AI-Powered PII Identification: Detects PII using Azure OpenAI prompt actions, including sensitive data like names, SSNs, credit card details, and medical information.

Step-by-Step Guide to Building the Supply Chain Copilot

Step 1: Set Up Dataverse for Customer Registration Data

To begin, we need to organize our customer details in Dataverse. Create a table named Customer Registration with the following columns:

Name
MedicalID
Preexisting Conditions
Additional Details
And any other needed fields.

Step 2: Populate the Dataverse Table

Enter the customer details into the Dataverse table. We have the below data for the demo.

Step 3: Creating the Copilot in Copilot Studio

Head over to https://copilotstudio.microsoft.com/ and click on Create.

This will provide us the option to create a copilot based on an existing template or create a blank copilot from scratch. Let’s select New copilot.

This will take us to the page where we can:

Describe the copilot functionality and provide any specific instructions to the copilot.
Once done, click on Create to provision the copilot.

Step 4: Enable Generative Selection of Topics

The copilot is now created. We can then make the needed configuration changes.

Click on Edit, edit the copilot details like name, icon, and description.
Click on Settings to enable the Generative selection of topics so that without relying on triggers, the topics will be auto-selected based on user conversation resulting in a much smoother user experience.

To enable the automatic detection of topics from user interaction:

Click on Generative AI.
Select Generative (preview).
Select High – More precise for content moderation.
Click on Save to update the settings.
Click on the Close icon to go back to the homepage of this custom copilot.

Step 5: Create Topics

Now let’s go ahead and create the topics that will automatically redirect the conversation flow to appropriate topics based on the question user posts.

Click on Topics from the navigation menu.
To add the topic, we can either go with the option to create a blank topic or use Copilot to create the topic with an initial set of prepopulated conversation nodes based on the topic description that we provide.
Let’s click on Add a Topic.
Select Create from description with Copilot.

Let’s provide the below topic description details in the pop-up that opened when we clicked the Add topic button previously. Then, click on Create, which will provision the topic skeleton based on the provided description.

Thus, we have the basic topic created with an automatic trigger as well as a question to the user which is generated using the description provided. We can now add more conversation nodes.

As the first step, let’s add an adaptive card to accept details from the user.

Add the below adaptive card schema to the node properties so that it will provide the user with the option to enter the medical ID that we need to search for and also the specific PII information to search for.

{
    "type": "AdaptiveCard",
    "version": "1.4",
    "backgroundImage": {
        "url": "https://adaptivecardsbot.blob.core.windows.net/imagestore/GDPRBG.jpg"
    },
    "body": [
        {
            "type": "Image",
            "url": "https://adaptivecardsbot.blob.core.windows.net/imagestore/GDPR.png",
            "size": "Medium",
            "horizontalAlignment": "Center"
        },
        {
            "type": "TextBlock",
            "text": "GDPR PII Checker",
            "weight": "Bolder",
            "size": "Large",
            "color": "Accent",
            "spacing": "Medium",
            "horizontalAlignment": "Center"
        },
        {
            "type": "TextBlock",
            "text": "Enter the Medical ID and select the personal information you want to check for.",
            "wrap": true,
            "spacing": "Small",
            "size": "Medium",
            "horizontalAlignment": "Center",
            "weight": "Default"
        },
        {
            "type": "TextBlock",
            "text": "Medical ID",
            "weight": "Bolder",
            "size": "Medium",
            "color": "Good",
            "spacing": "Medium"
        },
        {
            "type": "Input.Text",
            "id": "medicalId",
            "placeholder": "Enter Medical ID",
            "style": "text",
            "spacing": "Small"
        },
        {
            "type": "TextBlock",
            "text": "Select Information to Check",
            "weight": "Bolder",
            "size": "Medium",
            "color": "Good",
            "spacing": "Medium"
        },
        {
            "type": "Input.Toggle",
            "id": "checkName",
            "title": "Name",
            "valueOn": "true",
            "valueOff": "false",
            "wrap": true,
            "spacing": "Small",
            "weight": "Default",
            "size": "Medium"
        },
        {
            "type": "Input.Toggle",
            "id": "checkCreditCard",
            "title": "Credit Card",
            "valueOn": "true",
            "valueOff": "false",
            "wrap": true,
            "spacing": "Small",
            "weight": "Default",
            "size": "Medium"
        },
        {
            "type": "Input.Toggle",
            "id": "checkSSN",
            "title": "Social Security Number (SSN)",
            "valueOn": "true",
            "valueOff": "false",
            "wrap": true,
            "spacing": "Small",
            "weight": "Default",
            "size": "Medium"
        },
        {
            "type": "Input.Toggle",
            "id": "checkConditions",
            "title": "Preexisting Conditions",
            "valueOn": "true",
            "valueOff": "false",
            "wrap": true,
            "spacing": "Small",
            "weight": "Default",
            "size": "Medium"
        }
    ],
    "actions": [
        {
            "type": "Action.Submit",
            "title": "Check GDPR Compliance",
            "style": "positive",
            "spacing": "Medium"
        }
    ]
}

The user input details can be found in the output variables of the adaptive card, which we will be using down the line.

Step 6: Fetching Customer Details from Dataverse

We now need to fetch the customer details from the Dataverse table for which we will add the Dataverse connector action by:

Select Call an action.
Select the Connector tab and search for Dataverse.
Click on List rows from selected environment.

This will add the Dataverse connector action to the Copilot canvas, and let’s configure the inputs for this action by:

Mentioning the Environment and Table name where the Customer Registration Details Table is present.

Specify the column names from the table that should be returned in the results .

 cr026_medicalid,cr026_name,cr026_preexistingconditions,cr026_additionaldetails

Using the Filter rows field, mention the specific MedicalID that the user had input in the adaptive card to fetch the specific table record .
```
Concatenate("cr026_medicalid eq '", Topic.medicalId,"'")
```

The output of the Dataverse connector will be stored in the varCustomerDetails variable, which we will use for further processing in the subsequent steps.

Step 7: Adding AI-Prompt for PII Detection

The output of the Dataverse Table Connector (varCustomerDetails) will contain lots of system columns as well. We will need to format the table to filter and ensure only the needed columns are present.

To do this, let’s initialize a variable (varFilteredTable) to hold the filtered output of the Dataverse connector .

ForAll(
    Topic.varCustomerDetails.value,
    {
        Name: ThisRecord.cr026_name,
        MedicalID: ThisRecord.cr026_medicalid,
        PreExistingConditions: ThisRecord.cr026_preexistingconditions,
        AdditionalDetails: ThisRecord.cr026_additionaldetails
    }
)

If we were to test and output this variable value in the test pane, we will get the output as :

[{“AdditionalDetails”:“Credit Card: 1234-5678-9101-1121”,“MedicalID”:“15”,“Name”:“Graham Maynard”,“PreExistingConditions”:“Fatty Liver”}]

Since the table cannot be used as input to the Prompt action, we will do one more formatting of this output to serialize this JSON into a readable format: <Name>: <MedicalID>: <Pre Existing Conditions>: <Additional Details>.

To do this, let’s add another variable and set its formula as below :

Concat(Topic.varFilteredTable, Name & ": " & MedicalID & ":" & PreExistingConditions & " :" & AdditionalDetails)

This way, from the previous filtered table, we will concatenate the customer information in a readable format, which can be shared as an input to the AI Prompt.

Now, let’s add the AI prompt using which we can check for the PII of a customer. To do this:

Select Call an action.
From Basic Actions, select Create a prompt.

This will open up the Prompt window where we can name the prompt and also:

Define the variables that will be used in the prompt, which will be dynamically added from the copilot during runtime.
Create the prompt that will be used to identify PII from the Dataverse returned data and also mask them as needed.
Save the prompt, which will make it available for use within the Copilot canvas.

Now that the Prompt action is added, populate the:

Adaptive Card outputs into the respective Prompt action input fields.
Pass the serialized Dataverse returned data into the Prompt action.

The output of the Prompt action will be stored in the varPrediction variable, which we will be using for displaying the final output.

Finally, we will show the PII detection output as a basic card back to the user, for which we will select the text property of the varPrediction record, which will contain the Generative AI output.

Topic.varPrediction.text

Test the Copilot

Now, let’s test the Copilot by triggering the conversation, and we will enter the details to check for in the adaptive card.

It fetches the details from the Dataverse table and passes them to the Prompt action to check if any PII is present. It masks the related information and shares the details back with the user.

Conclusion

The PII Detection Copilot provides a powerful and automated solution for detecting personally identifiable information (PII) using Azure OpenAI and Microsoft Copilot. By fetching customer data from Dataverse, detecting PII, and masking sensitive information, businesses can ensure compliance with data privacy regulations. This streamlined process, powered by AI, helps organizations safeguard sensitive data and improve customer trust.

Smart Invoice Anomaly Detection using AI prompt Action and Dataverse data

Wed, 22 Oct 2025 17:31:35 +0530

Introduction
Process Flow
Demo
Steps to Create the Invoice Anomaly Detection System
Create the Dataverse Table
Creating the Copilot in Copilot Studio
Enable Generative Selection of Topics
Create Topics
Test the Copilot
Conclusion

Introduction

Keeping invoices accurate is crucial to avoid financial mistakes. This blog will show you how to build an Invoice Anomaly Detection system using Copilot Studio. You’ll learn how to input invoice details using an Adaptive Card and compare them with previous month’s data stored in Dataverse. The system will automatically check for any irregularities using AI prompt actions, helping you ensure accuracy and streamline your invoice process.

Process Flow

Invoice Anomaly Detection System involves several key steps to ensure accurate and efficient anomaly detection. Here’s an overview of the process:

Data Storage: Invoice details are stored in Dataverse, allowing us to easily access and compare previous month’s data.
Copilot Setup: Using Copilot Studio, we build a bot that captures the current month’s invoice details through an Adaptive Card and stores them as variables.
Data Retrieval: The system fetches invoice data from Dataverse and formats it for comparison.
Anomaly Detection: By leveraging AI prompt actions, the bot compares the current month’s invoice details with the historical data. If discrepancies are detected, the bot highlights them for review.
Results Display: Finally, the system presents the analysis results in a user-friendly format, allowing you to take any necessary actions to maintain financial accuracy.

Demo

Watch the demo video below to see how the Invoice Anomaly Detection System works.

Steps to Create the Invoice Anomaly Detection System

Create the Dataverse Table

We will be storing the invoice details in the Dataverse table, which will contain the previous month’s invoices that we will be using to spot any irregularities. The table will contain the following columns:

Product Name
Invoice Amount
Month
Quantity

Creating the Copilot in Copilot Studio

Step 1: Head over to Copilot Studio and click on Create. This will provide the option to create a copilot based on an existing template or create a blank copilot from scratch. Let’s select New Copilot.

Step 2: You will now see a page where you can:

Describe the copilot functionality and provide any specific instructions.
Click on Create to provision the copilot.

Enable Generative Selection of Topics

Now that the copilot is created, we can configure it further.

Step 1: Click on Edit to modify details like the copilot’s name, icon, and description.

Step 2: Click on Settings and enable the Generative selection of topics, which allows topics to be automatically selected based on user conversations. This leads to a smoother user experience.

To enable the automatic detection of topics from user interaction:

Click on Generative AI.
Select Generative (preview).
Click on Save to update the settings.
Click the close icon to return to the home page of this custom copilot.

Create Topics

Let’s create topics that will automatically redirect the conversation flow based on the questions posed by users.

Step 1: Click on Topics from the navigation menu.

To add a topic:

Either create a blank topic or use Copilot to generate a topic with prepopulated conversation nodes based on the description you provide.
Click on Add a Topic.
Select Create from description with Copilot.

In the pop-up, provide the necessary topic description and then Click on Create. This will provision the topic skeleton.

Now that the basic topic is created with an automatic trigger, we can add more conversation nodes. Let’s add an Adaptive Card so users can input invoice details.

We will add the JSON schema for the adaptive card in the Node properties:

{
    "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
    "type": "AdaptiveCard",
    "version": "1.4",
    "body": [
        {
            "type": "ColumnSet",
            "columns": [
                {
                    "type": "Column",
                    "width": "auto",
                    "items": [
                        {
                            "type": "Image",
                            "url": "https://adaptivecardsbot.blob.core.windows.net/imagestore/InvoiceProcess.png",
                            "size": "Small",
                            "style": "Person"
                        }
                    ]
                },
                {
                    "type": "Column",
                    "width": "stretch",
                    "items": [
                        {
                            "type": "TextBlock",
                            "text": "Invoice Entry Form",
                            "weight": "Bolder",
                            "size": "Large",
                            "wrap": true
                        }
                    ]
                }
            ]
        },
        {
            "type": "TextBlock",
            "text": "Please fill in the details below to submit your invoice.",
            "wrap": true,
            "weight": "Bolder",
            "color": "Good", 
            "spacing": "Medium"
        },
        {
            "type": "TextBlock",
            "text": "Invoice Month",
            "weight": "Bolder",
            "wrap": true,
            "spacing": "Small"
        },
        {
            "type": "Input.Text",
            "id": "invoiceMonth",
            "placeholder": "Enter Invoice Month (e.g., January)"
        },
        {
            "type": "TextBlock",
            "text": "Product Name",
            "weight": "Bolder",
            "wrap": true,
            "spacing": "Small"
        },
        {
            "type": "Input.Text",
            "id": "productName",
            "placeholder": "Enter Product Name"
        },
        {
            "type": "TextBlock",
            "text": "Quantity",
            "weight": "Bolder",
            "wrap": true,
            "spacing": "Small"
        },
        {
            "type": "Input.Number",
            "id": "quantity",
            "placeholder": "Enter Quantity"
        },
        {
            "type": "TextBlock",
            "text": "Invoice Total",
            "weight": "Bolder",
            "wrap": true,
            "spacing": "Small"
        },
        {
            "type": "Input.Number",
            "id": "invoiceTotal",
            "placeholder": "Enter Invoice Total"
        }
    ],
    "actions": [
        {
            "type": "Action.Submit",
            "title": "Submit"
        }
    ],
    "style": "default",
    "backgroundImage": {
        "url": "https://adaptivecardsbot.blob.core.windows.net/imagestore/background.jpg"
    }
}

The user-entered values in the adaptive card will be available as output variables.

Step 3: Add a variable using Power Fx to concatenate user input into the format: ProductName: Month: InvoiceTotal (Quantity kg).

For example:
Copper Wires: March: 1900 (15 kg)

We will add the below expression to the variable varCurrentMonthInvoiceDetails:

Concat(Topic.varFormattedTable, Product & ": " & Month & ":" & Amount & " (" & Quantity & " kg)", ", ")

Step 4: Now, add the Dataverse connector action to fetch the previous month’s invoice details from the Monthly Invoices table.

To do this:

Select Call an action.
From the connector tab, search for Dataverse.
Select List rows from the selected environment.

Configure the connector by:

Mentioning the Environment and table name.
Click on Advanced Inputs to filter the columns returned.

Add the necessary logical names for Product Name, Month, Quantity, and Invoice Amount to the Select columns field.

Step 5: Add an output variable varInvoiceTable to store the Dataverse returned data in a table format. Since there are system columns in the data, we’ll filter it using the following format:

[
{"Amount":"1000","Month":"January","Product":"Copper Wires","Quantity":"15"}, 
{"Amount":"1100","Month":"February","Product":"Copper Wires","Quantity":"15"}
]

We will store the filtered table in a new variable varFormattedTable using the below Power Fx expression:

ForAll(
    Topic.varInvoiceTable,
    {
        Product: ThisRecord.crfeb_productname,
        Month: ThisRecord.crfeb_month,
        Amount: ThisRecord.crfeb_invoiceamount,
        Quantity: ThisRecord.crfeb_quantitykg
    }
)

Step 6: Serialize the table data for the AI prompt action, as it cannot accept tables directly. Use the below format:

Eg: Copper Wires: January: 1000 (15 kg), Copper Wires: February: 1100 (15 kg)

Store the serialized data in a variable varSerializedInvoiceDetails and concatenate the table data using the below expression.

Concat(Topic.varFormattedTable, Product & ": " & Month & ":" & Amount & " (" & Quantity & " kg)", ", ")

Step 7: Add an AI Prompt action by selecting Call an action, and from the Basic actions tab, select Create a prompt. This opens a pop-up where you can:

Enter a name for the prompt.
Create variables for Current Month Invoice and Previous Month Details.
Add dynamic variables to the prompt using the Insert button.
Click on Save custom prompt to make it available in the Copilot designer.

Step 8: Add the prompt by selecting Call an action, and from the Basic actions tab, choose the Invoice Anomaly Checker prompt.

Configure the prompt by adding the previously created variables:

varSerializedInvoiceDetails: Previous month’s data.
varCurrentMonthInvoiceDetails: Current user input.

We will store the AI-prompt output in varPredictionOutput.

Step 9: Finally, add a basic card and populate it with details from the varPredictionOutput.

The text property will contain the AI-generated output, which we will display in the Adaptive Card.

Test the Copilot

Let’s test the copilot by specifying invoice details for the month of March using the Adaptive Card.

Upon submission, previous month’s invoice details are fetched from Dataverse, and using the AI Prompt action, the copilot identifies any potential variations in the invoice and shares them back with the user.

Conclusion

In this blog, we successfully built an Invoice Anomaly Detection system using Copilot Studio. By leveraging Adaptive Cards for user inputs, Dataverse for storing historical data, and AI prompt actions for detecting anomalies, we created a seamless and accurate invoice-checking process. This helps in identifying potential mistakes and ensures better financial accuracy. The same approach can be extended to various other data anomaly detection scenarios, streamlining business processes efficiently.

Build a Responsible AI Copilot with Azure Content Safety Service

Thu, 16 Oct 2025 17:31:35 +0530

Introduction
Prerequisites
Step 1: Setting Up Azure Content Safety
- Create an Azure Content Safety Resource
Step 2: Create the Copilot
Step 3: Enable Generative Selection of Topics
Step 4: Create Topics
Test the Copilot
Conclusion

Introduction

In this blog, we will create a Copilot that can accept user input, check if it’s safe using Azure Content Safety against four categories (self-harm, hate, violence, and sexual), and if deemed safe, query the United Nations website using generative actions to provide a response to the user. Follow the steps below to build this solution.

Prerequisites

Before we start, ensure you have the following:

An Azure account
Access to Azure Content Safety
Access to Copilot Studio

Step 1: Setting Up Azure Content Safety

Create an Azure Content Safety Resource

Head over to Azure portal and search for Content Safety
Select Create, which will open the window to add the Content Safety configurations.
Specify the Subscription and Instance details for the Content Safety Service. Click on Review and Create.
From the Keys and Endpoint section of the service, Copy the Endpoint and Key which we will be using in the Copilot.

Step 2: Create the Copilot

Head over to Copilot Studio and click on Create.
Select “New copilot” to create a copilot from scratch.
Describe the copilot functionality and provide any specific instructions to the copilot. Once done, click on Create to provision the copilot.

Step 3: Enable Generative Selection of Topics

Click on Edit, edit the copilot details like name, icon, and description.
Click on Settings to enable the Generative selection of topics so that without relying on triggers, the topics will be auto-selected based on user conversation resulting in a much smoother user experience.
Click on Generative AI.
Select Generative (preview).
Click on Save to update the settings.
Click on Close icon to go back to the home page of this custom copilot.

Step 4: Create Topics

Click on Topics from the navigation menu.
Click on Add a Topic and select Create from description with Copilot.
Provide the topic description details and click on Create, which will provision the topic skeleton based on the provided description.
Add a variable to store the user query:
- From variable management, select Set a variable value.
- Configure the variable:
  1. Set the variable name to varUserQuery.
  2. Click the arrow next to the To Value.
  3. Select the System tab.
  4. Set the value to Activity.Text.
Add the step to invoke the Azure Content Safety API to validate the user query and check for any unsafe content:
- From the advanced tab, select Send HTTP Request.

Configure the HTTP Action:

Paste the content safety URL saved from Azure Portal.
Select the Method as POST.
Click on Edit in the Headers and body section.
Add 2 headers:
1. Set the Key as Content-Type.
2. Set the Value as application/json.
3. Click on Add.
4. Set the Key as Ocp-Apim-Subscription-Key.
5. Set the Value to the content safety endpoint key saved from Azure.
Update the request body:
- Select JSON Content from the Body section.
- Select Edit Formula and click on Formula to add the user query variable.
- Add the below expression to the body tag:
```
  {
    "Text": Topic.varUserQuery
  }
```

Define the response data type:

Select From sample data to provide the sample output.

Paste the below schema in the pop-up and click on Confirm:

  {
      "blocklistsMatch": [],
      "categoriesAnalysis": [
          {
              "category": "Hate",
              "severity": 2
          },
          {
              "category": "SelfHarm",
              "severity": 0
          },
          {
              "category": "Sexual",
              "severity": 0
          },
          {
              "category": "Violence",
              "severity": 0
          }
      ]
  }

Create a new variable to hold the output of the content safety API, named varSafetyOutput.

Declare variables for the content safety ratings:

Hate Severity:

  First(Filter(Topic.varSafetyOutput.categoriesAnalysis, category = "Hate")).severity

Self Harm Severity:

  First(Filter(Topic.varSafetyOutput.categoriesAnalysis, category = "SelfHarm")).severity

Sexual Severity:

  First(Filter(Topic.varSafetyOutput.categoriesAnalysis, category = "Sexual")).severity

Violence Severity:

  First(Filter(Topic.varSafetyOutput.categoriesAnalysis, category = "Violence")).severity

Create an overall safety variable named varOverallSafety to determine if there is any sort of content safety issue:

 If(
     Topic.varHateSeverity = 0 && 
     Topic.varSelfHarmSeverity = 0 && 
     Topic.varSexualSeverity = 0 && 
     Topic.varViolenceSeverity = 0,
     "Safe",
     "Unsafe"
 )

Check the varOverallSafety variable and create a positive control flow branch:

Add the condition action.
Add the generative answers node in the positive branch:
- Select Generative Answers.
- Configure the input to use varUserQuery.
Edit the data source and click on Add knowledge to enter the United Nations website as the source.
- Select Public Websites as the knowledge source.
- Enter the UN website link and click on Add.

In the negative flow branch, add the below expression to check the 4 variables and provide appropriate messages to the user:

  If(
      Topic.varHateSeverity > 0,
      "The query contains hate speech. Please reformulate your question.",
      ""
  ) & 
  If(
      Topic.varSelfHarmSeverity > 0,
      "The query indicates self-harm. Please seek immediate help or contact a professional.",
      ""
  ) &
  If(
      Topic.varSexualSeverity > 0,
      "The query contains inappropriate sexual content. Please rephrase your question.",
      ""
  ) &
  If(
      Topic.varViolenceSeverity > 0,
      "The query contains references to violence. Please reformulate your question.",
      ""
  )

Thus we have completed the configuration of the copilot and have ensured that proper content safety is checked before generating the contextual answers from the UN website.

Test the Copilot

Test the copilot by triggering the conversation with a question. You can see that the Azure Content Safety API has detected hate speech and has given the custom message back to the user to reformulate the question.
Ask another question. You can see that this time the Azure Content Safety has detected violence in the user query and has asked to reformulate the question.
Ask a content safe question. You can see that the copilot fetches the accurate information along with citation links from the UN website using its generative AI capabilities.

Conclusion

In this blog, we demonstrated how to create a Copilot that uses Azure Content Safety to filter user inputs against harmful content categories and queries the United Nations website for safe user inputs. This approach ensures a secure and informative interaction with the Copilot, providing accurate information while maintaining user safety. By following these steps, you can build similar solutions that integrate content safety checks with generative AI capabilities to deliver valuable and secure user experiences.

Customer Service Copilot using Sentiment Analysis and Live Agent Escalation

Fri, 10 Oct 2025 17:31:35 +0530

Introduction
Process Flow
Demo
Prerequisites
Technologies Involved
Steps to Create the Customer Service Copilot
Conclusion

Introduction

Providing exceptional customer service is crucial for businesses to thrive. One of the key aspects of modern customer service is leveraging AI to analyze and respond to customer feedback efficiently. This blog will guide you through creating a dynamic customer service Copilot using Microsoft Dynamics 365, Azure AI Language Service, and Copilot Studio. The Copilot will analyze user feedback for sentiment and handle it accordingly, either storing positive feedback in Dataverse or escalating negative feedback to a human agent through Omnichannel.

Process Flow

This guide will walk you through the process of setting up an intelligent Customer Service Copilot from scratch. The steps involved are:

User provides restaurant feedback via a chat interface.
Copilot receives the feedback and invokes the Azure AI Language endpoint to perform sentiment analysis on the feedback.
Azure AI Language endpoint identifies the feedback sentiment.
- If the feedback is positive:
  - The feedback is saved to Dataverse.
- If the feedback is negative:
  - The feedback is handed over to a human agent in Dynamics 365 Customer Service.
Customer agent gets notified with the conversation history and can respond to the user through Copilot, establishing a two-way communication channel.

This flow ensures that all feedback is appropriately analyzed and acted upon, with positive feedback being stored for future reference and negative feedback being escalated to human agents for immediate attention.

Demo

Watch the demo video below to see how the intelligent Customer Service Copilot works.

Prerequisites

Before we begin, ensure you have the following:

A Microsoft account
Access to Azure Portal
Dynamics 365 Customer Service trial
Basic understanding of Power Platform and Azure services

Technologies Involved

Dynamics 365 Customer Service: For providing a comprehensive customer service platform.
Azure AI Language Service: For analyzing the sentiment of user feedback.
Dataverse: For storing feedback data.
Copilot Studio: For creating and configuring the Copilot.
Power Pages: For embedding the chat widget and testing the Copilot interactions.

Steps to Create the Customer Service Copilot

Step 1: Provisioning a Dynamics 365 Customer Service Trial

Go to Dynamics 365 Customer Service trial to sign up for the trial.

Once provisioned, you will land on the customer service workspace which gives you a 30-day trial run time.

Step 2: Creating Necessary Dataverse Tables

Create a Dataverse table to store positive feedback, so it doesn’t need to be escalated to a human agent.

Step 3: Setting Up Azure AI Language Service for Sentiment Analysis

We will also need to create an instance of Azure AI Language service to help us with the sentiment analysis of the user submitted feedback.

Head over to the Azure AI Services section and from the left pane select Language Service and click on Create.

The next page will show the default features that come with the service and the option to add custom features. We will go with the default features as it contains sentiment analysis. Click on Continue to create your resource.

Mention the subscription and instance details and click on Review + Create.

Once the resource is created, we can head over to the page and from the Keys and endpoint section copy the Endpoint and Keys so that we can use it within the Copilot Studio to connect to the Azure AI Language Connector.

Step 4: Configuring the Copilot in Copilot Studio and Setting Up the Handover

Head over to Copilot Studio and select the Customer Service environment that got created as we signed up for the trial.

Step 5: Creating the Copilot

Click on Create.
This will provide us the option to create a Copilot based on an existing template or create a blank Copilot from scratch. Let’s select New Copilot.

This will take us to the page where we can:
- Describe the Copilot functionality and provide any specific instructions to the Copilot.
- Once done, click on Create to provision the Copilot.

Step 6: Configuring the Copilot

The Copilot is now created. We can then make the needed configuration changes.

Click on Edit, edit the Copilot details like name, icon, and description.
Click on Settings to set the authentication to No Authentication.

From the Settings section, select Security -> Authentication. Choose No authentication and click on Save so that the Copilot will be accessible without authentication to public users to give feedback.

Step 7: Creating Topics

Click on Topics from the navigation menu.
To add the topic, we can either go with the option to create a blank topic or use Copilot to create the topic with an initial set of prepopulated conversation nodes based on the topic description that we provide.
Let’s click on Add a Topic and select From blank.

We have named the topic as Feedback Analyzer and added the trigger phrases that will invoke this topic. As a conversation starter, we are also asking the question about the feedback and the response is stored in the variable varUserFeedback.

Note: We are not enabling the Generative selection of topics due to existing issues in Agent Handover where null messages are posted during the handover process (we will see this down the line).

Now we will add the HTTP request node by selecting Advanced -> Send HTTP request so that we can invoke the Azure AI Language endpoint to detect the user feedback sentiments.

Let’s configure the HTTP request node by:
- Specify the URL of the Azure AI Language instance that we had created earlier and append text/analytics/v3.1/sentiment to it. The URL will look like below https://<Azure AI Language Instance Name>.cognitiveservices.azure.com/text/analytics/v3.1/sentiment
- Mention the method as POST
- Click on Edit to update the header and body

We will add 2 header attributes:
- Click on Add
- Mention the first parameter key as Content-Type and value as application/json

Let’s add one more attribute for the API Key:
- Click on Add
- Mention the key as Ocp-Apim-Subscription-Key and value as <the key copied from the Azure AI Language Instance>

Now we will add the body of the request by selecting the:
- JSON Content from the drop-down
- Ensure that you select Formula as the way of mentioning the body within the box so that we can pass in dynamic content which is the user feedback variable.

Add the below formula to the box which will format the body as expected by the Azure AI Language API where text key will contain the user feedback submitted.
```
{
  documents: [
{
  language: "en",
  id: "1",
  text: Topic.varUserFeedback
}
  ]
}
```

Now let’s configure the Response data type as From sample data and click on Get schema from sample JSON so that we can pass the sample output of the Azure AI Language API and the response schema can be auto-generated from it.

We will add the below sample output JSON to generate the schema:

{
  "documents": [
{
  "confidenceScores": {
    "negative": 0.98,
    "neutral": 0.01,
    "positive": 0.01
  },
  "id": "1",
  "sentences": [
    {
      "confidenceScores": {
        "negative": 0.98,
        "neutral": 0.01,
        "positive": 0.01
      },
      "length": 11,
      "offset": 0,
      "sentiment": "negative",
      "text": "bad service"
    }
  ],
  "sentiment": "negative",
  "warnings": []
}
  ],
  "errors": [],
  "modelVersion": "2022-11-01"
}

Add the Sample JSON to the pop-up
Click on Confirm which will convert this into a schema
Finally, save the output to a new variable varOutput

As we can see in the above sample output, the Sentiment value is nested within the node documents->sentences->sentiment which we will be trying to extract using Power Fx. For this, we will add a new variable and use the below Power Fx:
```
First(Topic.varOutput.documents).sentiment
```
- Create a new variable named varSentiment in the Set variable field
- Assign the above Power Fx formula to the To value field so that we can extract the sentiment value from the output

Now that we have the sentiment value, we will add a condition check and if the sentiment is negative, we will escalate it to a human agent using the Transfer conversation node.

If feedback is positive, we can save the feedback to Dataverse by calling a Power Automate and passing the user feedback. We will not be able to use the Dataverse connector directly in this scenario because we have enabled No authentication for the Copilot. The positive feedback saving flow is pretty simple as it directly saves the feedback to the table.

Step 8: Configure Transfer to Agent Node

Before making further changes, let’s save the Topic and publish the bot once. Now let’s configure the Agent transfer by selecting Channels -> Dynamic 365 Customer Service.

We would need a Dynamics 365 Customer Service environment for the Omnichannel agent transfer to work.

We can see the message stating, we don’t have access to all the required variables and actions. The mentioned packages aren’t required to hand off to Omnichannel for Customer Service, but they provide Copilot authors with a better experience by providing extra variables and actions.

So let’s install the package from here.

Mention the user account and click on Get It Now.

Next, we will select the environment where we would like to install the Omnichannel Extension and click on Install.

This will install the needed extensions and if we head back to the Copilot channel page, we can now see that the warning message is no longer there.

Since we had signed up for a trial customer service instance, it is available for us to connect. We can see the status is currently Not connected, let’s click on Connect.

Note: In case you end up seeing the below message even after having a Customer Service instance, it is probably because your Copilot and Customer Service are in two different environments. Both have to be in the same environment to configure the handover.

Thus we have established the connection between the Copilot and Omnichannel. Click on View in Omnichannel so that we can head over to the Omnichannel admin center.

In the Users section of the Omnichannel admin center, we can see that the Copilot has been added as a user.

Step 9: Create the Queue

So as to proceed with successfully performing the handover we need to do 3 actions:

Create a Queue
Create a Workstream
Create a RuleSet

Though we can do this from the Omnichannel admin center, it is deprecated, and we are advised to start using the Customer Service Admin center going forward. So let’s head over to by clicking the Open Customer Service admin center.

Now that we are inside the Customer Service admin center, to hold the incoming conversations that are handed over, we will create a Queue and add the human agent as well as the Copilot that we have created to the queue.

Click on Queues from the left side pane.

From the Advanced queues section, click on Manage.

We will configure the queue by:

Click on New Queue.
Mention the Queue Name.
We can create a Messaging/Record/Voice queue. For this demo, we will create a messaging handover queue.
Specify the Group Number. Assigning a group number helps you organize your queues in the list view if there are multiple queues. The group number won’t affect the priority of the queue or the incoming conversations.
Click on Create to provision the queue.

Once the queue is created, it will take us to the newly created queue page. Click on Add Users as we have to add the Human Agent as well as the Copilot to the Queue.

Select the human agent user as well as the Copilot agent instance and click on Add.

The queue setup is now done and we will add this to a workstream as the conversation handovers will first come to the workstream and from there it is routed to different queues.

Step 10: Create Workstream

Now let’s create a Workstream. A workstream acts as a container to route, and assign work items.

From the Workstreams tab in the left pane, click on New Workstream.

Let’s configure the workstream by:

Specifying the workstream name, Type as Messaging and the channel type as Chat.
Select the work distribution mode as Push so that when a conversation comes, it is auto assigned to agents based on capacity and presence.
We will come to routing rules in a while. If there are no routing rules defined, then we need a fallback or default queue to which the conversation will be handed over. For this, we have already created a queue earlier, so let’s select choose existing and pick the FeedbackMonitor queue.
Click on Create.

Once the workstream is created it will automatically take us to the newly created workstream where we can configure the chat that we will be using for interacting with the users. The Copilot interactions will now be hosted within this chatbot.

Click on Set up chat.

This will open up the popup where we can define the chat channel attributes like name and language and click on Next.

In the next page, we can define the look and feel of the chat bot widget that will host the Copilot conversations and the human agent handover. We have provided the title, subtitle, theme color, Azure blob hosted logo URL, agent display name as well as the widget positioning. Click on Next.

We will retain the chat channel behavior parameters AS IS and click on Next.

We will retain the user features like file upload, customer notifications, and conversation transcripts ON and click on Next.

Let’s click on Create channel to provision the chat channel.

Once the channel is created, it will take us to the chat channel section where we can copy the Chat Widget Javascript code by clicking on the Copy Live Chat Widget 2.0 Script. This can later be embedded into the website or Power Pages which will allow the user to chat with the Copilot and initiate the handover to the agent as part of the escalation process.

We can also create a rule set from this section which allows us to define some conditions and route the conversation to specific queues. If there are no rulesets defined, the fallback queue that we created earlier will be used.

Clicking on the Ruleset will allow us to add conditions to route conversations. This comes in handy if there are multiple queues. For instance, we can check the incoming customer name and route the conversation to a specific queue where a particular agent assigned to that customer can handle all the related conversations.

We will for the time being go with the fallback default queue that we have created.

This completes the configuration of the Omnichannel within the Customer Service admin center. We can now go ahead and use the chat widget which embeds the Copilot and handover logic within Power Pages of a restaurant to test it out.

Step 11: Testing in Power Pages

Embed the chat widget script obtained from the Omnichannel setup into a Power Pages site.

	 <script v2 id="Microsoft_Omnichannel_LCWidget" src="https://oc-cdn-public-ind.azureedge.net/livechatwidget/scripts/LiveChatBootstrapper.js" data-app-id="4bf2da1c-da35-4f74-a4e1-6ad1cd38" data-lcw-version="prod" data-org-id="2c7dff01-f845-e1-8e4c-002248d5c5d3" data-org-url="https://m-2c7dff01-f845-ef11-8e4c-002248d5c5d3.in.omnichannelengagementhub.com"></script>

The complete HTML Code used in the Power Pages is shared below :

   <meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>US Farming Information Hub</title><link rel="stylesheet" href="styles.css">
<div class="container">
  <div class="main-column">
    <header class="header">
      <div class="header-content">
        <img src="/restaurant.png" alt="Header Image" class="header-img">
        <div class="header-text">
          <h1>Gourmet Dining Hub</h1>
          <p>Your one-stop destination for all gourmet dining experiences</p>
        </div>
      </div>
    </header>
    <main class="main-content">
      <section class="card-row">
        <section id="farming-queries" class="card">
          <h2>Our Menu</h2>
          <p>Explore our extensive menu with a variety of dishes curated by our top chefs. Find the best meals to satisfy your cravings.</p>
          <img src="/menu.png" alt="Farming Queries" class="responsive-img">
        </section>
        <section id="weather" class="card">
          <h2>Reservations</h2>
          <p>Book a table at our restaurant easily through our online reservation system. Ensure you have a spot at our popular dining times.</p>
          <img src="/booking.png" alt="Weather" class="responsive-img">
        </section>
      </section>
      <section class="card-row single-card">
        <section id="loans" class="card">
          <h2>Special Offers</h2>
          <p>Discover our special offers and discounts. Enjoy gourmet dining at the best prices with our exclusive deals.</p>
          <img src="/offer.png" alt="Loans" class="responsive-img">
        </section>
      </section>
    </main>
  </div>
  
  <div class="sidebar">
    <div class="farmerAssistant">
      <h2 class="farmerAssistant-title"></h2>
      <div>
        <script v2 id="Microsoft_Omnichannel_LCWidget" src="https://oc-cdn-public-ind.azureedge.net/livechatwidget/scripts/LiveChatBootstrapper.js" data-app-id="4bf2da1c-da35-4f74-a1-6adfcd38" data-lcw-version="prod" data-org-id="2c7dff01-f845-ef11-8e4c-002248d5c5d3" data-org-url="https://m-2c7dff01-f845-ef11-8e4c-002248d5c5d3.in.omnichannelengagementhub.com"></script>

      </div>
    </div>
  </div>
</div>
<div class="row sectionBlockLayout text-left" style="display: flex; flex-wrap: wrap; margin: 0px; min-height: auto; padding: 8px;">
  <div class="container" style="padding: 0px; display: flex; flex-wrap: wrap;"><div class="col-md-12 columnBlockLayout" style="flex-grow: 1; display: flex; flex-direction: column; min-width: 250px; word-break: break-word;"></div></div>
</div>

The complete CSS used in the Power Pages is shared below :

   body {
    background-color: #f0f0f3;
    font-family: 'Arial', sans-serif;
    margin: 0;
    padding: 0;
    display: flex;
    justify-content: center;
    align-items: stretch; /* Stretch to fill the full height */
    min-height: 100vh;
    height: 100vh; /* Ensure the body takes full height */
}

.container {
    display: flex;
    width: 100%;
    height: 100%;
    background: #e0e0e0;
    box-shadow: 20px 20px 60px #bebebe, -20px -20px 60px #ffffff;
}

.main-column {
    flex: 3;
    display: flex;
    flex-direction: column;
    align-items: center;
    padding: 20px;
}

.sidebar {
    flex: 1;
    display: flex;
    flex-direction: column;
    justify-content: flex-start;
    background: #e0e0e0;
    padding: 20px;
    height: 100%;
}

.header {
    display: flex;
    justify-content: center;
    align-items: center;
    padding: 20px;
    background: #e0e0e0;
    border-radius: 20px;
    box-shadow: inset 10px 10px 20px #bebebe, inset -10px -10px 20px #ffffff;
    width: 100%;
    margin-bottom: 10px;
}

.header-content {
    display: flex;
    align-items: center;
}

.header-text {
    text-align: center;
    margin-left: 20px;
}

.header h1 {
    margin: 0;
    font-size: 2.5em;
    color: #333;
}

.header p {
    margin: 10px 0 0;
    font-size: 1.2em;
    color: #666;
}

.header-img {
    width: 110px;
    height: auto;
    border-radius: 10px;
}

.main-content {
    width: 100%;
    flex-grow: 1; /* Make sure the content takes the remaining space */
}

.card-row {
    display: flex;
    justify-content: space-between;
    width: 100%;
    margin-bottom: 10px;
}

.single-card {
    display: flex;
    justify-content: center;
    width: 100%;
}

.card {
    background: #e0e0e0;
    border-radius: 20px;
    box-shadow: 20px 20px 60px #bebebe, -20px -20px 60px #ffffff;
    padding: 15px;
    width: 48%;
    text-align: center;
    margin-bottom: 10px;
}

.single-card .card {
    width: 50%;
}

.card h2 {
    font-size: 24px;
    color: #333;
    margin-top: 0;
}

.card p {
    font-size: 1.1em;
    color: #666;
}

.responsive-img {
    margin: auto;
    width: 110px;
    height: auto;
    border-radius: 10px;
    margin-top: 10px;
}

.footer {
    display: none;
}

.copilot-container {
    width: 100%;
    height: calc(100vh - 60px); /* Adjust height to fit within the sidebar */
    border-radius: 10px;
    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
}

.farmerAssistant-title {
    font-size: 26px;
    text-align: center;
}

.navbar {
    display: none !important;
}

Lets preview the Power Pages Site and interact with the Copilot by submitting a negative feedback
As we can see the negative feedback has been identified the Azure AI Language Service and has escalated and handed it over to the human agent
The human agent will receive the notification in the customer service workspace where he can accept the conversation that has come to his queue.
Human agent can now start conversing with the customer asking for the details of the incident
The customer can now provide detailed feedback report which will be attended to by the customer executive
The customer service center receives all the conversations from the customer in real time and this helps in establishing a proper escalation process in the feedback system
Conclusion

Thus we have successfully created a dynamic customer service Copilot that leverages AI to analyze user feedback and handle it efficiently. This Copilot not only improves customer satisfaction by quickly addressing negative feedback but also streamlines the process of storing positive feedback.

Cafeteria Feedback Copilot that uses AI Prompt Action for Sentiment Analysis

Thu, 21 Aug 2025 17:31:35 +0530

Introduction
Process Flow
Prerequisites
Demo
Summary

Introduction

In this blog, we will walk through the process of creating a custom Cafeteria Feedback Copilot using Copilot Studio. This Copilot will analyze user feedback using the AI Prompt action, perform sentiment analysis, automatically escalate negative feedback, and store positive feedback in Dataverse.

Process Flow

User Interaction: The user initiates the conversation with the Copilot by providing feedback about the cafeteria.
Automatic Topic Selection: Based on the user’s input, the Copilot automatically detects the relevant topic and directs the conversation accordingly.
Feedback Collection: The user is presented with an adaptive card to input specific details such as the date and their feedback.
Sentiment Analysis: Once the feedback is submitted, the Copilot uses an AI Prompt action to analyze the sentiment of the feedback in real-time.
Action Based on Sentiment:
- Negative Feedback: If the sentiment is negative, the feedback is escalated to the concerned team via email, and the details are logged in Dataverse.
- Positive Feedback: If the sentiment is positive, the feedback is simply logged in Dataverse.
User Confirmation: The user receives a confirmation message indicating the action taken on their feedback.

This process ensures a seamless and responsive interaction where the user’s feedback is promptly analyzed and acted upon.

Prerequisites

Access to Copilot Studio.
Dataverse configured for storing feedback.
AI Builder Credits for using AI Prompt Action
Images stored in a location like Azure Blob Storage which can be used in Adaptive Cards

Demo

Watch the demo video below to see how the Smart Feedback Analyzer works.

Step 1 : Create the Dataverse Table

We will be storing the positive and negative feedbacks in the dataverse table named RestaurantFeedbacks which contains the columns Feedback,Feedback Date,Sentiment

Step 2: Create the Custom Copilot

Head over to Copilot Studio and click on Create.
You will have the option to create a copilot based on an existing template or create a blank copilot from scratch. Let’s select New copilot.
This will take you to the page where you can:
1. Describe the copilot functionality and provide any specific instructions.
2. Click on Create to provision the copilot.

Step 3: Enable Generative Selection of Topics

The copilot is now created. Next, we need to make some configuration changes.
1. Click on Edit to update the copilot’s name, icon, and description.
2. Click on Settings to enable the Generative selection of topics so that topics are auto-selected based on user conversations, resulting in a smoother user experience.
To enable the automatic detection of topics from user interaction:
1. Click on Generative AI.
2. Select Generative.
3. Click on Save to update the settings.
4. Click on the Close icon to return to the home page of this custom copilot.

Step 4: Create Topics

Now, let’s go ahead and create the topics that will automatically redirect the conversation flow to appropriate topics based on the user’s questions.
1. Click on Topics from the navigation menu.
2. Click on Add a Topic.
3. You can either create a blank topic or use Copilot to create the topic with an initial set of prepopulated conversation nodes based on the topic description.Select Create from description with Copilot.
Let’s provide the topic description details in the pop-up that appears.

Click on Create to provision the topic skeleton based on the provided description.

Thus, we have the basic topic created with an automatic trigger. Now, let’s add an adaptive card to accept the user input, such as feedback date and cafeteria feedback.

We will add the below adaptive card JSON schema to the Adaptive Card Node Properties as shown below.

 {
     "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
     "type": "AdaptiveCard",
     "version": "1.4",
     "backgroundImage": {
         "url": "https://adaptivecardsbot.blob.core.windows.net/imagestore/108265.jpg",
         "fillMode": "cover",
         "horizontalAlignment": "center",
         "verticalAlignment": "center"
     },
     "body": [
         {
             "type": "Container",
             "backgroundColor": "#E0FFFF",
             "items": [
                 {
                     "type": "ColumnSet",
                     "columns": [
                         {
                             "type": "Column",
                             "width": "auto",
                             "items": [
                                 {
                                     "type": "Image",
                                     "url": "https://adaptivecardsbot.blob.core.windows.net/imagestore/cafeteria.png",
                                     "size": "Small",
                                     "horizontalAlignment": "Left"
                                 }
                             ]
                         },
                         {
                             "type": "Column",
                             "width": "stretch",
                             "items": [
                                 {
                                     "type": "TextBlock",
                                     "text": "Cafeteria Food Feedback",
                                     "weight": "Bolder",
                                     "size": "Large",
                                     "wrap": true,
                                     "horizontalAlignment": "Left",
                                     "color": "Default",
                                     "spacing": "Medium"
                                 }
                             ]
                         }
                     ]
                 }
             ],
             "style": "emphasis",
             "bleed": true,
             "spacing": "None"
         },
         {
             "type": "TextBlock",
             "text": "Please provide your feedback for the food served today.",
             "wrap": true,
             "weight": "Bolder",
             "color": "Good",
             "spacing": "Medium"
         },
         {
             "type": "TextBlock",
             "text": "Date",
             "weight": "Bolder",
             "wrap": true,
             "spacing": "Small"
         },
         {
             "type": "Input.Date",
             "id": "feedbackDate",
             "placeholder": "dd-mm-yyyy"
         },
         {
             "type": "TextBlock",
             "text": "Your Feedback",
             "weight": "Bolder",
             "wrap": true,
             "spacing": "Small"
         },
         {
             "type": "Input.Text",
             "id": "feedbackText",
             "isMultiline": true,
             "placeholder": "Enter your feedback here...",
             "maxLength": 500
         }
     ],
     "actions": [
         {
             "type": "Action.Submit",
             "title": "Submit Feedback"
         }
     ],
     "style": "default"
 }

As we can see, the user inputted values for date and feedback are stored in the feedbackDate and feedbackText variables, which we will use later.

Step 5: Add AI Prompt Action

Now, let’s add the AI Prompt action:
1. Select Call an action.
2. Click on Basic Actions.
3. Select Create a prompt.
This will open a pop-up window where we can define the prompt. We will:
1. Provide a name for the prompt (e.g., Cafeteria Feedback Analyzer) so that we can later select it by this name.
2. Create an input with the name Feedback so that we can dynamically pass the user input to this variable.
3. Add the prompt that will analyze the feedback in the Prompt section and click on Insert to add the Feedback variable to the prompt.
4. Click on Save custom prompt to make it available in the Copilot canvas.
Now we can add the prompt to the conversation flow by selecting its name:
1. Select Call an action.
2. From Basic Actions, search for the recently created prompt by its name.
3. Select the Cafeteria Feedback Analyzer prompt.
Select the feedbackText variable, which contains the user inputted feedback, and assign it as the input to the Prompt action.
We will also define a variable (feedbackSentiment) to hold the output of the AI Prompt action so that we can check the sentiment of the user feedback and take action on it.

Step 6: Escalate Negative Feedback

Now, let’s add a condition to check whether the feedback analyzed by the AI Prompt action is negative or positive by adding the condition node.
Since feedbackSentiment is a record variable, we need to get the feedbackSentiment.text property, which contains the feedback analysis value. We will then check if it is negative and, if so, escalate the feedback to the concerned users.
To escalate the feedback, let’s add an Office 365 Mail action:
1. Select Call an action.
2. From the Connector tab, search for Office 365 Mail connectors.
3. Select Send an email (V2) action.
Now, configure the Office 365 Mail connector:
1. Set the To and Escalation Subject fields.
2. In the Body, add the mail content and concatenate it with the user feedback present in the feedbackText variable using the Concatenate expression.
3. Add an output variable to the Connector action.

Step 7: Save Feedback to Dataverse

Once escalated, let’s save the negative feedback to the Dataverse backend using the Connector action:
1. Select Call an action.
2. From the Connector actions tab, search for the Dataverse connector.
3. Select the Add a new row to the selected environment connector.
Now, configure the Dataverse connector action:
1. Set the environment and table name.
2. Select the feedbackText variable, which contains the User Feedback.
3. Select Advanced inputs to add the remaining data that needs to be saved.
Add additional inputs like Feedback Date and Feedback Sentiments retrieved from the AI prompt action to save them to Dataverse.
We will also add an image to provide the user confirmation that the feedback has been escalated to the concerned individuals.
In the positive branch of the condition, let’s repeat the same steps to save the positive feedback to Dataverse:
1. Select Call an action.
2. From the Connector actions tab, search for the Dataverse connector.
3. Select the Add a new row to the selected environment connector.
Now, configure the Dataverse connector action:
1. Set the environment and table name.
2. Select the feedbackText variable, which contains the User Feedback.
3. Select Advanced inputs to add the remaining data that needs to be saved.
Add additional inputs like Feedback Date and Feedback Sentiments retrieved from the AI prompt action to save them to Dataverse.
We will also add an image to provide the user confirmation that the feedback has been saved.

Step 8: Publish the Copilot

We have now completed the Copilot development. Let’s deploy this in Teams so that employees can start using it.
1. Select Channels and select Microsoft Teams.
2. Select Turn on Teams to enable Teams publishing channel.
Now we have the option to edit the Copilot icon, details, and description that will be shown in Teams. Once done, Click on Availability options.
We have different ways to publish the Copilot to Teams. We can download and upload the Zip to use the Copilot as a personal app, but we will publish it to the whole organization.
Select Submit for admin approval so that the app can be approved by the admin from the Teams admin center.
We can see that the app has come up for approval in the admin center. Let’s approve it.
It would take some time for the app to be globally published. Once available, let’s search for the app from the Teams store and add it for our use.
We will initiate the conversation with the copilot, and it provides the adaptive card for providing the feedback details.
The feedback has been submitted, and we get a success message indicating the escalation process has been initiated.
If we head to the Dataverse, we can see that the feedback has been logged.
We can also see that the escalation mail has reached the concerned team.
Now, let’s test with positive feedback.
The feedback has been submitted, and we get a positive feedback success message.
If we check Dataverse, we can see that the positive feedback has also been logged.

Summary

In this blog, we have walked through the process of developing a Cafeteria Feedback Copilot that uses AI Prompt action to perform sentiment analysis on the fly and take appropriate actions based on the sentiment. This copilot can be a powerful tool for automating feedback analysis and ensuring prompt responses to user feedback in an organization.

Building a Sales Analyzer Copilot using Dataverse and Llama Model in Azure AI Studio

Tue, 19 Aug 2025 17:31:35 +0530

Introduction
Llama Model
Understanding the Use Case
Prerequisites
Demo
Step 1: Preparing Your Dataverse Environment
Step 2: Setting Up Azure AI Studio
Step 3: Create the Copilot in Copilot Studio
Step 4: Enable Generative selection of topics
Step 5 : Create Topics
Step 6: Add an HTTP Request for Llama Model
Step 7: Configure the HTTP Request
Step 8: Add Header Properties
Step 9: Add the Body to the Request
Step 10: Display the Generative Answer
Step 11: Test the Copilot
Conclusion

Introduction

Integrating cutting-edge AI models, such as the Llama model, with robust platforms like Azure AI Studio and Microsoft Dataverse, offers a sophisticated yet easy to build solution for analyzing sales data. This powerful combination allows businesses to transform raw data into meaningful insights and respond promptly to user queries.

In this blog, we will explore how to leverage the Llama model within Azure AI Studio, alongside Microsoft Copilot, to read and analyze sales data stored in Dataverse. We will guide you through setting up this integration to create a system that efficiently processes user questions and delivers insightful answers directly from your sales data.

Llama Model

Llama (Large Language Model for AI) is a groundbreaking language model from Meta AI designed to understand and generate human-like text. It’s adept at processing natural language inputs and can provide contextually relevant responses. When integrated with Azure AI Studio, Llama becomes a formidable tool for interpreting and analysing data, allowing businesses to address user queries with precision and depth.

Understanding the Use Case

Use Case Overview: We aim to build a system that allows users to query their sales data stored in Dataverse using natural language. This system will utilize the Llama model to understand and process these queries and Microsoft Copilot to facilitate interactive conversations.

The control flow is as follows :

User Queries: User asks sales-related questions to the Copilot.
Data Retrieval: Copilot fetches Q1 sales data from the Sales Information Table in Dataverse.
Llama Model Analysis: Copilot sends the data to the Llama model in Azure AI Studio for analysis.
Generate Response: Llama model analyzes the data and generates a contextual response.
Display Answer: Copilot displays the generated response to the user.

Prerequisites

To successfully implement this solution, you will need:

Azure Subscription: Access to Azure AI for configuring the Llama model.
Copilot Studio: Access to copilot studio to build custom copilots.
Dataverse Environment: Structured and accessible sales data within Dataverse.

Demo

Watch the demo video below to see how the Sales Analysis Copilot works.

Step 1: Preparing Your Dataverse Environment

Start by ensuring your sales data is well-structured and available in Dataverse. We have created a table named “Q1 Sales Data” which contains the First quarter sales details for 4 companies .

Step 2: Setting Up Azure AI Studio

Azure AI Studio will be used to develop, train, and manage the Llama model. So as to work with the AI studio, we need to first create an instance of AI Services which we can do by navigating to the Azure AI Services in the azure portal .

Click on Create.
Specify the Resource Group, Name and other details for the AI Services instance . Click on Review+Create which will run the validation and create the AI Services instance for us.
Head over to the newly created Azure AI Services instance and click on Goto Azure AI Studio.
Once we are in Azure AI Studio , we can create an AI Hub which will act as a top level container for all resources created in the AI Studio. Click on New hub.
Specify the details like Name, Subscription, Resource group, Location and the AI Service Instance name. Click on Next.
Click on Create to provision the AI Hub.
We can see that the AI hub is created, Within the hub lets create a project as well so that we can compartmentalize different model deployments to different projects. Click on New Project.
Let’s provide a Project Name and click on Create a Project.
Now that the AI Hub and Project is created , lets select the Model catalog from the left pane. Azure AI Studio offers a diverse range of AI models tailored to meet various business needs and enhance data analysis capabilities.

For this demo, we will be deploying an instance of the Meta Llama 3 - 8 B model where 3 stands for the version number of the model and 8 B refers to the number of parameters in the model, which is 8 billion. Parameters are the components of the model that get adjusted during training to learn patterns from the data. Let’s select this model.
Click on Deploy to create the instance of the selected Llama model.
We can choose to have Azure AI Content safety filters along with the model which would incur charges through Azure AI Content Safety services. However, this is optional.
Ensure that you have selected the recently created project , Select Subscribe and Deploy.
Specify the Deployment name and click on Deploy to finalize the deployment of the model.
It would take some time for the model deployment to complete. Once done,
1. In the deployments left side pane, we can see that the Provisioning State is succeeded.
2. We will copy the Key value as it is needed for authentication from copilot
3. We will now click on consume tab so as to copy the REST endpoint for this model.
In the consume tab,
1. Copy the REST endpoint which we will use for invoking the model from the copilot.
2. There is also samples of how the input prompt for Llama model looks like which we can follow while creating the prompt in copilot.

Step 3: Create the Copilot in Copilot Studio

Head over to Copilot Studio and
1. Click on Create.
2. This will provide us the option to create a copilot based on an existing template on create a blank copilot from scratch, Lets select New copilot.
This will take us to the page where we can
1. Describe the copilot functionality and provide any specific instructions to the copilot.
2. Once done, click on Create to provision the copilot.

Step 4: Enable Generative selection of topics

The copilot is now created. We can then make the needed configuration changes
1. Click on Edit, edit the copilot details like name, icon and description.
2. Click on Settings to enable the Generative selection of topics so that without relying on triggers, the topics will be auto selected based on user conversation resulting in a much smoother user experience.
To enable the automatic detection of topics from user interaction:
1. Click on Generative AI.
2. Select Generative(preview).
3. Click on Save to update the settings.
4. Click on Close icon to go back to the home page of this custom copilot.

Step 5 : Create Topics

Now let’s go ahead and create the topics that will automatically redirect the conversation flow to appropriate topics based on the question user posts.
- Click on Topics from the navigation menu.
To add the topic, we can either go with the option to create a blank topic or use Copilot to create the topic with initial set of prepopulated conversation nodes based on the topic description that we provide.
- Let’s Click on Add a Topic and
- Select Create from description with Copilot.
Let’s provide the below topic description details in the pop up that opened when we clicked the Add topic button previously. Then, Click on Create, which will provision the topic skeleton based on the provided description.
Thus, we have the basic topic created with an automatic trigger as well as a question to the user which are generated using the description provided.
Now lets add the dataverse connector action which will fetch the Q1 Sales data information from the table.
1. Select Call an action.
2. From the Connector tab, select List rows from selected environment.
Create the connection and Click on Submit.
We can now configure the Dataverse connection by
1. Selecting the Environment and Table.
2. Mention the logical name of the columns to be retrieved.
We can see that the output of the Dataverse connector action is a table, and we need to define a variable to hold the table data. For this we will
1. Select the right arrow against the value field and
2. Click on Create a new variable and name it as varSalesTable.
The output of the Dataverse Table Connector(varSalesTable) will contain lots of system columns as well . We will need to format the table to filter and ensure only the needed columns are present. To do this let’s initialize a variable(varSalesDetails) to hold the new filtered output of the Dataverse connector.
We will then add the below formula which will filter the output to create a subset of the table and store it in the variable. It does this by looping through the previous Dataverse connector output and fetching only the columns that we have mentioned in the expression.
```
ForAll(
    Topic.varSalesTable,
    {
        Month: ThisRecord.cr06f_month,
        Product: ThisRecord.cr06f_product,
        SalesAmount: ThisRecord.cr06f_salesamount
    }
    )
```
If we were to test and output this variable(varSalesDetails) value in the test pane, we will get the table output as :
```
[{“Month”:“January”,“Product”:“AeroFusion Blender”,“SalesAmount”:7500},
{“Month”:“January”,“Product”:“SolarX PowerPack”,“SalesAmount”:6200},
{“Month”:“January”,“Product”:“QuantumLight Glasses”,“SalesAmount”:5600}]
```
We will do one more formatting of this output to serialize this table into a string readable format as shown below < Month >: < Product >: < Sales Amount > . The reason for doing this is because the LLM input should be a string and hence the table has to be serialized to the string format.
```
January:AeroFusion Blender:7500, 
January:SolarX PowerPack:6200, 
January:QuantumLight Glasses:5600, 
January:EcoWave Cleanser:4300, 
February:AeroFusion Blender:8100, 
February:SolarX PowerPack:5900, 
February:QuantumLight Glasses:6300,
```
To do this, lets add another variable(varSerializedSalesData) and set its formula to
```
Concat(Topic.varSalesDetails, Month & ":" & Product & ":" & SalesAmount, ", ")
```
This way, from the previous filtered table, we will concat the Product and sales details in the readable string format which can be shared as an input to the Llama Prompt

Step 6: Add an HTTP Request for Llama Model

Now let’s add an HTTP Request so that we can call the Llama deployment endpoint in Azure AI Studio.

Step 7: Configure the HTTP Request

Paste the REST URL we copied from azure ai studio to the URL field.
Change the Method to POST.
Click on Edit to update the Header and Body.

Step 8: Add Header Properties

This will open up the HTTP Request Properties pane where :
1. We will click on Add so that it adds a Key Value Pair field section
2. Add the Authorization text to the Key and Bearer {Key copied from Azure AI Studio} to the value field
We have to add one more header property
1. Click on Add once again so that we can add the next Key Value Pair
2. Add the Content-Type text to the Key and application/json to the value field

Step 9: Add the Body to the Request

Now we have to add the Body which is the Llama prompt to the Request for which we will
1. Click on the Body field and
2. Select JSON Content.
This will open up the JSON/Formula box just below the body field. If we were sending a static text as body, we could have selected JSON. But since, we need to dynamically pass the user query as well into the prompt,we will select Formula.
We can now add the prompt by concatenating the User query along with the Dataverse table sales data and passing it to the content attribute of the prompt. The role attribute indicates that this message is an input from the user. Thus we have created the prompt as expected by Llama. Now lets head back to the copilot designer and define the response data type.

We will now configure the response data type field by :

Clicking the right arrow and
Select From sample data.

In general the output of Llama 3 would look like below:

     {
         "choices": [
             {
                 "finish_reason": "stop",
                 "index": 0,
                 "logprobs": null,
                 "message": {
                     "content": "Output Text",
                     "role": "assistant",
                     "tool_calls": null
                 },
                 "stop_reason": 128009
             }
         ],
         "created": 1718285835,
         "id": "cmpl-7443f01686d24a52924850b34655bf22",
         "model": "Meta-Llama-3-8B-Instruct",
         "object": "chat.completion",
         "usage": {
             "completion_tokens": 108,
             "prompt_tokens": 51,
             "total_tokens": 159
         }
     }

Lets add this sample output data by clicking on Getting schema from sample JSON.
1. Paste the above JSON Output content and
2. Click on Confirm.
3. We will add a variable named varLlamaOutput to hold the returned output value which is of record datatype.

Step 10: Display the Generative Answer

Finally lets show the generative answer result from the Llama model as a basic card. As we can see in the output schema, the generative answer will be present in the content key value pair which is nested within the choice and message parent . We will get this output using the Power Fx formula:

	First(Topic.varLlamaOutput.choices).message.content

Thus we have completed the creation of the copilot which will invoke Llama model to helps us derive meaningful insights from the Q1 Sales Data present in the dataverse table.

Step 11: Test the Copilot

Lets test the copilot by initiating the conversation. We will ask few sales related questions to the copilot.

We will also try to ask a bit more complex question which involves calculating the cumulative sales across different records and we can see that Llama has intelligently provided us back with the contextual response.

Conclusion

By following these steps, you can successfully leverage the Llama model within Azure AI Studio and Microsoft Dataverse to create a system that efficiently processes user questions and delivers insightful answers from your sales data. This integration not only enhances data analysis capabilities but also provides a seamless and interactive user experience through Microsoft Copilot. With the power of AI, businesses can now make informed decisions based on real-time data insights, driving growth and innovation.

Creating a Meal and Fitness Advisor Using Google Gemini API and Copilot

Fri, 15 Aug 2025 17:31:35 +0530

Introduction
User Interaction Process Flow
Technologies Involved
Prerequisites
Demo
Step 1: Get the Gemini API Key
Step 2: Create a Custom Connector in Power Automate
Testing the Connector
Step 3: Create Copilot
Step 4: Enable Generative Selection of Topics
Step 5: Create Topics
Step 6: Create the Prompt and Assign it to the Variable
Step 7: Add the Google Gemini Custom Connector as an Action
Test the Copilot
Conclusion

Introduction

In this blog, we will explore how to create a custom connector for the Google Gemini API in Microsoft Power Platform and use it within Copilot to build a dynamic Meal and Fitness Advisor. This process leverages advanced AI capabilities to generate personalized recommendations based on user inputs such as meal preferences and fitness goals.

The user can ask personalized Meal and Fitness plan and the Copilot will use Google Gemini API connector to provide back the contextual plan back to the user.

User Interaction Process Flow

The overall process flow will be as follows :

User Query: User asks the Copilot for a personalized meal and fitness plan.
Query Formatting: Copilot formats the user’s query and sends it to the Google Gemini Custom Connector.
Response Generation: Google Gemini API generates a contextual meal and fitness plan based on the user’s inputs.
Response Handling: The response is sent back to the Copilot.
User Interaction: User views the personalized meal and fitness plan and continues the conversation.

Technologies Involved

Google Gemini API: Used for generating personalized content based on user inputs.
Microsoft Power Automate: To create a custom connector that interacts with the Google Gemini API.
Copilot Studio: To create and manage the Copilot bot.
Microsoft Teams: The platform where the Copilot will be deployed and used.

We will follow these steps to achieve our goal:

Obtain the API key from Google AI Studio.
Create a custom connector to interact with the Google Gemini API.
Develop a Copilot in Copilot Studio that utilizes this custom connector to get the personalized Meal and Fitness Plan.

Prerequisites

Access to the Google Gemini API and API keys.
Access to Microsoft Power Automate and Copilot Studio.

Demo

Watch the demo video below to see how the Meal and Fitness Plan Advisor Copilot works.

Step 1: Get the Gemini API Key

Head over to the Google AI Studio and get your API key by clicking on Create API Key, which can be used to authenticate the Google Gemini API.

Step 2: Create a Custom Connector in Power Automate

Head over to Power Automate and from the Discover menu, select Custom Connectors.
Click on New custom connector and select Create from blank to provision a connector from scratch.
Mention the API connector name as Google Gemini Generate Content in the pop-up and click on Next.
This will open the editor where we can toggle the swagger editor and paste the below swagger file content that we have defined for the Text Generation endpoint.

swagger: '2.0'
info:
  title: Google Gemini
  description: >-
    Custom connector for Google Gemini, providing advanced AI multi modal
    content generation functionalities.Gemini is a family of multimodal large
    language models developed by Google DeepMind, serving as the successor to
    LaMDA and PaLM 2. Comprising Gemini Ultra, Gemini Pro, and Gemini Nano, it
    was announced on December 6, 2023
  version: '1.0'
  contact:
    name: Fusion Dev Consulting
x-ms-connector-metadata:
  - propertyName: Website
    propertyValue: https://ai.google.dev/
  - propertyName: Privacy policy
    propertyValue: https://policies.google.com/privacy
  - propertyName: Categories
    propertyValue: AI
host: generativelanguage.googleapis.com
basePath: /
schemes:
  - https
produces:
  - application/json
consumes:
  - application/json
securityDefinitions:
  API Key:
    type: apiKey
    in: query
    name: key
security:
  - API Key: []
paths:
  /{apiVersion}/models/{modelName}:generateContent:
    post:
      summary: Generate text content
      description: Generates a text response from the model given an input message.
      operationId: GenerateTextContent
      parameters:
        - in: path
          name: apiVersion
          x-ms-summary: API Version
          x-ms-url-encoding: single
          required: true
          type: string
          default: v1beta
          description: API version to use for the endpoint. Eg- v1beta
        - in: path
          name: modelName
          x-ms-summary: Model Name
          x-ms-url-encoding: single
          required: true
          type: string
          default: gemini-pro
          description: Name of the model to be used for text generation. Eg - gemini-pro
        - in: body
          name: body
          required: true
          schema:
            type: object
            properties:
              contents:
                type: array
                x-ms-summary: Contents
                description: Contents for generating the text response.
                items:
                  type: object
                  required:
                    - parts
                  properties:
                    role:
                      type: string
                      x-ms-summary: Role
                      default: user
                      description: >
                        Optional. The producer of the content. Must be either
                        'user' or 'model'
                    parts:
                      type: array
                      x-ms-summary: Parts
                      description: Parts of the content for text generation.
                      items:
                        type: object
                        required:
                          - text
                        properties:
                          text:
                            type: string
                            x-ms-summary: Text
                            description: Required.Text for generating the response.
              safetySettings:
                type: array
                x-ms-summary: Safety Settings
                description: Optional.Safety settings for text content generation.
                items:
                  type: object
                  properties:
                    category:
                      type: string
                      x-ms-summary: Category
                      description: Optional.The category of content to be filtered.
                    threshold:
                      type: string
                      x-ms-summary: Threshold
                      description: >-
                        Optional.The threshold for filtering content in the
                        specified category.
              generationConfig:
                type: object
                properties:
                  maxOutputTokens:
                    type: integer
                    x-ms-summary: Max Output Tokens
                    description: >-
                      Optional.The maximum number of tokens to include in a text
                      candidate.
                  temperature:
                    type: number
                    x-ms-summary: Temperature
                    description: Optional.Controls the randomness of the text output.
                  topP:
                    type: number
                    x-ms-summary: Top P
                    description: >-
                      Optional.The maximum cumulative probability of tokens to
                      consider when sampling.
                  topK:
                    type: integer
                    x-ms-summary: Top K
                    description: >-
                      Optional.The maximum number of tokens to consider when
                      sampling.
                  candidateCount:
                    type: integer
                    x-ms-summary: Candidate Count
                    description: Optional. Number of candidate responses to generate.
                  stopSequences:
                    type: array
                    x-ms-summary: Stop Sequences
                    description: >-
                      Optional.The set of character sequences that will stop
                      text output generation.
                    items:
                      type: string
                      description: >-
                        Optional.The set of character sequences that will stop
                        text output generation.
      responses:
        '200':
          description: Successful text response
          schema:
            type: object
            properties:
              text:
                type: string
                description: The generated text response.
              candidates:
                type: array
                items:
                  type: object
                  properties:
                    content:
                      type: object
                      properties:
                        parts:
                          type: array
                          items:
                            type: object
                            properties:
                              text:
                                type: string
                    finishReason:
                      type: string
                    index:
                      type: integer
                    safetyRatings:
                      type: array
                      items:
                        type: object
                        properties:
                          category:
                            type: string
                          probability:
                            type: string
              promptFeedback:
                type: object
                properties:
                  safetyRatings:
                    type: array
                    items:
                      type: object
                      properties:
                        category:
                          type: string
                        probability:
                          type: string

Testing the Connector

We can use the in-built test functionality to ensure that your connector works correctly. To do this, click on Authorize and paste the Google API Key which we copied from the Google AI Studio into the field and click on Authorize.

Click on Try it out and paste the below text in the body. Here we are passing the query to find the capital of the United States in the body.

 {
   "contents": [
     {
       "role": "user",
       "parts": [
         {
           "text": "Capital of United States"
         }
       ]
     }
   ]
 }

Click on Execute to invoke the API and get back the contextual response from Google Gemini.
As we go down the editor, we can see that it has successfully fetched back the capital of the United States.
Now that we have created the connector using the swagger definition, let’s click on Create Connector.
The Google Gemini Generate Content Connector is now available for use within the Power Platform.

Step 3: Create Copilot

Head over to Copilot Studio and click on Create.
This will provide us the option to create a copilot based on an existing template or create a blank copilot from scratch. Let’s select New copilot.
This will take us to the page where we can:
1. Describe the copilot functionality and provide any specific instructions to the copilot.
2. Once done, click on Create to provision the copilot.

Step 4: Enable Generative Selection of Topics

The copilot is now created. We can then make the needed configuration changes:
1. Click on Edit, edit the copilot details like name, icon, and description.
2. Click on Settings to enable the Generative selection of topics so that without relying on triggers, the topics will be auto-selected based on user conversation resulting in a much smoother user experience.
To enable the automatic detection of topics from user interaction:
1. Click on Generative AI.
2. Select Generative (preview).
3. Click on Save to update the settings.
4. Click on the Close icon to go back to the home page of this custom copilot.

Step 5: Create Topics

Now let’s go ahead and create the topics that will automatically redirect the conversation flow to appropriate topics based on the question the user posts.
1. Click on Topics from the navigation menu.
To add the topic, we can either go with the option to create a blank topic or use Copilot to create the topic with an initial set of prepopulated conversation nodes based on the topic description that we provide.
1. Click on Add a Topic and
2. Select Create from description with Copilot.
Let’s provide the below topic description details in the pop-up that opened when we clicked the Add topic button previously. Then, click on Create, which will provision the topic skeleton based on the provided description.
Thus, we have the basic topic created with an automatic trigger as well as a few questions to the user which are generated using the description provided.
In addition to the meal preference, the questions around fitness goals and morbidities are also generated automatically, and responses are stored in respective variables which we will use down the line to pass to Google Gemini.

Step 6: Create the Prompt and Assign it to the Variable

Let’s create the prompt and assign it to the variable. For this, we will select Variable management -> Set a variable value.
We will create a new variable and name it as varPrompt.
We will be creating a table-structured prompt to send it to the Google Gemini Custom Connector. In the To value field, use the below concatenate formula to create a prompt which will contain the meal preference, fitness goals, and morbidities information.
```
 Table({role: "user", parts: [{text: Concatenate("Act as a Personalized Meal Advisor and Fitness Coach for a personal with the below morbidities: ", Topic.ExistingMorbidities, "The Meal Preferences are: ", Topic.MealPreference, ". Fitness Goals are: ", Topic.FitnessGoals)}]})
```
The table structure described in the prompt is used to format the input data for the Google Gemini API’s text generation endpoint.
- Role: This specifies who is providing the input. In this context, the role is set to “user,” indicating that the input is coming from the user of the system. This helps the AI model understand the perspective or the context from which the content is generated.
- Parts: This is an array containing the actual content to be processed by the AI model. Parts will contain the actual prompt that describes the context and what is expected as a response from the model.
Once the formula is added to the box, click on Insert.

Step 7: Add the Google Gemini Custom Connector as an Action

Now that the prompt is ready, let’s add the Google Gemini custom connector as an action.
As we add the connector, it will ask to create a connection. Click on Create.
Add the connection name and paste the Google API Key copied from Google AI Studio. Click on Create and then Submit.
Let’s configure the Google Gemini custom connector with the needed input values.
- Specify the API Version as v1beta.
- Mention the model name as gemini-pro.
- For the Contents field, select the varPrompt variable that we had created earlier.
We can see that the generative output of the connector is stored in the variable text.
Now let’s add a basic card and show the text output back to the user.

Test the Copilot

We have published the bot and will distribute it to Microsoft Teams by submitting it to the admin for approval.

Admins can now publish this to the organization from the Teams admin center.

The Meal and Fitness Coach has now become available in the Teams app store which we can start using.We have provided the basic information and preferences around the meal and fitness plan that we are looking at.

Google Gemini API is invoked through the custom connector, and we can see the detailed meal and fitness plan provided by the copilot.

Conclusion

In this blog, we explored how to create a custom connector for Google Gemini in Microsoft Power Platform and use it within Copilot to build a dynamic Meal and Fitness Advisor. By integrating advanced AI capabilities through this custom connector, we can generate personalized recommendations based on user inputs, such as meal preferences and fitness goals.

Power Apps FAQ Copilot built using Azure AI Search and Azure Open AI

Wed, 13 Aug 2025 17:31:35 +0530

Introduction
- Process Flow Explanation
Demo
Prerequisites
Step-by-Step Implementation
Conclusion

Introduction

Connecting data through Azure OpenAI Service within Microsoft Copilot Studio enables your Copilots to utilize Azure resources effectively via the Generative Answers node. Leveraging the robust capabilities of Azure AI Search and Azure OpenAI, these copilots can deliver responses that are both contextually relevant and compliant with your organization’s guidelines. In this blog we will see how to create a Power Apps FAQ copilot utilizing the official Microsoft PowerApps documentation PDF and leveraging the Azure AI Search and Azure Open AI.

Process Flow Explanation

The overall process flow that we will see in this explanation is as follows :

Power Apps Documentation : PDF is uploaded to Azure Storage account
Index the Document : Azure AI Search indexes the document for easy retrieval
User Interaction: A user initiates a query related to Power Apps via the Copilot interface.
Copilot Processing: The Copilot captures the user’s query and passes it as a prompt to the Azure OpenAI, which is configured as a datasource.
Grounding : Azure OpenAI processes the query using its generative capabilities, accessing the indexed Power Apps documentation stored in Azure AI Search.
User Display: The Copilot displays the contextual response to the user, providing accurate and detailed answers to their Power Apps-related queries.

This integration allows users to get precise answers to their queries by leveraging the power of Azure’s AI services, making it a valuable tool for enhancing productivity and knowledge access.

Demo

Watch the demo video below to see how the Power Apps FAQ Copilot works.

Prerequisites

If you are intending to implement, ensure you have the following:

An active Azure subscription.
Access to Microsoft Copilot Studio.
Power Apps Documentation PDF from Microsoft Learn site.

Step-by-Step Implementation

Step 1: Download the Power Apps Documentation

Head over to the Power Apps Documentation and download the PDF. We will index it using the Azure search service and use it to generate contextual answers to user queries around Power Apps.

Step 2: Create an Azure AI Search Instance

Navigate to the Azure Portal: Log in to the Azure portal, search for “AI Search,” and select the service.
Create a New Search Service: Click on Create to start setting up a new search service.
Fill in the necessary details like resource group, service name, location, and pricing tier. Once you’ve filled in the details, review your configurations and click Create.
After a while, the search instance will be provisioned and available for use.

Step 3: Add Blob Storage and Create an Indexer

Set Up Azure Blob Storage: Navigate to the Storage Accounts in the Azure portal and click on Create to add a new storage account.
Fill in the necessary details like resource group, storage account name, region, and performance. Click on Create to provision the storage account.
Once the storage account is created, head over to this resource and click on Container to create a new container to store the Power Apps PDF.
Click on Container, specify the container name, and click on Create to add the new container to the storage account.
Inside the container, click on Browse for files to add the Power Apps documentation PDF downloaded earlier. Click on Upload.
Navigate back to the Azure search instance that we created to index this PDF document. From the AI Search Overview page, click on Import data.
In the Connect your data tab, select Azure Blob Storage.
Specify a name for the datasource and click on Choose an existing connection to connect to the container within the storage account.
Select the appropriate container and click on Select.
The connection string is automatically added for this container. Click on Next: Add Cognitive Skills. This is optional and will be skipped for now.
Ensure the content field of the indexer is marked as Retrievable and Searchable. Click on Create an Indexer to create the index.
The indexer is now created, and we can connect this to Azure OpenAI for generative features.

Step 4: Create Azure OpenAI Instance

Navigate to Azure OpenAI: Head over to Azure, search for Azure OpenAI, and select the service.
Click on Create.
Specify the values for Resource Group, Name, and Pricing tier. Click on Next for network-specific configurations. Finally, click on Create on the review page.
The Azure OpenAI Instance is now created. Click on Go to Azure OpenAI Studio where we can configure and connect the OpenAI Instance with the Azure Search indexer.
In Azure OpenAI Studio, create a model deployment. From the Chat section, click on Create new deployment.
Specify the model type (e.g., gpt-4), mention the name, and click on Create.
The model is deployed. In the chat playground, click on Add your data to connect to the search index.
Select the data source.
In the opened pop-up:
- Select the data source as Azure AI Search.
- Mention the Search Instance and Search Index created earlier.
- Click on Next.
In the Data Management section, enable Keyword search. Semantic search is also an option that can be configured.
Select API Key as the Azure resource authentication type. Click on Next.
Finally, click on Save and close to finalize the data source setup.
Test the Azure OpenAI playground, which has its data source as Azure AI Search. For example, ask about Power Apps offline functionality, and it will fetch detailed contextual answers from the Azure AI search index.

Step 5: Integrate Copilot with Azure OpenAI Instance

Deploy to Copilot Studio: Click on Deploy to and select A new copilot in Copilot Studio.
Select Continue in Copilot Studio, which will take us to Copilot Studio to continue with the copilot creation.
Specify the copilot name and click on Create.
This initializes the copilot, which is already connected to the Azure OpenAI Instance.
Head over to topics and select the Conversational boosting system topic.
It contains a Generative answers node preconfigured with the Azure OpenAI instance set up earlier.
Click on the connection properties. Under the General tab, you can see the model details and parameters used for generating answers.
In the Model data tab, you can see the Azure AI Search data source and the field from which the data is grounded.
The copilot is auto-configured and connected to the Azure OpenAI instance, which is internally connected with the Azure AI Search Instance.

Step 6: Publish the Bot

We can publish the bot to different channels. For now, deploy it to Teams.
Head over to Channels -> Microsoft Teams -> Turn on Teams.
Click on Availability Options to choose how to distribute the app in Teams.
You can either deploy it to the app store through admin approval or upload the app as a zip and use it as a personal app.
The app becomes available in the Teams admin centre, and the admin can now publish it for org-wide use.
Access the app from the Teams App Store and start a conversation. Ask anything about Power Apps, and the copilot will fetch contextual answers from the grounded Power Apps Documentation PDF and provide responses.

Thus we have completed the implementation and demo of a scalable Copilot that can leverage Azure AI search and Azure Open AI to provide us with contextual answers for our questions.

Alternate Approach : Power Apps Documentation as Local Datasource

So far we explored how we can build a scalable Copilot using Azure AI search Index as the primary data source. Now lets see how we can implement the same using the native local datasource approach in Copilot. For this we can upload the same Power Apps PDF documentation as a Local File Knowledge base :

Once uploaded, depending on the size, the processing time varies and once ready we can see the status in the Knowledge section

We can now create a new Topic and add the Generative Answers node and connect to this knowledge source that we have uploaded.

We can test the Copilot’s ability to use the local knowledge source by initiating a conversation and asking questions and we can see that we are getting back the contextual response along with citations.

High Level Data Source Comparison : Azure AI Search vs SharePoint Vs Local File

Data Source	When to Use	Pros	Cons
Local File Upload	- Quick, simple setups	- Simplicity: Easy setup - Flexibility: User uploads as needed when creating a personal Copilot	- Limited Scope: Best for small-scale operations - Size: - 512 MB per file limitation - Manual Process: Requires user intervention every time the document has to be updated
SharePoint Documents	- Enterprise applications - Collaboration and document management - Regularly updated, accessible content	- Centralized Management: Easy to update the document from SharePoint - Version Control: Tracks document changes	- Complexity: As of writing, Manual authentication with App registration is required for authentication configuration
Azure OpenAI with Azure AI Search	- Complex searches across large datasets - Aggregation and analysis of unstructured data - Enterprise-level applications requiring AI-driven insights	- Powerful AI Capabilities: Combines NLU with robust search - Scalability: Handles large datasets - Advanced Features: Semantic and cognitive search	- Complex Setup: Requires more configuration - Cost: Different tiers have different storage limitations. Higher the tier, higher the cost

Conclusion

Integrating Azure OpenAI Service with Microsoft Copilot Studio opens up a lot of possibilities for creating intelligent, data-driven copilots. This guide has walked you through the process of setting up Azure AI Search, configuring Azure OpenAI, and seamlessly connecting these services in Copilot Studio. By harnessing the power of Azure’s AI capabilities, you can build copilots that provide rich, contextual responses tailored to your organizational needs. We also saw how the same Power Apps PDF documentation can be used as a Local Source Knowledge Data Source. Depending on the use case and complexity of search involved, we can use either of them as a source of generative answers.

Creating a Smart Supply Chain Vendor Selection Copilot with AI Prompt Actions

Sat, 09 Aug 2025 17:31:35 +0530

Introduction
Overview
Demo
Step-by-Step Guide to Building the Supply Chain Copilot

Introduction

Leveraging advanced technologies like Microsoft Power Platform can significantly enhance your supply chain operations. In this blog, we will explore how to create a Copilot for supply chain management that identifies the best vendor based on vendor details stored in Dataverse. This Copilot will utilize parameters like lead time, quality score, and unit price, and employ AI prompts to make intelligent vendor recommendations.

Overview

Our supply chain Copilot will:

Fetch Vendor Details from Dataverse: Retrieve data for multiple vendors, each providing the same product with different parameters.
Use AI to Identify the Best Vendor: Implement AI-powered analysis using the AI Prompt to find the most suitable vendor based on the retrieved data and parameters like lead time, quality score, and unit price.

Demo

Watch the demo video below to see how the Smart Supply Chain Copilot works.

Step-by-Step Guide to Building the Supply Chain Copilot

Step 1: Set Up Dataverse for Vendor Data

To begin, we need to organize our vendor details in Dataverse. Create a table named Vendor Details with the following columns:

Material Name: The name of the material or product (e.g., Aluminium Sheets, Copper Wires).
Vendor Name: The name of the vendor supplying the product.
Unit Price (Dollars): The cost per unit of the product.
Quality Score: A score representing the quality of the product (typically on a scale of 1-100).
Lead Time (Days): The time taken by the vendor to deliver the product.

Step 2: Populate the Dataverse Table

Enter the vendor details into the Dataverse table. We have the below data for the demo:

Step 3: Creating the Copilot in Copilot Studio

Head over to Copilot Studio and click on Create.

This will provide us the option to create a copilot based on an existing template or create a blank copilot from scratch. Let’s select New copilot.

This will take us to the page where we can:

Describe the copilot functionality and provide any specific instructions.
Click on Create to provision the copilot.

Step 4: Enable Generative Selection of Topics

The copilot is now created. We can then make the needed configuration changes:

Click on Edit, edit the copilot details like name, icon, and description.
Click on Settings to enable the Generative selection of topics so that without relying on triggers, the topics will be auto-selected based on user conversation resulting in a much smoother user experience.

To enable the automatic detection of topics from user interaction:

Click on Generative AI.
Select Generative (preview).
Click on Save to update the settings.
Click on the Close icon to go back to the home page of this custom copilot.

Step 5: Create Topics

Now let’s go ahead and create the topics that will automatically redirect the conversation flow to appropriate topics based on the question user posts.

Click on Topics from the navigation menu. To add the topic, we can either go with the option to create a blank topic or use Copilot to create the topic with an initial set of prepopulated conversation nodes based on the topic description that we provide.
Click on Add a Topic and
Select Create from description with Copilot.

Let’s provide the below topic description details in the pop-up that opened when we clicked the Add topic button previously. Then, Click on Create, which will provision the topic skeleton based on the provided description.

Thus we have the basic topic created with an automatic trigger as well as a question to the user which are generated using the description provided. We can now add more conversation nodes.

We now need to fetch the vendor details from the Dataverse table for which we will add the Dataverse connector action by:

Select Call an action.
Select the Connector tab.
Click on List rows from selected environment.

This will add the Dataverse connector action to the Copilot canvas. Let’s configure the inputs for this action by:

Mentioning the Environment and Table name where Vendor Details Table is present.
Click on Advanced inputs to filter the data that is returned from the table.

Specify the Dataverse table columns which should be present in the returned output. We will specify the Material name, Vendor name, Lead time, Unit Price, and Quality Score columns.

Note: You can get the logical name of the columns used in the Select columns field from the Dataverse table by following the below path:

The output of the Dataverse Table Connector (varVendorTable) will contain lots of system columns as well. We will need to format the table to filter and ensure only the needed columns are present. To do this, let’s initialize a variable to hold the output of Dataverse connector:

We will then add the below formula which will filter the output to create a subset of the table and store it in the variable. It does this by looping through the previous Dataverse connector output and fetching only the columns that we have mentioned in the expression:

ForAll(
    Topic.varVendorTable,
    {
        MaterialName: ThisRecord.cr06f_materialname,
        VendorName: ThisRecord.cr06f_vendorname,
        LeadTime: ThisRecord.cr06f_leadtimedays,
        Quality: ThisRecord.cr06f_qualityscore,
        UnitPrice: ThisRecord.cr06f_unitpricedollars
    }
)

If we were to test and output this variable value(varFilteredTable) in the test pane, we will get the output as:

[
    {"LeadTime":"5","MaterialName":"Aluminum Sheets","Quality":"92","UnitPrice":"35","VendorName":"PureAluminum"},
    {"LeadTime":"6","MaterialName":"Aluminum Sheets","Quality":"90","UnitPrice":"37","VendorName":"MetalSheetsCo"},
    {"LeadTime":"7","MaterialName":"Aluminum Sheets","Quality":"91","UnitPrice":"33","VendorName":"HighGradeAluminum"},
    {"LeadTime":"10","MaterialName":"Copper Wires","Quality":"93","UnitPrice":"60","VendorName":"ElectroCopper"},
    {"LeadTime":"9","MaterialName":"Copper Wires","Quality":"92","UnitPrice":"62","VendorName":"PureCopperSupplies"}
]

We will do one more formatting of this output to serialize this JSON into a readable format: Material Name: Vendor Name: Lead Time Days: Quality Score: Unit Price Dollars . To do this, let’s add another variable(varSerializedVendorDetails) and set its formula to:

Concat(Topic.varFormattedTable, MaterialName & ":" & VendorName & ":" & LeadTime & ":" & Quality & ":" & UnitPrice, ", ")

This way, from the previous filtered table, we will concat the Material Name and details in a readable format which can be shared as an input to the AI Prompt.

Step 6:Adding the AI Prompt

Now let’s add the AI prompt using which we can find the best vendor for the product specified by the user. To do this:

Select Call an action and
From Basic Actions, select Create a prompt.

This will open up the Prompt AI Builder in a pop-up where we can:

Create the Product Variable to which we will pass the user inputted product name for which they are finding the best vendor.
Create the Vendor Details variable to which we will pass the Dataverse connector returned vendor details.
In the Prompt section, use the below prompt and add the variables dynamically using the Insert button which will allow us to add the Product and Vendor Details input variables into the prompt.
Click on Save custom prompt, which will make the prompt available in the copilot designer.

We will add the recently created prompt by:

Selecting Call an action.
From the Basic actions tab, select the Best Vendor Details prompt.

The prompt is now available. Let’s configure it by adding the first input parameter, which is the user-inputted Product Name.

Next, we will add the Dataverse returned output data, which we had formatted, to the Vendor Details field.

Finally, we need to store the output record generated by the Prompt action in a variable for which we will create a new variable named varBestVendor.

Thus, we have configured the Prompt action with the required input, and it should ideally fetch us back the best vendor for the passed-in product based on the Quality Score parameter.

Finally, we will show the best vendor output as a basic card back to the user for which we will select the text Property of the varBestVendor record, which will contain the generative AI output.

Step 7: Publish the Copilot to Team

We will finally publish the copilot and add it to the Teams Channel for which we will enable the teams channel by selecting the Channels Tab -> Microsoft Teams -> Turn On Teams.

Click on the Availability Options to select how to distribute the copilot within Teams.

We have the option to publish the app to the app store, which goes through an admin approval, or we can download the zip file and upload it as a personal app. For this demo, we will go with publishing the app org-wide.

Click on Submit for Admin approval, and the admin can approve this from the Teams admin center.

We can see that the copilot has become available for publishing in the Teams admin center. Click on Publish.

Let’s now add the copilot to Teams so that we can interact and get results with it.

Thus, we have initiated the conversation with the copilot and tried to find the best vendor for Copper Wires. If we filter the Dataverse table for Copper Wire Vendors, we could see three records, but the AI prompt that we used has refined the results by comparing the Unit Price and Quality score to arrive at the best vendor.

We can see that the copilot has picked the vendor details from Dataverse and using the AI Prompt, fetched the generative contextual answer for the best vendor by comparing the unit price and quality score.

Conclusion

In this blog, we’ve explored how to build a supply chain Copilot using Microsoft Power Platform and Dataverse to streamline the vendor selection process. By leveraging Dataverse for structured storage of vendor details and employing AI prompts for intelligent analysis, our Copilot provides an efficient solution for identifying the best vendor based on critical parameters like lead time, quality score, and unit price.

Fusion Dev Insights

Material Procurement Copilot Agent built using Anthropic Claude & Dataverse

Table of Contents

Introduction

Technologies Involved

Overall Flow

Step 1: Get the Anthropic Claude Keys

Step 2: Create a Custom Connector for Anthropic Claude

Step 3: Create and Populate the Dataverse Table

Step 4: Creating the Agent in Copilot Studio

Enable Generative Selection of Topics

Step 5: Create Topics

Adding Material Selection Card

Adding Dataverse Data Retrieval

Formatting Data for Analysis

Adding the Anthropic Claude Connector

Testing the Agent

Conclusion

PII Detection Copilot powered with AI Prompt Action

Table of Contents

Introduction

Overview

Features:

Step-by-Step Guide to Building the Supply Chain Copilot

Step 1: Set Up Dataverse for Customer Registration Data

Step 2: Populate the Dataverse Table

Step 3: Creating the Copilot in Copilot Studio

Step 4: Enable Generative Selection of Topics

Step 5: Create Topics

Step 6: Fetching Customer Details from Dataverse

Step 7: Adding AI-Prompt for PII Detection

Test the Copilot

Conclusion

Smart Invoice Anomaly Detection using AI prompt Action and Dataverse data

Table of Contents

Introduction

Process Flow

Demo

Steps to Create the Invoice Anomaly Detection System

Create the Dataverse Table

Creating the Copilot in Copilot Studio

Enable Generative Selection of Topics

Create Topics

Test the Copilot

Conclusion

Build a Responsible AI Copilot with Azure Content Safety Service

Table of Contents

Introduction

Prerequisites

Step 1: Setting Up Azure Content Safety

Create an Azure Content Safety Resource

Step 2: Create the Copilot

Step 3: Enable Generative Selection of Topics

Step 4: Create Topics

Test the Copilot

Conclusion

Customer Service Copilot using Sentiment Analysis and Live Agent Escalation

Table of Contents

Introduction

Process Flow

Demo

Prerequisites

Technologies Involved

Steps to Create the Customer Service Copilot

Step 1: Provisioning a Dynamics 365 Customer Service Trial

Step 2: Creating Necessary Dataverse Tables

Step 3: Setting Up Azure AI Language Service for Sentiment Analysis

Step 4: Configuring the Copilot in Copilot Studio and Setting Up the Handover

Step 5: Creating the Copilot

Step 6: Configuring the Copilot

Step 7: Creating Topics

Step 8: Configure Transfer to Agent Node

Step 9: Create the Queue

Step 10: Create Workstream

Step 11: Testing in Power Pages

Conclusion

Cafeteria Feedback Copilot that uses AI Prompt Action for Sentiment Analysis

Table of Contents

Introduction

Process Flow