DEV Community: Vamsi Dogiparthi

Understanding MS Rules Engine — Nested Rules — Part 5

Vamsi Dogiparthi — Mon, 07 Jul 2025 16:10:16 +0000

Hi Buddy! Welcome back to the part 5 of the MS Rules Engine series. In this article we will be concentrating on how to build simple nested rules with different Operators OR, AND How to parse the nested rules output actions from the ResultTree. So, without any further delay. Let's get started!! 😁

Configuring Simple Nested Rules Without Actions

In this section, few important pieces of Nested Rules configurations, syntaxes before we dig deep into step-by-step implementation.

Syntax:

In order to define the Nested Rules, we need to follow below syntax.

[
  {
    "WorkflowName": "{NameOfWorkflow",
    "Rules": [ // Parent Rules Array
      {
        "RuleName": "{Rule1Name}",
        "RuleExpressionType": "LambdaExpression",
        "Operator": "Or", // AND or OR
        "Rules" : [ // Nested Rules Array
          {
            "RuleName": "{NestRule2Name}",            
            "RuleExpressionType": "LambdaExpression",
            "Expression": "{Expression}",
          },
          {
            "RuleName": "{NestRule2Name}",           
            "RuleExpressionType": "LambdaExpression",          
            "Expression": "{Expression}",
          }
        ]
      }
    ]
  }
]

Operators:

When we included Nested Rules, one important thing is to note that we need to define the Logical Operator which identifies how the end result of all the Nested Rules should be interpreted. The possible values are below.

AND - This represents Logical AND which means to get a true value. You need all the nested rules to be true. If not, it will return false.
OR - This represents Logical OR which means to get a true value. You need at least one the nested rules to be true. If not, it will return false.
AndElse - This is a synonym for AND. So, the functionality is same.
OrElse - This is a synonym for OR. So, the functionality is same.

{  
   "enum": [
            "And",
            "AndAlso",
            "Or",
            "OrElse"
            ]
}

ReSettings:

To configure the nested rules properly and also change its behavior of execution. It's necessary to know one of the rule settings NestedRuleExecutionMode. Which changes the behavior of the rule execution. Possible values are

All - Executes all the nested rules regardless of whether the result will affect the overall result. Ex: OR Operator is used to terminate the rule execution when first true value is found. But with All setting regardless of its default behavior all the rules are executed
Performance - Executes only the rules which might affect the overall outcome. Ex: When OR Operator is used to terminate the rule execution when first true value is found. With this performance setting it will terminate when it finds the first true value.

Awesome, we just went through some important pieces of configurations which we will be using in the rest of the article to implement the Nested Rules. So, without further delay let's start the implementation part with Use Case Statement, followed by step-by-step implementation.

Use Case:

To demonstrate this functionality, let's take a use case in arcade business where we have to check the inventory of certain genre games belonging to a Platform by Gaming Studio.

When the inventory falls below a threshold for a certain set of games by platform, genre and gaming studio. We want to consider that the rule is a success.

In this article we will try to create one nested rule for Gaming Studio Microsoft and Sony.

Step by Step Implementation:

Download the base code from Github Repo.
Add a class named RestockingChainNestedRulesExample.cs into your project root folder.
Add a new JSON rule named RestockingChainNestedRules.json to your RulesFiles folder.
Add below content to the above created Json file.

[
  {
    "WorkflowName": "RestockingChainNestedRules",
    "Rules": [
      {
        "RuleName": "ActionPlaystationGameRestock1",
        "ErrorMessage": "The action game stocks for the playstation are low. Restock by 5 units",
        "ErrorType": "Error",
        "SuccessEvent": "5",
        "RuleExpressionType": "LambdaExpression",
        "Operator": "Or",
        "Rules" : [
          {
            "RuleName": "ActionPlaystationGameRestock1_sony",
            "ErrorMessage": "The action game stocks for the playstation are low. Restock by 5 units",
            "ErrorType": "Error",
            "RuleExpressionType": "LambdaExpression",
            "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\" AND x.GamingStudio == \"Sony\").Sum(x => x.Quantity) < 5",
          },
          {
            "RuleName": "ActionPlaystationGameRestock1_nonsony",
            "ErrorMessage": "The action game stocks for the playstation are low. Restock by 10 units",
            "ErrorType": "Error",
            "RuleExpressionType": "LambdaExpression",          
            "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\" AND x.GamingStudio == \"Microsoft\").Sum(x => x.Quantity) < 5",
          }
        ]
      }
    ]
  }
]

Modify the Game.cs model class under model's folder to include a new property called Quantity of type integer as show below.

namespace MsRulesEngine.Models;
public class Game {
    public string Title { get; set; } = string.Empty;
    public string Genre { get; set; } = string.Empty;
    public long Id { get; set; }
    public string Platform { get; set; } = string.Empty;    
    public string GamingStudio { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}

Lets now add some code to our new RestockingChainNestedRulesExample.cs class file as shown below.

using RE = RulesEngine;

namespace MsRulesEngine;
public class RestockingChainNestedRulesExample
{
    public static async Task Run()
    {

        string filePath = Path.Combine(Environment.CurrentDirectory, "RulesFiles", "RestockingChainNestedRules.json");
        Console.WriteLine(filePath);
        string jsonString = File.ReadAllText(filePath);

        var workflows = JsonSerializer.Deserialize<Workflow[]>(jsonString);

        var gamesInventory = new List<Game>
        {
            new() {
                Title = "Halo",
                Genre = "Action",
                Id = 1,
                Platform = "PlayStation",
                GamingStudio = "Sony",
                Price = 59.99m,
                Quantity = 1
            },
            new() {
                Title = "Yakuza",
                Genre = "Action",
                Id = 2,
                Platform = "PlayStation",
                GamingStudio = "EA",
                Price = 49.99m,
                Quantity = 2
            },
        };

        var ruleParameters = new RuleParameter[] {
        new ("input1", gamesInventory),
      };

        var settings = new ReSettings
        {
            NestedRuleExecutionMode = NestedRuleExecutionMode.Performance
        };

        RE.RulesEngine rulesEngine = new(workflows);

        var resultList = await rulesEngine.ExecuteAllRulesAsync("RestockingChainNestedRules", ruleParameters, settings);

        foreach (var result in resultList)
        {
            Console.WriteLine($"Rule: {result.Rule.RuleName}, Result: {result.IsSuccess}, Message: {result.ExceptionMessage}");
            if (result.ActionResult != null)
            {
                Console.WriteLine($"Action Result: {result.ActionResult.Output}");
            }
        }
    }

}

Modify the program.cs as shown below and execute the application.

   using MsRulesEngine;
   await RestockingChainNestedRulesExample.Run();

You will observe the below output. It returns the result as true. As game from the Sony fell below the threshold.

Advantages of Nested Rules:

Easy to have different sub expressions for a single parent rule.
Define Logical Operators between nested expressions in a more scalable and manageable way.
Breaking down the complex expressions into sub expressions.
Easy to change individual expressions on fly.

Conclusion:

In our day-to-day business, we come across many scenarios where we want to perform nested rule evaluations which we usually implement with next if else blocks. But with the Nested Rules, we can dynamically inject them to the parent Rule without cluttered and hardcoded if else blocks. Which hard to understand and change

Hope this article will help you understand the use of Nest Rules and provide you guidance to use it for your needs.

To access my source code. Please go to my GitHub Link. In my next article
I will be explaining how to create some Nested Rules with Actions and how to parse those actions. So, follow me to get notification when it is available.

To get more articles like this, please follow me to get notification when they are available.

Until then see ya soon! 😁

Lets build future AI agent to summarize long call summaries in seconds.

Vamsi Dogiparthi — Sat, 05 Jul 2025 21:41:51 +0000

Vamsi Dogiparthi

Jul 5 '25

AI Summarization Agent🧾 in 7 minutes! 🔥

#programming #ai #llm #rag

Comments

10 min read

AI Summarization Agent🧾 in 7 minutes! 🔥

Vamsi Dogiparthi — Sat, 05 Jul 2025 21:38:04 +0000

Hi Buddy! Welcome to a quick tutorial on building an AI summarization agent that will allow you to summarize lengthier meeting conversations, long pages of various concepts using Semantic Kernel & Open API (model GPT 4o).

This will be a quick tutorial aimed to be max of 7mins for you to quickly create an AI Agent.

This tutorial uses 2 major tools.

Semantic Kernel (Chat completion & Function plugins).
Open AI Account (with paid or trail use).

So, without wasting anymore time lets dive into the rest of the steps.

Prerequisites:

Create an Open AI Account.
Create a project in Open AI Account.
Add a token amount if you are choosing the paid version in the billing section.
Download Visual Studio and .NET 9 framework through this link.

Step by Step Project setup:

Create new Console Application using .NET9.
Install below necessary packages.

dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.Extensions.Logging
dotnet add package Microsoft.Extensions.Logging.Console
dotnet add package Microsoft.Extensions.Configuration.FileExtensions
dotnet add package Microsoft.Extensions.Configuration.Json
dotnet add package Microsoft.Extensions.Configuration.UserSecrets
dotnet add package Microsoft.Extensions.Configuration.CommandLine
dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables
dotnet add package Microsoft.SemanticKernel.PromptTemplates.Handlebars
dotnet add package Microsoft.SemanticKernel.Yaml

Add appsettings.json file to the project directory and add below code to the csproj project file.

<ItemGroup>
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

Add OpenAIConfiguration.cs to Options folder underneath the project.

namespace AIAgentTextSummarization.Options
{
    public class OpenAIConfiguration
    {
        public const string SectionName = "OpenAIConfiguration";
        public string Endpoint { get; set; } = string.Empty;
        public string ApiKey { get; set; } = string.Empty;
        public string ModelId { get; set; } = string.Empty;
        public int MaxTokens { get; set; }
        public double Temperature { get; set; }
        public double TopP { get; set; }
    }
}

Add TextSummarizationPlugin.cs to Plugins folder

using System.ComponentModel;
using AIAgentTextSummarization.Services;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.PromptTemplates.Handlebars;

namespace AIAgentTextSummarization.Plugins.PromptPlugins.TextSummarizationPromptPlugin;

public class TextSummarizationPromptPlugin(ILogger<TextSummarizationPromptPlugin> logger)
{
    [KernelFunction("summarize_text")]
    [Description("Summarize the given text.")]
    public async Task<FunctionResult?> GetSummarizedText(
        [Description("input text to be summarize")] string input,
        Kernel kernel
    )
    {
        var handlebarsPromptYaml = EmbeddedResource.Read("TextSummarizationYamlTemplate.yaml");
        var templateFactory = new HandlebarsPromptTemplateFactory();
        var function = kernel.CreateFunctionFromPromptYaml(handlebarsPromptYaml, templateFactory);

        var arguments = new KernelArguments() { { "input", input } };

        var response = await kernel.InvokeAsync(function, arguments);
        logger.LogInformation("Response: {Response}", response);
        return response;
    }
}

Add TextSummarizationPromptTemplate.yaml to Plugins -> PromptPlugins -> TextSummarizationPromptPlugin folder.

name: SummarizeInformation
template: |
  <message role="system">
      # System Instructions
      You are a expert text summarizer. Your task is to summarize the information provided in the conversation history into key points.
      You should focus on the most important details and present them in a clear and concise manner.
      The summary should categorize the 7 main sections: 
      Acronyms, Glossary, Problem Statement, Description, Key Points, Entities (Location, people, places, Books), Next Steps.
      Each section should be clearly labeled and the information should be presented in a bullet point format.

      Each section should have atmost 5 bullet points.
      The summary should be no more than 200 words in total.

      You should also correct any grammar and spelling errors in the history.
      The summary should be in English.
      The summary should be in a professional tone and should not include any personal opinions or subjective statements.

      # Safety
      - Don't use any bad words, hateful tone, angy tone, sad tone.
      - Don't use any sensitive information, or confidential information.         

      # Example Input starts here:
      - Bruce: These days people are so busy with their work that they don't have time to read books and know about the history
      - Wayne: Yes, I agree. I think it's important to take time to read and learn about our history. We are what we are because of our past.
      - Bruce: I think we should make it a point to read at least one book a month. It can be about anything, but it should be something that teaches us something new.
      - Wayne: That's a great idea! I will try to do that. I think it will help us grow as individuals and as a society.
      - Bruce: I read about different cultures and their history, expecially native indian culture. I think it's important to understand and appreciate the diversity of our world.
      - Wayne: Yes, I agree. Understanding different cultures can help us become more empathetic and open-minded. It can also help us appreciate the beauty of our world.
      - Marry: I think we should also make an effort to learn about the history of our own culture and heritage. It's important to know where we come from and what has shaped us as a people.
      - Bruce: Yes, I agree. I think it's important to have a strong sense of identity and to understand our roots. It can help us navigate the world and make informed decisions about our future.
      - Wayne: We should also learn about historical places like the pyramids and the great wall of china. They are not only important landmarks, but they also tell us a lot about the cultures and civilizations that built them.
      # Example Input ends here.
      # Example Output Starts Here:
      -Acronyms:
          - N/A
      -Glossary:
          - Empathy: The ability to understand and share the feelings of another.
          - Heritage: Property that is or may be inherited; an inheritance.
          - Culture: The ideas, customs, and social behavior of a particular people or society.
          - Diversity: The state of being diverse; variety.
      - Problem Statement:
          - People are busy with work and don't have time to read books.
          - Importance of reading and learning about history.
          - Suggestion to read at least one book a month.
          - Learn about historical places and cultures.
          - Understanding different cultures can help us become more empathetic.
      - Key Points:
          - People are busy with work and don't have time to read books.
          - Importance of reading and learning about history.
          - Suggestion to read at least one book a month.
          - Understanding different cultures can help us become more empathetic.
          - Importance of learning about our own culture and heritage.
      - Description:
          - People are busy with work and don't have time to read books.
          - Importance of reading and learning about history.
          - Suggestion to read at least one book a month.
          - Understanding different cultures can help us become more empathetic.
          - Importance of learning about our own culture and heritage.
      - Entities:
            - Locations: China
            - People: Bruce, Wayne, Marry
            - Places: Pyramids, Great Wall of China
            - Books: Great wall of china, george washignton, native indian culture
      - Next Steps: 
            - Make it a point to read at least one book a month.
            - Learn about different cultures and their history.
            - Understand and appreciate the diversity of our world.
            - Learn about the history of our own culture and heritage.
            - Learn about historical places like the pyramids and the great wall of china.
        #Example Output ends Here
  </message>
  <message role="user">
        {{input}}
  </message>
template_format: handlebars
description: Contoso chat prompt template.
input_variables:
  - name: input
    description: user message to be summarized.
    is_required: true
    allow_dangerously_set_content : false
output_variable:
  description: The summarized information.
execution_settings:
  service1:
    model_id: gpt-4o
    temperature: 0.6
  default:
    temperature: 0.5

Add conversation.txt as our conversation sample to be used for this text summarization project under Assets folder

**Conversation:**

**Emma:** *Alright everyone, today’s family picnic turned into a history class. But that’s okay, isn’t it?* Look at this—Statue of Liberty! It’s stunning, isn’t it?

**Ryan:** *Yeah, it’s alright,* but don’t you think some monuments are... um... boring? Like, why do we even care about something from, like, the 1800s?

**Maya:** *Oh, Ryan!* You youngsters have so much to learn. The Statue of Liberty, gifted by France in 1886, represents freedom and democracy. Imagine the stories it witnessed over time. You can't call that boring!

**Ethan:** Maya has a point. But Ryan does, too, in a way. How do we make kids care about these landmarks? Shouldn’t we use tech, like VR, to let them experience the history?

**Emma:** I think Ethan’s onto something. Virtual reality tours of places like the Colosseum in Rome or the Pyramids in Egypt could be fascinating. But Ryan, why do you find history boring?

**Ryan:** *I mean,* it just feels... distant, you know? Like, I know George Washington led battles, but, like, how does that matter to me?

**Maya:** It matters because it’s part of your identity, Ryan. History tells us where we came from. Without it, culture fades. Have you been to the Alamo in Texas? It's a reminder of resilience and sacrifice. Without those stories, how will we learn courage?

**Ethan:** True, but here's a problem—many monuments, like the Taj Mahal, are decaying because of pollution and neglect. Shouldn't we focus on fixing that first?

**Emma:** *Absolutely!* I read last week about how smog is damaging India’s Taj Mahal. It’s heart-wrenching. Preserving monuments must go hand-in-hand with teaching their value. Any ideas, Ryan?

**Ryan:** Maybe we could, like, organize cleanups or raise funds for conservation? Schools could include those activities so we, um, actually feel involved.

**Maya:** That’s a wonderful idea, Ryan! Did you know during the 1940s, the Mount Rushmore National Memorial was improved as part of a community-driven effort? It’s proof that every little action helps.

**Ethan:** And not just local action. Global awareness is key. Social media could spotlight these issues. Imagine a campaign encouraging people worldwide to protect the Great Wall of China.

**Emma:** Let’s not forget to highlight the cultural aspect too. I once took a trip to Kyoto, Japan, and visited the Fushimi Inari Shrine. Learning about its spiritual significance deeply moved me. We must keep those cultural stories alive.

**Maya:** So, the problem is clear. Awareness, preservation, education—*all* need attention. The solution? A mix of passion, action, and modern tools, just like you all suggested.

**Ryan:** I guess you’re right. I mean, the Golden Gate Bridge wouldn’t be the same if it crumbled away, huh? Alright, I’m in. Let’s save some history!

**Ethan:** That’s the spirit, Ryan! History doesn’t have to stay in dusty textbooks. We can make it alive for everyone!

**Emma:** And that’s the beauty of culture—it connects us across time. Let’s plan something. Maybe we can start with a local landmark?

**Maya:** Perfect idea! How about a visit to Fort Ticonderoga? It’s close by, rich in history, and we can brainstorm ways to help.

---

**End of Conversation**

We are using EmbeddedResource approach to attach these assets & resources to cs.proj and read them when needed using below EmbeddedResource Service Class.

using System.Reflection;

namespace AIAgentTextSummarization.Services;

public static class EmbeddedResource
{
    public static string Read(string resourceName)
    {
        var assembly = Assembly.GetExecutingAssembly();
        var resourcePath =
            assembly
                .GetManifestResourceNames()
                .FirstOrDefault(name =>
                    name.EndsWith(resourceName, StringComparison.OrdinalIgnoreCase)
                ) ?? throw new FileNotFoundException($"Resource '{resourceName}' not found.");
        using var stream =
            assembly.GetManifestResourceStream(resourcePath)
            ?? throw new FileNotFoundException($"Resource stream for '{resourceName}' is null.");
        using var reader = new StreamReader(stream);
        return reader.ReadToEnd();
    }
}

Attach the yaml template & example conversation .txt to the .csproj

  <ItemGroup>
    <EmbeddedResource Include="Plugins\PromptPlugins\TextSummarizationPromptPlugin\TextSummarizationYamlTemplate.yaml" />
    <EmbeddedResource Include="Assets\Conversation.txt" />
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

We will be using a separate class called Brain.cs to perform our text summarization. So, please create it under Brain folder with below content

using AIAgentTextSummarization.Services;

namespace AIAgentTextSummarization.Brain;

public interface IBrain
{
    Task Run(Kernel kernel);
}

public class Brain(ILogger<Brain> logger) : IBrain
{
    public async Task Run(Kernel kernel)
    {
        logger.LogInformation("Starting AI Agent Text Summarization...");
        var conversation = EmbeddedResource.Read("Conversation.txt");

        var result = await kernel.InvokeAsync(
            "TextSummarizationPromptPlugin",
            "summarize_text",
            new KernelArguments() { { "input", conversation } }
        );

        logger.LogInformation("Result: {Result}", result.ToString());
    }
}

I like to use globalusings for common namespaces to keep the class files lean. Please create GlobalUsings.cs under you root project folder with namespaces.

global using Microsoft.Extensions.Configuration;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Logging;
global using Microsoft.SemanticKernel;
global using Microsoft.SemanticKernel.ChatCompletion;

Finally, lets setup our program.cs file with below code to run our project.

// See https://aka.ms/new-console-template for more information
using AIAgentTextSummarization.Brain;
using AIAgentTextSummarization.Options;
using AIAgentTextSummarization.Plugins.FunctionPlugins.TimePlugin;
using AIAgentTextSummarization.Plugins.PromptPlugins.TextSummarizationPromptPlugin;

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
    .AddUserSecrets<Program>(optional: true)
    .AddEnvironmentVariables()
    .Build();

var kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.Services.AddLogging(loggingBuilder =>
    loggingBuilder.AddConsole().AddConfiguration(configuration.GetSection("Logging"))
);

kernelBuilder.Services.AddOptions();
kernelBuilder.Services.Configure<OpenAIConfiguration>(
    configuration.GetSection(OpenAIConfiguration.SectionName)
);

kernelBuilder.Services.AddTransient<IBrain, Brain>();

var openAIConfiguration =
    configuration.GetSection(OpenAIConfiguration.SectionName).Get<OpenAIConfiguration>()
    ?? throw new Exception("OpenAI configuration is missing");

kernelBuilder.Services.AddOpenAIChatCompletion(
    openAIConfiguration.ModelId,
    openAIConfiguration.ApiKey
);

var kernel = kernelBuilder.Build();
kernel.Plugins.AddFromType<TimePlugin>();
kernel.ImportPluginFromType<TextSummarizationPromptPlugin>(); 

var logger = kernel.GetRequiredService<ILogger<Program>>();
logger.LogInformation("Starting the AI Calendar Agent");
await kernel.GetRequiredService<IBrain>().Run(kernel);

Before running your project, please make sure appsettings.json file which was added to our project directory has values to below settings.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Information",
      "Microsoft.Hosting.Lifetime": "Information"
    },
    "Console": {
      "LogLevel": {
        "Default": "Information",
        "Microsoft.Hosting.Lifetime": "Information"
      }
    }
  },
  "OpenAIConfiguration": {
    "ModelId": "gpt-4o",
    "ApiKey": "api-key",
    "Endpoint": "api-endpoint"
  },
}

Run the program.cs using dotnet run command. You will see the below output

Result: 
- Acronyms:
  - VR: Virtual Reality

- Glossary:
  - Monuments: Structures created to commemorate a person or event.
  - Preservation: The act of maintaining something in its original or existing state.
  - Conservation: The protection and care of natural resources and cultural heritage.
  - Resilience: The capacity to recover quickly from difficulties; toughness.

- Problem Statement:
  - Many people, especially younger generations, find historical monuments boring or irrelevant.
  - Monuments like the Taj Mahal are decaying due to pollution and neglect.
  - There is a lack of awareness and modern engagement with historical sites.

- Description:
  - Discussion on making history engaging for younger generations using modern tools like VR.
  - Importance of preserving monuments and integrating cultural education.
  - Suggestions for organizing community-driven efforts for conservation.
  - Emphasis on global awareness and social media campaigns for monument preservation.

- Key Points:
  - The Statue of Liberty symbolizes freedom and democracy.
  - Integrating tech, such as VR, to make history engaging.
  - Need for preservation and conservation of historical sites.
  - Importance of cultural education and community involvement.
  - Potential for social media to raise global awareness.

- Entities:
  - Locations: Statue of Liberty, Colosseum, Pyramids, Alamo, Taj Mahal, Great Wall of China, Kyoto, Fushimi Inari Shrine, Golden Gate Bridge, Fort Ticonderoga
  - People: Emma, Ryan, Maya, Ethan
  - Places: France, Rome, Egypt, Texas, India, Japan, China

- Next Steps:
  - Organize cleanups or fundraisers for monument conservation.
  - Plan visits to local landmarks, like Fort Ticonderoga, to brainstorm preservation efforts.
  - Utilize social media for global awareness campaigns.
  - Incorporate VR tours into educational curricula.
  - Foster community involvement in cultural and historical education.

Concepts Showcased:

Function Invocation through kernel.
Handlebars prompt template using YAML schema for prompt plugins.
Injecting KernelArguments into Prompt templates.
Seperation of Concerns
.NET Dependency Injection.
.NET Options Pattern.
Natural Language Processing & Natural Language Understanding.
Text Summarization, grammar correction.

Conclusion:

Using powerful sematic kernel, we can easily create NLP, NLU based AI Agents on fly with few simple steps and configurations for very common use cases such as the one showed in this article. With minimal effort we can reduce our workload, processing times and improve efficiency. Hope this tutorial can help you get started to build your own AI Agent.

To get access to my source code. Please visit this GitHub link.

To get more tutorials🧾 like this! Follow me! see ya 👋!

🧑‍💻AI Calendar🗓️Agent in 7 minutes! 🔥

Vamsi Dogiparthi — Wed, 12 Mar 2025 11:55:42 +0000

Hi Buddy! Welcome to a quick tutorial on building an AI Calendar agent that will allow you to create calendar events using Semantic Kernel, Google Calendar APIs & Open API (model GPT 4o).

This will be a quick tutorial aimed to be max of 7mins for you to quickly create an AI Agent.

This tutorial uses three major tools.

Semantic Kernel (Chat completion & Function plugins)
Google Workspace (Google Calendar APIs)
Open AI Account (with paid or trail use)

So, without wasting anymore time lets dive into the rest of the steps.

Prerequisites:

Create an Open AI Account.
Create a project in Open AI Account.
Add a token amount if you are choosing the paid version in the billing section.
Create new Google Workspace Project.
Enable Google Workspace APIs | Google for Developers
We are going to use Service to Service Authentication flow for this AI Agent as it will be a console application. So, create a service account.

Once Service account is created, add keys as shown below. Choose JSON as the option. This will download a JSON key into your machine. Name it as apikey.json. Which we will be using later in our agent building process.

Download Visual Studio and .NET 9 framework through this link.

Step by Step Project setup:

Create new Console Application using .NET9.
Install below necessary packages.

dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.Extensions.Logging
dotnet add package Microsoft.Extensions.Logging.Console
dotnet add Microsoft.Extensions.Configuration.FileExtensions
dotnet add Microsoft.Extensions.Configuration.Json
dotnet add Microsoft.Extensions.Configuration.UserSecrets
dotnet add Microsoft.Extensions.Configuration.CommandLine
dotnet add Microsoft.Extensions.Configuration.EnvironmentVariables
dotnet add Google.Apis.Calendar.v3
dotnet add Google.Apis.Auth

Add appsettings.json file to the project directory and add below code to the csproj project file.

<ItemGroup>
    <None Update="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

Add the downloaded apikey.json into the project folder.
Create a new CalendarService.cs class under Services folder.

using AICalendarAgent.Configurations;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Calendar.v3.Data;
using Microsoft.Extensions.Options;

namespace AICalendarAgent.Services;

public interface ICalendarService
{
    Task CreateEventAsync(
        string title,
        string description,
        DateTimeOffset startTime,
        DateTimeOffset endTime
    );

    Task<List<CalendarListEntry>> GetMyCalendarList();
}

public class CalendarService(
    IOptions<GoogleCalendarAPISettings> options,
    ILogger<CalendarService> logger
) : ICalendarService
{
    public async Task<List<CalendarListEntry>> GetMyCalendarList()
    {
        // Google credential for getting service account tokens
        var googleCredential = GetGoogleCredential();
        var service = new Google.Apis.Calendar.v3.CalendarService(
            new Google.Apis.Services.BaseClientService.Initializer
            {
                HttpClientInitializer = googleCredential,
                ApplicationName = options.Value.ApplicationName,
            }
        );

        var request = service.CalendarList.List();
        var calendarList = await request.ExecuteAsync();

        return [.. calendarList.Items];
    }

    public async Task CreateEventAsync(
        string title,
        string description,
        DateTimeOffset startTime,
        DateTimeOffset endTime
    )
    {
        // Google credential for getting service account tokens
        var googleCredential = GetGoogleCredential();

        // authentication flow for the google calendar using user auth token
        // var credential = await GoogleWebAuthorizationBroker.AuthorizeAsync(
        //     new ClientSecrets
        //     {
        //         ClientId = options.Value.ClientId,
        //         ClientSecret = options.Value.ClientSecret,
        //     },
        //     options.Value.Scopes,
        //     options.Value.User,
        //     CancellationToken.None
        // );

        var service = new Google.Apis.Calendar.v3.CalendarService(
            new Google.Apis.Services.BaseClientService.Initializer
            {
                HttpClientInitializer = googleCredential,
                ApplicationName = options.Value.ApplicationName,
            }
        );

        var newEvent = new Event
        {
            Summary = title,
            Description = description,
            Start = new EventDateTime
            {
                DateTimeDateTimeOffset = startTime,
                TimeZone = "America/Los_Angeles",
            },
            End = new EventDateTime
            {
                DateTimeDateTimeOffset = endTime,
                TimeZone = "America/Los_Angeles",
            },
        };

        // Create an event in the calendar
        var request = service.Events.Insert(newEvent, options.Value.CalendarId);
        var createdEvent = await request.ExecuteAsync();

        logger.LogInformation(
            $"Event created: {title} - {description} - {startTime} - {endTime} - {createdEvent.HtmlLink}"
        );
    }

    // common code to create Google credential for service account
    protected GoogleCredential GetGoogleCredential()
    {
        GoogleCredential googleCredential;
        using var stream = new FileStream(
            Path.Combine(
                Directory.GetCurrentDirectory(),
                "apikey.json"
            ),
            FileMode.Open,
            FileAccess.Read
        );
        googleCredential = GoogleCredential.FromStream(stream).CreateScoped(options.Value.Scopes);
        return googleCredential;
    }
}

Add a new class called Brain.cs to folder Brain. Then add below code.

using AICalendarAgent.Configurations;
using Microsoft.Extensions.Options;

namespace AICalendarAgent.Brain;

public interface IBrain
{
    Task Run(Kernel kernel);
}

public class Brain(IServiceProvider serviceProvider, ILogger<Brain> logger) : IBrain
{
    public async Task Run(Kernel kernel)
    {
        var chatCompletionService = serviceProvider.GetRequiredService<IChatCompletionService>();

        OpenAIPromptExecutionSettings openAIPromptExecutionSettings = new()
        {
            FunctionChoiceBehavior = FunctionChoiceBehavior.Auto(),
        };

        var history = new ChatHistory();

        history.AddUserMessage(
            "Can you add an event in my Google Calendar with the title 'Meeting with John' "
                + "starting at 3 PM and ending at 4 PM EST on March 14th 2025?"
        );

        var result = await chatCompletionService.GetChatMessageContentAsync(
            history,
            executionSettings: openAIPromptExecutionSettings,
            kernel: kernel
        );

        logger.LogInformation("AI Response: {Response}", result.Content ?? "No response");
        history.AddMessage(result.Role, result.Content ?? "No response");
    }
}

Add a new Function Plugin CalendarPlugin.cs under Brain/Plugins/FunctionPlugins folder with below code.

using System.ComponentModel;
using AICalendarAgent.Services;
using Google.Apis.Calendar.v3.Data;

namespace AICalendarAgent.Brain.Plugins.FunctionPlugins;

public class CalendarPlugin(ICalendarService calendarService)
{
    private readonly ICalendarService _calendarService = calendarService;

    [KernelFunction("create_google_calendar_event")]
    [Description("Create an event in the Google Calendar.")]
    public async Task CreateGoogleCalendarEvent(
        string title,
        string description,
        DateTimeOffset startTime,
        DateTimeOffset endTime
    )
    {
        await _calendarService.CreateEventAsync(title, description, startTime, endTime);
    }

    [KernelFunction("get_my_calendar_list")]
    [Description("Get the list of calendars.")]
    public async Task<List<CalendarListEntry>> GetMyCalendarList()
    {
        return await _calendarService.GetMyCalendarList();
    }
}

Now, let's setup configuration classes GoogleCalendarAPISettings.cs & OpenAIConfiguration.cs with below code to hold strongly typed configuration values for two important APIs.

namespace AICalendarAgent.Configurations;

public class OpenAIConfiguration
{
    public const string SectionName = "OpenAIConfiguration";
    public string ApiKey { get; set; } = string.Empty;
    public string ModelId { get; set; } = string.Empty;
    public string Endpoint { get; set; } = string.Empty;
}

namespace AICalendarAgent.Configurations;

public class GoogleCalendarAPISettings
{
    public const string SectionName = "GoogleCalendarAPISettings";
    public string ClientId { get; set; } = string.Empty;
    public string ClientSecret { get; set; } = string.Empty;
    public string[] Scopes { get; set; } = [];
    public string RedirectUri { get; set; } = string.Empty;
    public string CalendarId { get; set; } = string.Empty;
    public string ApplicationName { get; set; } = string.Empty;
    public string User { get; set; } = string.Empty;
    public string[] Attendees { get; set; } = [];
}
- Now, let’s inject our services, plugins, settings and our running code to `program.cs`

using AICalendarAgent.Brain;
using AICalendarAgent.Brain.Filters;
using AICalendarAgent.Brain.Plugins.FunctionPlugins;
using AICalendarAgent.Configurations;
using AICalendarAgent.Services;

var configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
    .AddEnvironmentVariables()
    .AddUserSecrets<Program>()
    .AddCommandLine(args)
    .Build();

var builder = Kernel.CreateBuilder();

builder.Services.AddLogging(configure => configure.AddConsole().SetMinimumLevel(LogLevel.Trace));
builder.Services.AddSingleton<IConfiguration>(configuration);
builder.Services.AddOptions();
builder.Services.Configure<OpenAIConfiguration>(
    configuration.GetSection(OpenAIConfiguration.SectionName)
);
builder.Services.Configure<GoogleCalendarAPISettings>(
    configuration.GetSection(GoogleCalendarAPISettings.SectionName)
);

builder.Services.AddScoped<ICalendarService, CalendarService>();
builder.Services.AddTransient<IBrain, Brain>();

var openAIConfiguration =
    configuration.GetSection(OpenAIConfiguration.SectionName).Get<OpenAIConfiguration>()
    ?? throw new Exception("OpenAI configuration is missing");

var googleCalendarSettings =
    configuration.GetSection(GoogleCalendarAPISettings.SectionName).Get<GoogleCalendarAPISettings>()
    ?? throw new Exception("GoogleCalendarAPISettings configuration is missing");

// var azureOpenAIConfiguration =
//     configuration.GetSection(AzureOpenAIConfiguration.SectionName).Get<AzureOpenAIConfiguration>()
//     ?? throw new Exception("Azure OpenAI configuration is missing");

// below is for the azure openai chat completion
// builder.AddAzureOpenAIChatCompletion(
//     azureOpenAIConfiguration.ModelId,
//     azureOpenAIConfiguration.Endpoint,
//     azureOpenAIConfiguration.ApiKey
// );

builder.AddOpenAIChatCompletion(openAIConfiguration.ModelId, openAIConfiguration.ApiKey);

var kernel = builder.Build();
kernel.ImportPluginFromType<CalendarPlugin>(); // Add CalendarPlugin to the kernel. Use ImportPluginFromType instead of AddPluginFromType if you have services to be injected.

var logger = kernel.GetRequiredService<ILogger<Program>>();
logger.LogInformation("Starting the AI Calendar Agent");
await kernel.GetRequiredService<IBrain>().Run(kernel);

Let’s setup our appsettings.json file with below information

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "OpenAIConfiguration": {
    "ModelId": "gpt-4o",
    "ApiKey": "[YourKey]"    
  },

  "AzureOpenAIConfiguration": {
    "ModelId": "gpt-4o",
    "ApiKey": "[YourKey]",
    "Endpoint": "[YourEndpoint]"
  },

  "GoogleCalendarAPISettings": {
    "ClientId": "YourClientId", // only if you are using user oauth flow
    "ClientSecret": "YouClientSecret", // only if you are using user oauth flow
    "Scopes": [
      "https://www.googleapis.com/auth/calendar.readonly",
      "https://www.googleapis.com/auth/calendar.events.readonly",
      "https://www.googleapis.com/auth/calendar.events",
      "https://www.googleapis.com/auth/calendar"
    ],
    "ApplicationName": "AICalendarAgent",
    "RedirectUri": "http://localhost:5000/signin-google", // only if you are using user oauth flow
    "CalendarId": "[YourPersonalCalendarId]", // you personal calendar ID shared with your service account
    "User": "user", // only if you are using user oauth flow
  }
}

Let’s share your personal calendar with calendar Id mentioned above in appsettings.json file to your service account email from apikey.json file downloaded as part of step 7 of prerequisites.

Now, let's run the code using dotnet run & you will see the below output as well as a new event should be created on your calendar. The one you shared with the service account.

Concepts Showcased:

OAuth client credential flow with Google Calendar API.
Function Plugins & Auto Function Invocation from semantic kernel.
Chat completion with GPT 4o + semantic kernel.
.NET Dependency Injection.
.NET Options Pattern.
Natural Language Processing & Natural Language Understanding.
Process automation

Conclusion:

Using powerful sematic kernel, we can easily create NLP based AI Agents on fly with few simple steps and configurations. These agents are powerful to automate redundant tasks by connecting to your environment, existing code, existing APIs together.

To get access to my source code. Please visit this GitHub link. Hope this tutorial can help you get started to build your own AI Agent.

To get more tutorials🧾 like this! Follow me! see ya 👋!

Understanding MS Rules Engine In-Built Post Rule Actions — Part 4

Vamsi Dogiparthi — Mon, 24 Feb 2025 18:57:56 +0000

Hi Buddy! Welcome back to the part 4 of the MS Rules Engine series. In this article we will be concentrating on how to use different in-built post rule action to create a chain of rule executions.

So, lets dive into the next steps.

Configuring EvaluateRule built-in action

In this section, let’s explore how to configure EvaluateRule built-in action to create a chain of rule executions where you want to execute set of rules one after the other during OnSuccess or OnFailure of the parent rule.

Use Case:

To demonstrate this functionality, let’s take a use case we used in the previous article. which is in arcade business where we have to check the inventory of certain genre games belonging to a platform

When the inventory falls below a threshold, we want to calculate the quantity of games that we need to reorder for the genre and platform in question.

In this article we will try to create two level nested rule for quantity falling below 10 and 5.

Step by Step Implementation:

Download the base code from Github Repo.
Add a class named RestockingChainRulesExample.cs into your project root folder.
Add a new JSON rule named RestockingChainRules.json to your RulesFiles folder.
Add below content to the above created Json file.

[
  {
    "WorkflowName": "RestockingChainRules",
    "Rules": [
      {
        "RuleName": "ActionPlaystationGameRestock1",
        "ErrorMessage": "The action game stocks for the playstation are low. Restock by 5 units",
        "ErrorType": "Error",
        "SuccessEvent": "5",
        "RuleExpressionType": "LambdaExpression",
        "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\").Sum(x => x.Quantity) < 5",
        "Actions": {
          "OnSuccess": {
            "Name": "OutputExpression",
            "Context": {
              "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\").Sum(x => x.Quantity) * 5"
            }
          },
          "OnFailure": {
            "Name": "EvaluateRule",
            "Context": {
              "workflowName": "RestockingChainRules",
              "ruleName": "ActionPlaystationGameRestock2"
            }
          }
        }
      },
      {
        "RuleName": "ActionPlaystationGameRestock2",
        "ErrorMessage": "The action game stocks for the playstation are low. Restock by 10 units",
        "ErrorType": "Error",
        "SuccessEvent": "10",
        "RuleExpressionType": "LambdaExpression",
        "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\").Sum(x => x.Quantity) < 10",
        "Actions": {
          "OnSuccess": {
            "Name": "OutputExpression",
            "Context": {
              "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\").Sum(x => x.Quantity) * 10"
            }
          }
        }
      }
    ]
  }
]

Modify the Game.cs model class under model's folder to include a new property called Quantity of type integer as show below.

namespace MsRulesEngine.Models;
public class Game {
    public string Title { get; set; } = string.Empty;
    public string Genre { get; set; } = string.Empty;
    public long Id { get; set; }
    public string Platform { get; set; } = string.Empty;    
    public string GamingStudio { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}

Lets now add some code to our new RestockingChainRulesExample.cs class file as shown below.

using RE = RulesEngine;

namespace MsRulesEngine;
public class RestockingChainRulesExample
{
    public static async Task Run()
    {

        string filePath = Path.Combine(Environment.CurrentDirectory, "RulesFiles", "RestockingChainRules.json");
        Console.WriteLine(filePath);
        string jsonString = File.ReadAllText(filePath);

        var workflows = JsonSerializer.Deserialize<Workflow[]>(jsonString);


        var gamesInventory = new List<Game>
        {
            new() {
                Title = "Halo",
                Genre = "Action",
                Id = 1,
                Platform = "PlayStation",
                GamingStudio = "Sony",
                Price = 59.99m,
                Quantity = 5
            },
            new() {
                Title = "Yakuza",
                Genre = "Action",
                Id = 2,
                Platform = "PlayStation",
                GamingStudio = "EA",
                Price = 49.99m,
                Quantity = 2
            },
        };

        var ruleParameters = new RuleParameter[] {
        new ("input1", gamesInventory),
      };


        RE.RulesEngine rulesEngine = new(workflows);

        var result = await rulesEngine.ExecuteActionWorkflowAsync("RestockingChainRules", "ActionPlaystationGameRestock1", ruleParameters);


        Console.WriteLine($"Rule: {result.Output}");
    }

}

Modify the program.cs as shown below and execute the application.

// See https://aka.ms/new-console-template for more information

using MsRulesEngine;

await RestockingChainRulesExample.Run();

You will observe the below output. It calculates 10 as restock quantity for PlayStation Action games and 50 for Xbox RPG games.

Advantages of EvaluateRule:

You execute chain of rules to find the matching one.
Easy to change the rule chaining process.
Can be mixed with OutputExpression action to stop the chain execution and terminal condition.

Conclusion:

In our day-to-day business, we come across many scenarios where we want to perform various calculations or return different outputs out of a rule execution based on its OnSuccess and OnFailure we want to usually check if there are any sub rules it satisfies as shown in the current article.

This dynamic behavior helps us perform appropriate chaining process. Also, because of its dynamic nature we can easily change the chaining process as the business changes.

Hope this article will help you understand the use of built-in EvaluateRule Action and provide you guidance to use it for your needs.

To access my source code. Please go to my Github Link. In my next article I will explain about Nested Rules. Please don’t forget to check it out.

To get more articles like this, please follow me to get notification when it is available.

Until then see ya soon! 😁

Understanding MS Rules Engine In-Built Post Rule Actions — Part 3

Vamsi Dogiparthi — Wed, 12 Feb 2025 17:43:47 +0000

Hi Buddy! Welcome back to the part 3 of the MS Rules Engine series. In this article we will be concentrating on how to use different in-built post rule actions to return different action outputs or to create a chain of rule executions.

In this article we will learn how to configure one of the two different types of built-in post rule action execution that are shipped with MSRules Engine. So, lets dive into the next steps.

Configuring OuputExpression built-in action

In this section, let's explore how to configure OutputExpression to execute lambda expressions to produce different outputs on success and failure of a rule.

Use Case:

To demonstrate this functionality, let's take a use case in our arcade business where we have to check the inventory of certain genre games belonging to a platform.

When the inventory falls below a threshold, we want to calculate the quantity of games that we need to reorder for the genre and platform in question.

Step by Step Implementation:

Download the base code from Github Repo.
Add a class named RestockingRulesExample.cs into your project root folder.
Add a new JSON rule named RestockingRules.json to your RulesFiles folder.
Add below content to the above created json file.

[
    {
      "WorkflowName": "RestockingRules",
      "Rules": [
        {
          "RuleName": "ActionPlaysationGameRestock1",      
          "ErrorMessage": "The action game stocks for the playstation are low. Restock by 5 units", 
          "ErrorType": "Error",
          "SuccessEvent": "5",
          "RuleExpressionType": "LambdaExpression",
          "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\").Sum(x => x.Quantity) < 5",
          "Actions": {
            "OnSuccess": {
              "Name": "OutputExpression",
              "Context": {
                "Expression": "input1.Where(x => x.Genre == \"Action\" AND x.Platform == \"PlayStation\").Sum(x => x.Quantity) * 5"
              }
            }
          }
        },
        {
          "RuleName": "RPGXboxGameRestock1",          
          "ErrorMessage": "The RPG game stocks for the Xbox are low. Restock by 10 units",
          "ErrorType": "Error",
          "RuleExpressionType": "LambdaExpression",
          "SuccessEvent": "10",
          "Expression": "input1.Where(x => x.Genre == \"RPG\" AND x.Platform == \"Xbox\").Sum(x => x.Quantity) < 10",
          "Actions": {
            "OnSuccess": {
              "Name": "OutputExpression",
              "Context": {
                "Expression": "input1.Where(x => x.Genre == \"RPG\" AND x.Platform == \"Xbox\").Sum(x => x.Quantity) * 10"
              }
            }
          }
        }
      ]
    }
  ]

Modify the Game.cs model class under model's folder to include a new property called Quantity of type integer as show below.

namespace MsRulesEngine.Models;
public class Game {
    public string Title { get; set; } = string.Empty;
    public string Genre { get; set; } = string.Empty;
    public long Id { get; set; }
    public string Platform { get; set; } = string.Empty;    
    public string GamingStudio { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}

Lets now add some code to our new RestockingRulesExample.cs class file as shown below.

using RE = RulesEngine;

namespace MsRulesEngine;
public class RestockingRulesExample
{
    public static async Task Run()
    {


        string filePath = Path.Combine(Environment.CurrentDirectory, "RulesFiles", "RestockingRules.json");
        Console.WriteLine(filePath);
        string jsonString = File.ReadAllText(filePath);

        var workflows = JsonSerializer.Deserialize<Workflow[]>(jsonString);

        var gamesInventory = new List<Game>
        {
            new() {
                Title = "Halo",
                Genre = "Action",
                Id = 1,
                Platform = "PlayStation",
                GamingStudio = "Sony",
                Price = 59.99m,
                Quantity = 2
            },
            new() {
                Title = "Yakuza",
                Genre = "RPG",
                Id = 2,
                Platform = "Xbox",
                GamingStudio = "EA",
                Price = 49.99m,
                Quantity = 5
            },
            new() {
                Title = "Persona 5",
                Genre = "Sports",
                Id = 3,
                Platform = "Xbox",
                GamingStudio = "EA",
                Price = 49.99m,
                Quantity = 6
            }
        };

        RE.RulesEngine rulesEngine = new(workflows);

        var resultList = await rulesEngine.ExecuteAllRulesAsync("RestockingRules", gamesInventory);

        foreach (var result in resultList)
        {
            Console.WriteLine($"Rule: {result.Rule.RuleName}, Result: {result.IsSuccess}, Message: {result.ExceptionMessage}");
            if (result.ActionResult != null)
            {
                Console.WriteLine($"Action Result: {result.ActionResult.Output}");
            }
        }
    }

}

Modify the program.cs as shown below and execute the application.

// See https://aka.ms/new-console-template for more information

using MsRulesEngine;

//await SimpleDiscountRules.Run();
await RestockingRulesExample.Run();

You will observe the below output. It calculates 10 as restock quantity for PlayStation Action games and 50 for Xbox RPG games.

Advantages of OutputExpression:

Calculation expression can be configured on runtime using json file.
Can use complex lambda expressions in the json file to calculate the output.
Can define different action results on success and failure of a rule or set of rules.
No code change needed to change the calculation expression.
Less turnaround time

Conclusion:

In our day-to-day business, we come across many scenarios where we want to perform various calculations or return different outputs out of a rule execution based on its status such as OnSuccess and OnFailure.

This dynamic behavior helps us take appropriate follow up actions. Also, because of its dynamic nature we can easily change these calculations as our business changes.

Hope this article will help you understand the use of built-in OutputExpression Action and provide you guidance to use it for your needs.

To access my source code. Please go to my Github Link.

If you are learning from articles and want to stay tuned of my future articles, please like this article and follow me!

Until then see ya soon! 😁

Implementing MS Rules Engine with Sqlite DB + EFCore — Part 2

Vamsi Dogiparthi — Tue, 11 Feb 2025 03:00:52 +0000

Hello Coding Buddy! 😊 Welcome to the continuation of my previous article about getting started with Building A JSON Rules Engine from Scratch with MSRulesEngine — Part 1. If you haven’t checked it out. Please do so before continuing with current article.

In this Article, we will modify our MSRuleEngine to load the JSON rules from Database (Sqlite) using EF core and inject them into the RulesEngine Wrapper. This is to demonstrate that the rules can be saved from database and can be loaded when needed in JSON format to be used by your application.

Note: The JSON Rules can be saved in the DB in many ways. You can use the built-in RulesEngine.Models as your DB models or save those rules as JSON inside one of your table columns etc. In this article I am taking the second approach to keep it simple for our learning. I will create another article explaining how to use built-in models to achieve the same.

So, now we had setup some expectations we can dig into actual implementation of this integration. Let's implement/learn it together.

Step by Step Instructions:

Download the base code from Github Repo.
Install below packages to your downloaded console application.

 <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.1" />
 <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.1" />
 <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.1">

Modify your Arcade.cs class under Models folder as shown below.

namespace MsRulesEngine.Models;
public class Arcade {
    public string Name { get; set; } = string.Empty;
    public long Id { get; set; }
    public string Workflows { get; set; } = string.Empty;
}

Create a class named ArcadeDbContext.cs under DBContext folder. Then add below code to it. You might get some errors as we haven’t added model configurations to our project yet. We will do it in the next steps.

using Microsoft.EntityFrameworkCore;
using MsRulesEngine.DBConfigurations;
namespace MsRulesEngine.DBContext;

public class ArcadeDbContext : DbContext
{
    public string DbPath { get; private set; }
    public ArcadeDbContext()
    {
        DbPath =  Path.Combine(Environment.CurrentDirectory, "Database", "ArcadeDb.db");
    }

    public DbSet<Game> Games { get; set; }
    public DbSet<Arcade> Arcades { get; set; }

    #region Required
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.ApplyConfigurationsFromAssembly(typeof(ArcadeDbConfiguration).Assembly);
        string filePath = Path.Combine(Environment.CurrentDirectory, "RulesFiles", "DiscountRules.json");
        string jsonString = File.ReadAllText(filePath);

        Arcade arcade = new()
        {
            Name = "Arcade1",
            Id = 1,
            Workflows = jsonString
        };

        Game game = new()
        {
            Title = "Halo",
            Genre = "Action",
            Id = 1,
            Platform = "PlayStation",
            GamingStudio = "Sony",
            Price = 59.99m
        };

        modelBuilder.Entity<Game>().HasData(game);
        modelBuilder.Entity<Arcade>().HasData(arcade);

    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        base.OnConfiguring(optionsBuilder);
        optionsBuilder.UseSqlite($"Data Source={DbPath}");
    }

    #endregion

}

Now create Fluentconfigurations for the Arcade and Game Models by creating ArcadeDbConfiguration.cs and GameDbConfiguration.cs files under DBConfigurations folder in your project. Add below code to those two files.

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace MsRulesEngine.DBConfigurations;

public class GameDbConfiguration : IEntityTypeConfiguration<Game>
{
    public void Configure(EntityTypeBuilder<Game> builder)
    {
        builder
            .HasKey(a => a.Id);
        builder.Property(a => a.Title);
    }
}


// Arcade Configurations
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace MsRulesEngine.DBConfigurations;

public class ArcadeDbConfiguration : IEntityTypeConfiguration<Arcade>
{
    public void Configure(EntityTypeBuilder<Arcade> builder)
    {
        builder
            .HasKey(a => a.Id);
        builder.Property(a => a.Workflows)
            .HasMaxLength(4000);
    }
}

Now on your project folder create a new class called EFCoreDemo.cs. Add below code to it.


using Microsoft.EntityFrameworkCore;
using MsRulesEngine.DBContext;
using RE = RulesEngine;
namespace MsRulesEngine;
public class EFCoreDemo
{

    public static async Task Run()
    {
        ArcadeDbContext db = new();
        db.Database.EnsureCreated();

        var dbArcade = db.Arcades.FirstOrDefault();
        var games = db.Games.AsNoTracking().ToArray();
        var workflows = JsonSerializer.Deserialize<Workflow[]>(dbArcade!.Workflows);
        RE.RulesEngine rulesEngine = new(workflows);

        var resultList = await rulesEngine.ExecuteAllRulesAsync("GameDiscount", games);

        foreach (var result in resultList)
        {
            Console.WriteLine($"Rule: {result.Rule.RuleName}, Result: {result.IsSuccess}, Message: {result.ExceptionMessage}");
        }
    }

}

Modify program.cs as shown below

// See https://aka.ms/new-console-template for more information
using MsRulesEngine;

// await SimpleJsonRuleDemo.Run();

await EFCoreDemo.Run();

Execute the program.cs and you will see the below output.

Conclusion:

Have you observed how simple it is to load the rules from our Sqllite database columns and pull them using EF core on demand during the application runtime. This is another way of storing these JSON based rules file. There are other ways to save the JSON files, I will be creating articles on them as well. So, stay tuned for many other related articles! See you next time! Also, before I forget here is the link to GitHub Repo.

Building A JSON Rules Engine from Scratch with MSRulesEngine — Part 1

Vamsi Dogiparthi — Mon, 10 Feb 2025 02:50:37 +0000

Hi Coding Buddy!! 😊 Welcome to the learn series where we will build an rules engine for a childhood wonderland called “Arcade”. In this series we will concentrate on learning together a JSON based rules engine developed by Microsoft. This is the link to their Open-Source Git hub repo. In order to move forward seamlessly. Please make sure you have checked the pre-requisites section below. To have everything downloaded for us to work together.

Prerequisites:

Download .NET 6 or Higher version SDK.
Download Visual Studio.
Create a new Console Application.
Add the Rules Engine Nuget Package using dotnet add package RulesEngine — version 5.0.4

Understanding how the rules engine works.

Rules engine acts a dynamic wrapper between the user and application business logic allowing you to configure the business rules on demand without redeploying your application.

You can also think about it as proxy helping you to define some core business rules on demand.

Note: This is not a replacement of your entire server-side layer, but a tool defines certain changing rules on runtime.

Rules Engine has three major components/classes to help it work as expected:

Workflow:

This class encapsulates different configurations such as rules, actions on success or failure of certain rules, relationship between rules, error message on each rule etc. To add rules, you need at least have one workflow defined.

A workflow can contain one or more rules to be executed.

    public class Workflow
    {
        /// <summary>
        /// Gets the workflow name.
        /// </summary>
        public string WorkflowName { get; set; }

        /// <summary>Gets or sets the workflow rules to inject.</summary>
        /// <value>The workflow rules to inject.</value>
        [Obsolete("WorkflowRulesToInject is deprecated. Use WorkflowsToInject instead.")]
        public IEnumerable<string> WorkflowRulesToInject {
          set { WorkflowsToInject = value; }
        }
        public IEnumerable<string> WorkflowsToInject { get; set; }

        public RuleExpressionType RuleExpressionType { get; set; } = RuleExpressionType.LambdaExpression;

        /// <summary>
        /// Gets or Sets the global params which will be applicable to all rules
        /// </summary>
        public IEnumerable<ScopedParam> GlobalParams { get; set; }

        /// <summary>
        /// list of rules.
        /// </summary>
        public IEnumerable<Rule> Rules { get; set; }
    }
}

Rule:

This class directly maps to your business rules that has to be executed on user actions to fulfil them the right way.

Ex: Consider an Arcade rule where you have to restock the game when it reaches lower quantity in a particular location or region based on the current restocking cost, game platform etc.

public class Rule
    {
        /// <summary>
        /// Rule name for the Rule
        /// </summary>
        public string RuleName { get; set; }
        /// <summary> 
        /// Gets or sets the custom property or tags of the rule. 
        /// </summary> 
        /// <value> 
        /// The properties of the rule. 
        /// </value> 
        public Dictionary<string, object> Properties { get; set; }
        public string Operator { get; set; }
        public string ErrorMessage { get; set; }

        /// <summary>
        /// Gets or sets whether the rule is enabled.
        /// </summary>
        public bool Enabled { get; set; } = true;

        [JsonConverter (typeof(JsonStringEnumConverter))]
        public RuleExpressionType RuleExpressionType { get; set; } = RuleExpressionType.LambdaExpression;
        public IEnumerable<string> WorkflowsToInject { get; set; }
        public IEnumerable<Rule> Rules { get; set; }
        public IEnumerable<ScopedParam> LocalParams { get; set; }
        public string Expression { get; set; }
        public RuleActions Actions { get; set; }
        public string SuccessEvent { get; set; }

    }

Rules Engine:

This the wrapper or orchestrator class which takes array of workflows as input and executes the workflow rules all at once or specific ones upon request via its methods. This the main class which we interact with to execute the rules, read responses etc.

ReSettings:

This class allows you define custom types, custom actions on the rule's execution changing and overloading its behavior.
Ex: You can define custom class method if you want to parse the string formatted in a way the default way cannot understand you can achieve it with use of ReSettings

Step by Step implementation of simple json based workflow for Arcade

Use Case:

Let’s take simple workflow in every arcade business. Which is to provide discount on certain games to the players based on its genre, platform.

This discount can change every day. In traditional systems you will be saving these discount percentages in DB and load them when needed in the service layer for users to take advantage of them. But the downside to this approach is you only have limited control over the dynamic values but not to the rule expression behind the business rule.

Let’s say tomorrow you need to look into the gaming company to determine the discounts or individual platform versions. To change business rule expression, you have to rewrite and deploy new version of app. Imagine if you have to change it multiple times a day or week on business needs. It will be nightmare. This is where Microsoft Rule based engine can help you with by writing these rules in the form of lambda expressions coming from JSON file, SQL Database etc.

To demonstrate this let's create a simple JSON based rule and see how it works

Create a RulesFiles folder under you .NET Console project directory.
Add below rule to it as JSON file.

[
    {
      "WorkflowName": "GameDiscount",
      "Rules": [
        {
          "RuleName": "AwardDiscount5",      
          "ErrorMessage": "The game doesn't meet the criteria for 5% discount",  // when rule fails you get this error message
          "ErrorType": "Error",
          "RuleExpressionType": "LambdaExpression",
          "Expression": "input1.Genre == \"Sports\" AND input1.Platform == \"PlayStation\""
        },
        {
          "RuleName": "GiveDiscount15",          
          "ErrorMessage": "The game doesn't meet the criteria for 15% discount", // when rule fails you get this error message
          "ErrorType": "Error",
          "RuleExpressionType": "LambdaExpression",
          "Expression": "input1.Genre == \"Action\" AND input1.Platform == \"PlayStation\""
        }
      ]
    }
  ]

Set the Folder to be part of the build package inside the .csproj file

 <ItemGroup>
    <None Update="RulesFiles\**\*">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
  </ItemGroup>

Load this JSON file into array of Workflows into program.cs file

string filePath = Path.Combine(Environment.CurrentDirectory, "RulesFiles", "DiscountRules.json");
Console.WriteLine(filePath);
string jsonString = File.ReadAllText(filePath);
var jsonDocument = JsonDocument.Parse(jsonString);
var workflows = JsonSerializer.Deserialize<Workflow[]>(jsonString);

Add a Game class to the Models folder under our project.

namespace MsRulesEngine.Models;
public class Game {
    public string Title { get; set; } = string.Empty;
    public string Genre { get; set; } = string.Empty;
    public long Id { get; set; }
    public string Platform { get; set; } = string.Empty;    
    public string GamingStudio { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

Create a sample game in program.cs to push it into the rule's engine.

Game game = new()
{
    Title = "Halo",
    Genre = "Action",
    Id = 1,
    Platform = "PlayStation",
    GamingStudio = "Sony",
    Price = 59.99m
};

Create an instance of Rules Engine and execute the GameDiscount Rule for the above created game.

RE.RulesEngine rulesEngine = new(workflows);

var resultList = await rulesEngine.ExecuteAllRulesAsync("GameDiscount", game);

foreach (var result in resultList)
{
    Console.WriteLine($"Rule: {result.Rule.RuleName}, Result: {result.IsSuccess}, Message: {result.ExceptionMessage}");
}

Execute the program.cs file and observe the output.
Let's say the business changed its decision to include a new condition to provide discounts. Which is to include GamingCompany to decide the eligibility for 15% discount. Traditionally it requires a code change, but with rules engine. It is as simple as below.

[
  {
    "WorkflowName": "GameDiscount",
    "Rules": [
      {
        "RuleName": "AwardDiscount5",      
        "ErrorMessage": "The game doesn't meet the criteria for 5% discount", 
        "ErrorType": "Error",
        "RuleExpressionType": "LambdaExpression",
        "Expression": "input1.Genre == \"Sports\" AND input1.Platform == \"PlayStation\""
      },
      {
        "RuleName": "GiveDiscount15",          
        "ErrorMessage": "The game doesn't meet the criteria for 15% discount", 
        "ErrorType": "Error",
        "RuleExpressionType": "LambdaExpression",
        "Expression": "input1.Genre == \"Action\" AND input1.Platform == \"PlayStation\" AND input1.GamingStudio == \"Sony\"" // new condition
      }
    ]
  }
]

Execute the program.cs file and observe the output.

Pros:

Let’s go over some of the Pros of JSON based MS Rules engine below

Customizable and configurable rule expressions.
Runtime rule injection.
Easy to change rules on fly without any code changes.
Custom Actions to fulfil non existing business use case with built-in actions.

Realtime use cases:

Let's look into some Realtime use cases that the MS Rules engine stands out.

Car and Home insurance companies which requires frequent rule changes to accommodate customized user offerings.
Mortgage companies which require dynamic rule changes depending on customers, regions, location etc.
Notification services raising alerts, events based on business rules which can be changed on fly with JSON based MS rules engine

Conclusion:

Hurray! We did complete a simple tutorial with Microsoft JSON based rules engine to define some of our rules, underlying conditions injected from a JSON file. We also explored how to change the rule condition easily by changing the JSON file on fly. We also explored some pros of the Rules Engine, real-time use cases where we can use this rules engine.

All of this is a good base for us, to continue our journey in learning MS Rules engine and its different use cases. Please refer my part 2 of this article series using this link! It will take your through loading these rules from the Databases such as Sqlite. Don’t miss it!

Before I forget this is the GitHub link to the current project with everything we discussed in this article.

See you soon buddy!! 😍