Automating Knowledgebase Search with Triage Agent

Overview

This guide outlines how to integrate Triage Agent with Power Automate to streamline IT request resolutions by automatically searching and scraping relevant knowledgebase articles from platforms like HelpDocs, ITGlue, Hudu, SharePoint, and more. The integration helps resolve IT requests faster and improves operational efficiency by leveraging external knowledgebases or internal resources.

Below are two key use cases for this integration:

Use Case 1: External Knowledgebase for Self-Service

When a customer submits an IT request, Triage Agent automatically triggers the flow in Power Automate to query an external knowledgebase, such as ITGlue, Hudu, SharePoint, and more. The flow searches for relevant articles, providing technicians with the most up-to-date resources to quickly resolve the issue without having to manually search for answers.

Use Case 2: Internal Knowledgebase for Faster Resolution

Alternatively, the Power Automate flow can be configured to search an internal knowledgebase, such as SharePoint or Hudu, for relevant articles. This helps technicians find company-specific solutions, standard operating procedures and best practices quickly, improving response times and consistency when resolving IT issues.

Prerequisites

Before getting started, ensure you have the following:

1. Thread Workspace → A configured Thread environment.
2. Magic Agents with Thread → Ensure Magic Agents are enabled in your Thread workspace.
3. Power Automate → Typically included with Internal Use Rights (IUR) licenses for Microsoft Partners who have attained competencies as a Microsoft CSP reseller or through the Microsoft Action Pack (MAP).
4. OpenAI API Subscription → Required for AI-driven processing. You can subscribe here: OpenAI API Pricing.

1. Create an Intent in Triage Agent

To begin, you’ll need to create a new intent in Triage Agent. This intent will trigger when a user asks for help, such as troubleshooting a network issue or setting up a Teams app.

Steps to Create the Intent

1. Navigate to the Thread Admin Panel.
2. Go to Magic AI → Triage Agent.
3. Click Create Intent and fill out the following details:

Intent Configuration

Form Fields

This setup ensures that Triage Agent can intelligently extract key information from the user’s request and pass it along to Power Automate for further processing.

2. Download and Upload the Power Automate Flow Template

In this step, you will download a pre-configured Power Automate flow template in a .zip format and upload it to your Power Automate account. This flow template is pre-configured to handle the webhook and automate the knowledgebase search, streamlining your request resolution process. Below are the instructions for downloading and uploading the flow template, along with an explanation of each step within the flow for further configuration and customization.

This will download the flow package to your computer.

3. Upload the Flow to Power Automate

1. Go to Power Automate.
2. In the left-hand menu, click on My Flows.
3. At the top of the page, click on the Import button.
4. Click Upload and select the .zip file you just downloaded.
5. Select the newly uploaded flow template.
6. Click Edit to open the flow editor.

4. Configure the Flow Template

In this step, you will configure the flow template you uploaded to Power Automate. This involves setting up the webhook to ensure that the data from the Triage Agent in Thread is properly received and processed in Power Automate and scrapes the knowledgebase of your choice for relevant articles.

4.1 Set Up Webhook in Power Automate

1. Select When an HTTP request is received as the trigger.
2. Copy the webhook URL provided by Power Automate for this trigger. This URL is where the data from the Triage Agent in Thread will be sent.
3. In the Automation section of the Triage Agent intent, click Add Webhook.
4. Paste the Webhook URL you copied from Power Automate into the Webhook URL field.
5. Configure the Request Body JSON Schema to ensure all form fields within the Triage Agent intent and ticket metadata are captured. The form data, such as the user's query and request should be included in the "intent_fields" section as shown below.

{
    "type": "object",
    "properties": {
        "intent_name": {
            "type": "string"
        },
        "intent_fields": {
            "type": "object",
            "properties": {
                "Query": {
                    "type": "string"
                },
                "Request": {
                    "type": "string"
                }
            }
        },
        "meta_data": {
            "type": "object",
            "properties": {
                "ticket_id": {
                    "type": "integer"
                },
                "ticket_board_name": {
                    "type": "string"
                },
                "ticket_board_id": {
                    "type": "integer"
                },
                "contact_id": {
                    "type": "integer"
                },
                "contact_name": {
                    "type": "string"
                },
                "contact_email": {
                    "type": "string"
                },
                "company_id": {
                    "type": "string"
                },
                "company_name": {
                    "type": "string"
                },
                "company_types": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                }
            }
        }
    }
}

4.2 Search KnowledgeBase API

In this step, the flow will query the appropriate KnowledgeBase API based on the request. You can configure the flow to search across multiple knowledge sources like HelpDocs, ITGlue, SharePoint, Hudu, etc.

• HelpDocs:
  • Method: GET
  • URL: https://api.helpdocs.io/v1/search?query=@{triggerBody()?['intent_fields']?['Query']}
• ITGlue:
  • Method: GET
  • URL: https://api.itglue.com/search?query=@{triggerBody()?['intent_fields']?['Query']}
• Hudu:
  • Method: GET
  • URL: https://yourhudu.com/api/search?query=@{triggerBody()?['intent_fields']?['Query']}
• SharePoint:
  • Method: GET
  • URL: https://graph.microsoft.com/v1.0/search/query?query=@{triggerBody()?['intent_fields']?['Query']}
  Ensure that the search query @{triggerBody()?['intent_fields']?['Query']} is properly passed to the API to pull the most relevant articles. You can dynamically switch between these APIs based on your system's configuration or preference.

This step enables the flow to search for articles in any of your integrated KnowledgeBase sources, depending on what’s set up in your environment.

In this step, the flow will query the KnowledgeBase API to search for relevant knowledgebase articles based on the user’s request.

1. API Request for HelpDocs
   Use the following URL to send a search request to the HelpDocs API, with the query dynamically populated from the incoming data (in this case, from
   • triggerBody()):https://api.helpdocs.io/v1/search?query=@{triggerBody()?['intent_fields']?['Query']}
   • @{triggerBody()?['intent_fields']?['Query']}: This dynamically pulls the search term from the intent_fields.Query property of the incoming payload. This is the text that the user has asked about (e.g., "reset password").
2. Configure the Flow
   • Add an HTTP action in Power Automate to make a GET request to the HelpDocs search endpoint.
   • Ensure that the API response is captured and used in subsequent steps for further processing (i.e., relevance ranking with OpenAI).
3. Example Request
   When the flow triggers with a user’s query, it could look like this:
   https://api.helpdocs.io/v1/search?query=reset password
   This will return a list of articles related to "reset password" from the HelpDocs knowledgebase.
4. API Response Handling
   • Capture the API response, which will contain a list of articles, including their titles, URLs, and snippets.
   • This data is used in subsequent steps, like relevancy ranking via OpenAI and parsing for article selection.

This step explains how to query HelpDocs using the API and provides a clear example of how to structure the search request.

4.3 OpenAI Relevancy Search

1. Add a HTTP request action to send the search results to OpenAI:
   • Method: POST
   • URL: https://aiprod03.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-08-01-preview
   • Headers:
     • Content-Type: application/json
   • Body:

   {
     "messages": [
       { "role": "system", "content": "You are an assistant that finds the most relevant article from a search." },
       { "role": "user", "content": "@{triggerBody()?['intent_fields']?['Request']}" },
       { "role": "user", "content": "@{body('Help_Docs_Search')}" }
     ]
   }

2. Store the response in Parse_JSON.

4.4 Parse OpenAI Response

1. Add a Parse JSON action with the following schema:

   {
       "type": "object",
       "properties": {
           "article_id": { "type": "string" },
           "url": { "type": "string" }
       }
   }

4.5 Retrieve Full Article from HelpDocs

1. Add a HTTP request action to GET the full article:
   • Method: GET
   • URL: https://api.helpdocs.io/v1/article/@{body('Parse_JSON')?['article_id']}
2. Store the response in Single_Article.

4.6 Compose Article Details

1. Add a Compose action to structure the article response:

   {
       "article": {
           "article_id": "@{body('Single_Article')?['article']?['article_id']}",
           "title": "@{body('Single_Article')?['article']?['title']}",
           "body": "@{body('Single_Article')?['article']?['body']}",
           "url": "@{body('Parse_JSON')?['url']}"
       }
   }

4.7 Generate Brief Summary with OpenAI

1. Add another HTTP request action to summarize the article:
   • Method: POST
   • URL: https://aiprod03.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-08-01-preview
   • Headers:
     • Content-Type: application/json
   • Body:

   {
     "messages": [
       { "role": "system", "content": "You are an assistant that summarizes an article into short bullet points." },
       { "role": "user", "content": "@{triggerBody()?['intent_fields']?['Request']}" },
       { "role": "user", "content": "@{body('Single_Article')?['article']?['body']}" }
     ]
   }

2. Store the response in OpenAI_Brief_Description.

4.8 Response

The Triage Agent is waiting for a response, either as a message (customer-facing) or an internal note (visible only to your team), to update the ticket. Here, you can customize the response body to determine how Thread will update the ticket based on your use case.

1. Add a Compose action to return the response in the required format:

{
  "success": 200,
  "message": "@{body('OpenAI_Brief_Description')['choices'][0]?['message']?['content']} \n Full Article: @{body('Parse_JSON')?['url']}",
  "internal_message": "@{body('OpenAI_Brief_Description')['choices'][0]?['message']?['content']} \n Full Article: @{body('Parse_JSON')?['url']}"
}