DEV Community: Shantanu

Website AI Assistant library

Shantanu — Mon, 13 Apr 2026 03:24:02 +0000

Library built using ML .NET, Microsoft's machine learning platform

Create and your own bespoke AI model and make predictions

Hi community,

Websites usually have sections that contain information about the various products or services offered by the website.

It may contain a list of the different products or services offered, along with descriptions and more information in other pages.

This AI Assistant can help visitors narrow down which of the website's products or services suits their needs,

by classifying the visitor's natural language and/or numeric based input into one of the categories of products or services offered by the website.

You can then provide more information about that category.

The API provided by the library let you create your bespoke AI model based on your training data.

and then load your model and make predictions.

Implementation

The library is built using ML .NET, Microsoft's machine learning platform.

You can create a bespoke AI model by feeding your own training data.

The model can support classification based on

natural language and/or
numeric

training data and inputs to the trained AI model.

Example of natural language & numeric

Training data & input

Car categories:

public enum CarCategory
{
    None = -1,
    TwoDoorBasic = 0,
    TwoDoorLuxury = 1,               
    FourDoorBasic = 2,
    FourDoorLuxury = 3
}

Training data:

It comprises of 2 tab-separated columns.

First is the Label (ie category) column & second is the Feature (text) column.

-1  
0   2 door
0   basic
0   low price $ 20,000
0   mid price $ 25,000
0   high price $ 30,000
1   2 door
1   luxury
1   low price $ 40,000
1   mid price $ 45,000
1   high price $ 50,000
2   4 door
2   basic
2   low price $ 60,000
2   mid price $ 65,000
2   high price $ 70,000
3   4 door
3   luxury
3   low price $ 80,000
3   mid price $ 85,000
3   high price $ 90,000

The training data can be from a file or an IEnumerable list (from database for eg.).

Create your bespoke AI model using the library.

PredictionEngine.DataViewType = DataViewType.File;
PredictionEngine.DataViewFilePath = "TrainingDataset.tsv";

PredictionEngine.TextFeaturizingEstimatorOptions = new TextFeaturizingEstimatorOptions
{
    CharFeatureExtractor = new WordBagEstimatorOptions
    {
       NgramLength = 3, // Only 3-char sequences
       UseAllLengths = false, // Do not include shorter n-grams  
       Weighting = WordBagWeightingCriteria.TfIdf
    },
    WordFeatureExtractor = new WordBagEstimatorOptions
    {
        NgramLength = 3, // Only 3-char sequences
        UseAllLengths = false, // Do not include shorter n-grams  
        Weighting = WordBagWeightingCriteria.TfIdf
    }
};

// Path to save model
string modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "SampleWebsite-AI-Model.zip");

await PredictionEngine.CreateModelAsync(modelPath);

Build the DI container to use the helper service (WebsiteAIAssistantService) provided by library.

This service is used to make predictions.

var services = new ServiceCollection();
services.AddWebsiteAIAssistantCore(settings =>
{
    settings.AIModelLoadFilePath = Path.Combine(Environment.CurrentDirectory, "Data", "SampleWebsite-AI-Model.zip");
    settings.NegativeConfidenceThreshold = 0.70f;
    settings.NegativeLabel = -1f;
});
aiAssistantServiceProvider = services.BuildServiceProvider();

Unit tests on model:

[Theory]
[InlineData("price $ 42,000", CarCategory.TwoDoorLuxury)]
[InlineData("price $ 39,000", CarCategory.TwoDoorBasic)]
[InlineData("price $ 53,000", CarCategory.TwoDoorLuxury)]
[InlineData("4 door price $ 67,000", CarCategory.FourDoorBasic)]
[InlineData("luxury price $ 88,000", CarCategory.FourDoorLuxury)]
[InlineData("luxury price $ 62,000", CarCategory.TwoDoorLuxury)]
[InlineData("2 door price $ 29,000", CarCategory.TwoDoorBasic)]
[InlineData("low price $ 55,000", CarCategory.TwoDoorLuxury)]
[InlineData("high price $ 34,000", CarCategory.TwoDoorBasic)]
[InlineData("What is the colour of a rose?", CarCategory.None)]
public async Task Load_Predict_Service_CarCategory(string userInput, CarCategory expectedResult)
{
    // Arrange                      
    var aiAssistantService = _aiAssistantServiceProvider!.GetRequiredService<IWebsiteAIAssistantService>();

    var input = new ModelInput { Feature = userInput };

    // Act
    var prediction = await aiAssistantService.PredictAsync(input);

    // Assert
    Assert.NotNull(prediction);
    Assert.Equal(expectedResult, (CarCategory)prediction.PredictedLabel);
}

You can use the library in many different types of such scenarios.

Browse the library on GitHub:

VeritasSoftware / WebsiteAIAssistant

Library built using ML .NET. Create and your own bespoke AI model and make predictions.

Website AI Assistant

Library built using ML .NET, Microsoft's machine learning platform

Create and your own bespoke AI model and make predictions

AI Assistant helps visitors to your website, narrow down which of the offered products or services suits their needs.

Packages	Version	Downloads
WebsiteAIAssistant
WebsiteAIAssistant.MinimalAPI
WebsiteAIAssistant.AzureFunction
WebsiteAIAssistant.AWSLambda

Overview

Websites usually have sections that contain information about the various products or services offered by the website.

It may contain a list of the different products or services offered, along with descriptions and more information in other pages.

This AI Assistant can help visitors narrow down which of the website's products or services suits their needs,

by classifying the visitor's natural language and/or numeric based input into one of the categories of products or services offered by the website.

You can then provide more information about that category.

The API provided by the library let you create your bespoke AI model…

View on GitHub

xUnit - Run async code specific to test before/after test

Shantanu — Thu, 12 Mar 2026 03:15:01 +0000

xUnit allows you to run code before each test using the BeforeAfterTestAttribute.

But, you cannot run asynchronous code using this attribute. This is needed in many situations.

To solve this problem, I have created a custom abstract xUnit attribute BeforeAfterAsyncTestAttribute,

inheriting from BeforeAfterTestAttribute, that allows you to run asynchronous code before each test or group of tests.

Inherit and create a class for each test.

public class MyBeforeAfterAsyncTestAttribute : BeforeAfterAsyncTestAttribute
{
    public MyBeforeAfterAsyncTestAttribute(Type specificAttributeType, string stamp) : base(specificAttributeType, stamp)
    {
    }

    public MyBeforeAfterAsyncTestAttribute(Type specificAttribute, Type returnFunctionClassType,
                                                string returnFunctionName, string stamp)
                                                : base(specificAttribute, returnFunctionClassType, returnFunctionName, stamp)
    {
    }
}

These are interfaces your specific Test attribute has to implement.

public interface IRunBeforeAsync : IRunAsync
{
    Action? RunBefore { get; }
}

public interface IRunAfterAsync : IRunAsync
{
    Action? RunAfter { get; }
}

public interface IRunBeforeAsyncWithReturn : IRunBeforeAsync
{
    object? ReturnValue { get; set; }
}

In the interface implementation, specific to each test, put your code specific to the Test in the Run Action, as shown below.

Here you put your asynchronous code.

Examples

public class LoadAIModel : IRunBeforeAsync, IRunAfterAsync
{
    public Action RunBefore => async () =>
    {
        // Arrange
        // Path to load model
        string modelPath = Path.Combine(Environment.CurrentDirectory, "SampleWebsite-AI-Model.zip");

        await PredictionEngine.LoadModelAsync(modelPath);
    };

    public Action RunAfter => async () =>
    {
        // Clean up resources after the test, if necessary
        await PredictionEngine.UnloadModelAsync();
    };
}

public class SetAIModelPath : IRunBeforeAsync, IRunAfterAsync
{
    public Action RunBefore => async () =>
    {
        // Arrange
        // Path to load model
        string modelPath = Path.Combine(Environment.CurrentDirectory, "SampleWebsite-AI-Model.zip");
        // Provide the path to the AI model
        PredictionEngine.AIModelLoadFilePath = modelPath;
    };

    public Action RunAfter => async () =>
    {
        // Clean up resources after the test, if necessary
        await PredictionEngine.UnloadModelAsync();
    };
}

Then, you can decorate those specific tests.
Provide a Guid (as a string) as a parameter. This Guid should be unique to the test.

    [MyBeforeAfterAsyncTest(typeof(LoadAIModel), "5bb02c70-01d1-4987-8a6e-ab7fc8b1dcc4")]
    [Theory]
    [InlineData("What are the requisites for carbon credits?", Scheme.ACCU)]
    [InlineData("How do I calculate net emissions?", Scheme.SafeguardMechanism)]
    [InlineData("What is the colour of a rose?", Scheme.None)]
    public async Task Load_Predict(string userInput, Scheme expectedResult)
    {
        var input = new ModelInput { Feature = userInput };

        // Act
        var prediction = await PredictionEngine.PredictAsync(input);

        // Assert
        Assert.NotNull(prediction);
        Assert.Equal(expectedResult, (Scheme)prediction.PredictedLabel);
    }

    [MyBeforeAfterAsyncTest(typeof(SetAIModelPath), "d54e2920-ad42-4acc-a6e2-37aad8e9ac3f")]
    [Theory]
    [InlineData("What are the requisites for carbon credits?", Scheme.ACCU)]
    [InlineData("How do I calculate net emissions?", Scheme.SafeguardMechanism)]
    [InlineData("What is the colour of a rose?", Scheme.None)]
    public async Task AutoLoad_Predict(string userInput, Scheme expectedResult)
    {
        var input = new ModelInput { Feature = userInput };

        // Act
        var prediction = await PredictionEngine.PredictAsync(input);

        // Assert
        Assert.NotNull(prediction);
        Assert.Equal(expectedResult, (Scheme)prediction.PredictedLabel);
    }

Run all the tests in the class.

Your specific code will run ONLY ONCE before each group of Theory Tests.

So, for example, your specific code in LoadAIModel will run asynchronously only once for the 3 Tests in the Theory group.

You can browse the project's source code repository on GitHub:

VeritasSoftware / xUnit-Addons

Useful addons for xUnit

xUnit Addons

Run asynchronous code specific to test, before/after test

xUnit allows you to run code before each test using the BeforeAfterTestAttribute.

But, you cannot run asynchronous code using this attribute. This is needed in many situations.

To solve this problem, I have created a custom abstract xUnit attribute BeforeAfterAsyncTestAttribute,

inheriting from BeforeAfterTestAttribute, that allows you to run asynchronous code before each test or group of tests.

First, inherit from this attribute and create an attribute for each test.

You can re-use the attribute in multiples tests too. Just pass in a different Guid in the stamp parameter.

public class MyBeforeAfterAsyncTestAttribute : BeforeAfterAsyncTestAttribute
{
    public MyBeforeAfterAsyncTestAttribute(Type specificAttributeType, string stamp) : base(specificAttributeType, stamp)
    {
    }
    public MyBeforeAfterAsyncTestAttribute(Type specificAttribute, Type returnFunctionClassType,
                                                string returnFunctionName, string stamp)
                                                : base(specificAttribute, returnFunctionClassType, returnFunctionName, stamp

…

View on GitHub

.NET WebRTC

Shantanu — Mon, 06 Oct 2025 11:45:34 +0000

I have built a system for plugging in WebRTC (Web Real-Time Communication) based audio & video chat into your web application.

My system comprises of a Server & Client libraries for Angular, React & Blazor.

The system is really easy to use.

I have built sample web apps to demonstrate how to use my libraries in your project.

WebRTC communication in my system:

My Git Hub repo:

https://github.com/VeritasSoftware/WebRTC

Have a read...

LiveHealthChecks - real time API Health Check monitoring

Shantanu — Tue, 24 Jun 2025 12:23:34 +0000

I have designed and built a system which taps into the AspNetCore Web API Health Check system.

The system runs the Health Checks in an API periodically & makes the generated Health Report json,
available to Monitoring applications, via a Server using web sockets.

You can also publish a Health Report from your API code.
Eg. On an exception, in the handler, you can publish a Health Report in real-time.

This approach is much better than the API Health Check endpoint polling approach prevalent in the industry today.

My project takes API Health Check monitoring to the next level due to its real-time feature.

There are 2 Nuget packages for Client & Server.

The system is free, really easy to configure and put together.

Revolutionary API Gateway

Shantanu — Wed, 11 Jun 2025 08:40:03 +0000

An API Gateway is a centre piece Server component in Microservices architecture.

My invention of a concept for an API Gateway as a RESTful Microservice Facade, design and source code,
was on-boarded by Microsoft affiliated the .NET Foundation.

The Foundation endorsed it on their social media as a revolutionary Gateway.

Subscribe Notify pattern

Shantanu — Tue, 03 Jun 2025 01:47:04 +0000

Hi,

I have created a Subscribe Notify pattern, that greatly simplifies dealing with Observables (eg. for HttpClient), in your Angular component.

The pattern is implemented by a Notification Service which subscribes to the Observable and wires up the data & error received, to streams.

These streams (data$ & error$) are assigned to local variables (employees$ & error$) in your component.

These variables re-render the mark up every time they are notified & updated with new data or error.

component.ts

private readonly notificationService = inject(NotificationService<Employee[]>);

private readonly employeeApiService = inject(EmployeeApiService);

public employees$ = this.notificationService.data$;
public error$ = this.notificationService.error$;

getEmployeesByName(searchName: string) {
     // Fetch employees by name.
     // The employeeApiService method returns an Observable<Employee[]>.
     // The employees$ stream will be notified and updated with the data.
     // The error$ stream will be notified and updated with the error if any.
     this.notificationService.subscribe
     (
        this.employeeApiService.getEmployeesByName(searchName)
     );
}

component.html

@if (error$ | async) {
   <div style="color:red">{{(error$ | async)?.message}}</div>
}

<table>
    <thead>
        <tr>
            <th>Name</th>
            <th>Total Leave Days</th>
        </tr>
    </thead>
    <tbody>
        <!-- Loop through the employees$ stream -->
        @for (employee of employees$ | async; track employee.id) {
            <tr>
                <td>{{ employee.name }}</td>
                <td>{{ employee.totalLeaveDays }}</td>
            </tr>
        }
    </tbody>
</table>

Real easy to implement in your solution.

Hi, I have created a Subscribe Notify pattern, that greatly simplifies dealing with Observables (eg. for HttpClient), in your component. https://github.com/VeritasSoftware/NotificationService Real easy to implement in your solution. Have a quick read.

Shantanu — Sat, 31 May 2025 02:03:32 +0000