Creating a HR AI Assistant with RAG Implementation

In this blog post, we will explore how to build an AI-powered HR FAQ application using Retrieval-Augmented Generation (RAG) architecture. This app integrates Azure AI Search, Azure OpenAI, and SharePoint as a data source. We’ll provide a step-by-step guide, including setting up Azure resources and synchronizing data between SharePoint and Azure Storage Table using Azure Functions.

What is Retrieval-Augmented Generation (RAG)?

RAG is an AI architecture that combines information retrieval with generative AI models. It works by retrieving relevant data from a knowledge base and using a generative AI model to summarize or provide answers. This approach ensures accurate and contextually relevant responses.

In our implementation:

Azure AI Search acts as the retriever, indexing data from SharePoint using Azure Storage Table.
Azure OpenAI provides generative responses by leveraging the indexed data.

Solution Architecture

Retrieval Augmented Generation

Step-by-Step Implementation

Sync SharePoint to Azure Table

The backend data source for our application is an Azure Storage Table, which is continuously populated with data extracted from a SharePoint list using an Azure Function. The Azure Function runs once per day.

Backend Data Sync

The following fields are synchronized from the SharePoint FAQ list to the Azure Storage Table. You can create an Azure Function to perform this synchronization every 24 hours or adjust the frequency based on your requirements:

Field	Description
Id	Unique identifier for the list item
Question	The question text
Answer	The answer text
Category	The category of the FAQ
Tags	Tags associated with the FAQ
Department	Department related to the FAQ
RelatedResource	Related resources or links
Modified	Last modified date of the list item

Creating Data Source

Please note that you need to create the following Azure AI Search resources in the specified order:

Datasource
Index
Skillset
Indexer

I prefer using a PowerShell script to automate these tasks instead of configuring them manually. Below are the datasource.json and the Create-DataSource PowerShell function. You can also use Postman for this purpose.

Global variables for the following PowerShell snippets

powershell

# Define Global Variables
$searchServiceName = "ais-ehussain-dev"
$apiKey = ""
$apiVersion = "2024-07-01"
$searchServiceUrl = "https://$searchServiceName.search.windows.net"

# Create headers for rest api calls
$headers = @{
  'api-key'      = $apiKey
  'Content-Type' = 'application/json'
  'Accept'       = 'application/json'
}

DataSource configurations

json


{
    "name": "datasource-table-faq",
    "description": "FAQ data source",
    "type": "azuretable",
    "credentials": {
        "connectionString": ""
    },
    "container": {
        "name": "FAQs",
        "query": null
    }

}

Powershell script to create datasouce

powershell


function Create-DataSource {
  param(
    [Parameter(Mandatory = $true)]
    [object] $dataSourceConfig,
  
    [Parameter(Mandatory = $true)]
    [hashtable] $headers
  )
  
  $dataSourceName = $dataSourceConfig.name
  $dataSourceUri = "$searchServiceUrl/datasources/$($dataSourceName)?api-version=$apiVersion"
  if (-not (ResourceExists -Uri $dataSourceUri -Headers $headers)) {
    Write-Host "Creating data source: $dataSourceName..." -ForegroundColor Yellow
    Invoke-RestApi -Uri $dataSourceUri -Method Put -Body $dataSourceConfig -Headers $headers
    Write-Host "Data source created successfully!" -ForegroundColor Green
  }
  else {
    Write-Host "Data source '$dataSourceName' already exists. Skipping creation."
  }
}

Creating Index

The provided JSON configuration defines an index named index-table-faq for Azure AI Search. This index includes fields such as Id, Question, Answer, Category, Tags, Department, RelatedResource, Modified, and embedding. Each field is configured with specific attributes like searchable, filterable, and sortable.

The semantic section configures semantic search capabilities, prioritizing the Answer and Tags fields. The vectorSearch section defines a vector search profile using the text-embedding-ada-002 model from Azure OpenAI, enabling advanced search capabilities based on vector embeddings.

More Information

For more information on creating a vector index in Azure AI Search, please follow the link below:

Create a vector index

json

{
    "name": "index-table-faq",
    "fields": [
        { "name": "Id", "type": "Edm.String", "key": true, "filterable": true },
        { "name": "Question", "type": "Edm.String", "searchable": true },
        { "name": "Answer", "type": "Edm.String", "searchable": true },
        { "name": "Category", "type": "Edm.String", "searchable": true, "filterable": true, "sortable": true, "facetable": true },
        { "name": "Tags", "type": "Edm.String", "searchable": true, "filterable": true, "facetable": true },
        { "name": "Department", "type": "Edm.String", "searchable": true, "filterable": true, "sortable": true },
        { "name": "RelatedResource", "type": "Edm.String", "searchable": true },
        { "name": "Modified", "type": "Edm.DateTimeOffset", "filterable": true, "sortable": true },
        { "name": "embedding", "type": "Collection(Edm.Single)", "searchable": true, "filterable": true, "dimensions": 1536, "vectorSearchProfile": "vector-profile" }
    ],
    "semantic": {
        "configurations": [{
            "name": "semantic-config",
            "prioritizedFields": {
                "prioritizedContentFields": [{
                    "fieldName": "Answer"
                }],
                "prioritizedKeywordsFields": [{
                    "fieldName": "Tags"
                }]
            }
        }]
    },
    "vectorSearch": {
        "algorithms": [{
            "name": "vector-config",
            "kind": "hnsw",
            "hnswParameters": {
                "m": 4,
                "efConstruction": 400,
                "efSearch": 500,
                "metric": "cosine"
            }
        }],
        "profiles": [{
            "name": "vector-profile",
            "algorithm": "vector-config",
            "vectorizer": "vectorizer"
        }],
        "vectorizers": [{
            "name": "vectorizer",
            "kind": "azureOpenAI",
            "azureOpenAIParameters": {
                "resourceUri": "https://xxxx.openai.azure.com",
                "deploymentId": "text-embedding-ada-002",
                "apiKey": "<redacted>",
                "modelName": "text-embedding-ada-002"
            }
        }],
        "compressions": []
    }
}

powershell


function Create-Index {
  param(
    [Parameter(Mandatory = $true)]
    [object] $indexConfig,
  
    [Parameter(Mandatory = $true)]
    [hashtable] $headers
  )
  
  $indexName = $indexConfig.name
  $indexUri = "$searchServiceUrl/indexes/$($indexName)?api-version=$apiVersion"
  if (-not (ResourceExists -Uri $indexUri -Headers $headers)) {
    Write-Host "Creating index: $indexName..." -ForegroundColor Yellow
    Invoke-RestApi -Uri $indexUri -Method Put -Body $indexConfig -Headers $headers
    Write-Host "Index created successfully!" -ForegroundColor Green
  }
  else {
    Write-Host "Index '$indexName' already exists. Skipping creation."
  }
}

Creating Skillset

The following JSON defines an Azure AI Skillset named chunk-generate-embeddings-and-project. This skillset is designed to chunk documents and generate embeddings using the Azure OpenAI Embedding Skill. It processes the Answer field from the document, generates a vector embedding, and stores it in the embedding field. The skillset uses the text-embedding-ada-002 model deployed on Azure OpenAI service.

json

{
    "name": "chunk-generate-embeddings-and-project",
    "description": "Skillset to chunk documents and generate embeddings",
    "skills": [{
        "@odata.type": "#Microsoft.Skills.Text.AzureOpenAIEmbeddingSkill",
        "name": "vector-embedding-generation-skill",
        "description": "",
        "context": "/document",
        "inputs": [{
            "name": "text",
            "source": "/document/Answer",
            "inputs": []
        }],
        "outputs": [{
            "name": "embedding",
            "targetName": "embedding"
        }],
        "resourceUri": "https://xxxx.openai.azure.com",
        "deploymentId": "text-embedding-ada-002",
        "apiKey": "<redacted>",
        "modelName": "text-embedding-ada-002",
        "dimensions": 1536
    }]

}

powershell

function Create-Skillset {
  param(
    [Parameter(Mandatory = $true)]
    [object] $skillsetConfig,
  
    [Parameter(Mandatory = $true)]
    [hashtable] $headers
  )
  
  $skillsetName = $skillsetConfig.name
  $skillsetUri = "$searchServiceUrl/skillsets/$($skillsetName)?api-version=$apiVersion"
  if (-not (ResourceExists -Uri $skillsetUri -Headers $headers)) {
    Write-Host "Creating skillset: $skillsetName..." -ForegroundColor Yellow
    Invoke-RestApi -Uri $skillsetUri -Method Put -Body $skillsetConfig -Headers $headers
    Write-Host "Skillset created successfully!" -ForegroundColor Green
  }
  else {
    Write-Host "Skillset '$skillsetName' already exists. Skipping creation."
  }
}

Creating Indexer

The provided JSON configuration defines an indexer named indexer-table-faq for Azure AI Search. This indexer is responsible for pulling data from the datasource-table-faq, applying the chunk-generate-embeddings-and-project skillset, and populating the index-table-faq. The indexer is scheduled to run every 5 minutes (PT5M) and processes data in batches of 1000 items. It includes output field mappings to map the generated embeddings to the embedding field in the target index.

json


{
    "name": "indexer-table-faq",
    "dataSourceName": "datasource-table-faq",
    "targetIndexName": "index-table-faq",
    "skillsetName": "chunk-generate-embeddings-and-project",
    "schedule": { "interval": "PT5M" },
    "parameters": {
        "batchSize": 1000,
        "maxFailedItems": -1,
        "maxFailedItemsPerBatch": -1
    },
    "outputFieldMappings": [{
        "sourceFieldName": "/document/embedding/*",
        "targetFieldName": "embedding",
        "mappingFunction": null
    }]
}

powershell


function Create-Indexer {
  param(
    [Parameter(Mandatory = $true)]
    [object] $indexerConfig,

    [Parameter(Mandatory = $true)]
    [hashtable] $headers
  )

  $indexerName = $indexerConfig.name
  $indexerUri = "$searchServiceUrl/indexers/$($indexerName)?api-version=$apiVersion"
  if (-not (ResourceExists -Uri $indexerUri -Headers $headers)) {
    Write-Host "Creating indexer..." -ForegroundColor Yellow
    $indexerUri = "$searchServiceUrl/indexers?api-version=$apiVersion"
    Invoke-RestApi -Uri $indexerUri -Method Post -Body $indexerConfig -Headers $headers
    Write-Host "Indexer created successfully!" -ForegroundColor Green
  }
  else {
    Write-Host "Indexer '$indexerName' already exists. Skipping creation."
  }
}

Verifying the Search Index

If you have followed the above steps correctly, you can perform a quick search in your newly created index to verify that it returns results with the generated embeddings. This ensures that the data synchronization, skillset application, and indexing processes are functioning as expected.

To test the search functionality, navigate to the Azure AI Search portal, select your index, and run a query. You should see results that include the embeddings generated by the Azure OpenAI service.

Query Azure AI Search Index

Building the API for Querying and Summarizing

Now you can build your API to communicate with Azure AI Search to fetch results based on user queries and use Azure OpenAI to summarize the answers for the user.

Querying Azure AI Search

For the Azure API implementation to query Azure AI Search, you can use the following function in your API:

csharp

public async IAsyncEnumerable<DocumentResult> QuerySearchAsync(string query, bool useVectorSearch, bool useSemanticSearch, bool useFullTextSearch, int? top = 10, string? filter = null)
{
    // Configure search options
    var searchOptions = new SearchOptions
    {
        Filter = filter,
        Size = top,
        Select = { "Id", "Question", "Answer", "Category", "Tags", "RelatedResource" },
        IncludeTotalCount = true
    };

    // Configure vector search if enabled
    if (useVectorSearch)
    {
        searchOptions.QueryType = SearchQueryType.Full;
        searchOptions.VectorSearch = new VectorSearchOptions
        {
            Queries = {
                new VectorizableTextQuery(text: query)
                {
                    KNearestNeighborsCount = 50,
                    Fields = { "embedding" },
                    Exhaustive = true
                }
            },
        };
    }

    // Execute the search query
    SearchResults<SearchDocument> searchResults = await _searchClient.SearchAsync<SearchDocument>(useFullTextSearch ? query : null, searchOptions);

    // Process and yield search results
    await foreach (var result in searchResults.GetResultsAsync())
    {
        DocumentResult documentResult = new DocumentResult
        {
            Id = result.Document["Id"].ToString() ?? string.Empty,
            Question = result.Document["Question"].ToString() ?? string.Empty,
            Answer = result.Document["Answer"].ToString() ?? string.Empty,
            Category = result.Document["Category"].ToString() ?? string.Empty,
            Tags = result.Document["Tags"].ToString() ?? string.Empty,
            RelatedResource = result.Document["RelatedResource"].ToString() ?? string.Empty
        };

        yield return documentResult;
    }
}

Summarizing with Azure OpenAI

You can use the following code snippet to communicate with Azure OpenAI. This function takes the results from the Azure AI Search and passes them to Azure OpenAI to generate a summarized response:


public async Task<string> GenerateCompletionAsync(string question, List<DocumentResult> searchResults)
     {
         var completionClient = _azureOpenAIClient.GetChatClient(_completionModel);
         var prompt = new StringBuilder();
         prompt.AppendLine(question);

        // Define the system instruction
         string systemInstruction = OpenAIConstants.SystemInstruction;

         // Create the request payload with roles
         var messages = new List<ChatMessage>
         {
             new SystemChatMessage("system", systemInstruction),
             new UserChatMessage("user", question)
         };

         foreach (var result in searchResults)
         {
             messages.Add(new AssistantChatMessage("assistant", $"{result.Question}\n{result.Answer}"));
         }               

         var completionResult = await completionClient.CompleteChatAsync(messages);
         return completionResult.Value.Content.First().Text;
     }

By integrating these functions into your API, you can effectively query Azure AI Search for relevant documents and use Azure OpenAI to generate summarized responses based on the search results.

HR AI Assistant Chat Interface

You can now build your front-end chat interface. In this example, a SharePoint Framework (SPFx) web part is used to capture user questions and generate responses via the API described above. Users can ask questions related to HR policies, procedures, and documentation. The HR AI Assistant is an intelligent chatbot designed to provide accurate answers about company policies, procedures, and resources. Users can inquire about topics such as reimbursements, remote work, and workplace policies.

HR AI Assistant Chat Interface

Conclusion

By leveraging vector search and the Retrieval-Augmented Generation (RAG) approach, the HR AI Assistant provides highly accurate and contextually relevant responses. The combination of Azure AI Search for retrieving relevant results and Azure OpenAI for generating summaries ensures that users receive precise and comprehensive answers to their queries.

Azure AI Vector Search enhances the HR AI Assistant’s accuracy by using advanced vector embeddings to understand the semantic meaning of queries. Unlike traditional keyword-based search, vector search captures context and nuances, retrieving relevant results even without exact keyword matches. Combined with Azure OpenAI’s generative capabilities, this ensures concise and relevant summaries, significantly improving user experience and efficiency in accessing HR-related information.