Building a Semantic Kernel with F# for Enhanced AI Interaction

#semantickernel #langchain #llm

This blog base from https://github.com/microsoft/semantic-kernel/blob/main/dotnet/samples/GettingStarted/Step2_Add_Plugins.cs

F# code is here https://github.com/rocklau/fsharpPlayground

In the age of artificial intelligence, leveraging powerful tools to interact seamlessly with users is crucial. Semantic Kernels serve as versatile frameworks that enable AI models to comprehend and respond to queries intelligently. In this blog post, we’ll explore how to create a Semantic Kernel using F#, integrating plugins to enhance functionality and improve user interaction.

Setting Up the Semantic Kernel

The foundation of our Semantic Kernel is built on several key components:

Time Information Plugin: This plugin retrieves the current time in UTC.
Widget Factory Plugin: This plugin allows users to create widgets with specified types and colors.

Let's take a look at the code implementation for these plugins.

Time Information Plugin

This simple plugin is designed to provide the current UTC time, making it accessible for any application requiring time-related information.

type TimeInformationPlugin() =
    [<KernelFunction>]
    [<Description("Retrieves the current time in UTC.")>]
    member this.GetCurrentUtcTime() = DateTime.UtcNow.ToString("R")

Widget Factory Plugin

The widget factory plugin is more complex, allowing users to generate custom widgets based on their preferences. The plugin utilizes enumerated types to specify widget characteristics.

type WidgetType =
    | [<Description("A widget that is useful.")>] Useful = 0 
    | [<Description("A widget that is decorative.")>] Decorative = 1 

type WidgetColor =
    | [<Description("Use when creating a red item.")>] Red = 0 
    | [<Description("Use when creating a green item.")>] Green = 1
    | [<Description("Use when creating a blue item.")>] Blue = 2

type WidgetDetails =
    {
        SerialNumber: string
        Type: WidgetType
        Colors: WidgetColor[]
    }

type WidgetFactoryPlugin() =
    [<KernelFunction>]
    [<Description("Creates a new widget of the specified type and colors")>]    
    member this.CreateWidget(widgetType: WidgetType, widgetColors: WidgetColor[]) = 
        let number = $"{widgetType}-{String.Join('-',widgetColors)}-{Guid.NewGuid()}"
        Console.WriteLine $"Call a widget {number}"
        {
            SerialNumber = number
            Type = widgetType
            Colors = widgetColors
        }

Configuring the Kernel

After implementing the plugins, we construct the kernel and register our plugins. This is achieved by configuring the OpenAI API for chat functionalities.

let builder = Kernel.CreateBuilder()
                .AddOpenAIChatCompletion(modelId = "gpt-4o-mini", endpoint = Uri("https://api.chatgpt.com/v1/chat/completions"), apiKey = "sk-")
                .Plugins.AddFromType<TimeInformationPlugin>()
                .AddFromType<WidgetFactoryPlugin>()

let kernel = builder.Build()

Example Use Cases

Once the kernel and plugins are set up, we can create various examples to demonstrate their capabilities. Below are a few examples.

Example 1: Basic Interaction

In this example, we query the kernel about the color of the sky.

let example1 =
    fun () ->
        task {
            printfn "example1"
            let! response = kernel.InvokePromptAsync("What color is the sky?")
            Console.WriteLine response
        }

Example 2: Streaming Responses

We can also create streaming interactions, which allow us to get real-time responses from the AI.

let example2 =
    fun () ->
        asyncEx {
            printfn "example2"
            let arguments = new KernelArguments()
            arguments.Add("topic", "forest")
            let stream = kernel.InvokePromptStreamingAsync("What color is {{$topic}}?", arguments)

            for item in stream do
                Console.Write item
        }

Example 3: Using Plugins

We can directly utilize our plugins within prompts. For instance, we can retrieve the current UTC time and ask how many days remain until Christmas.

let example4 = fun() ->
    asyncEx {
        let! response = kernel.InvokePromptAsync("The current time is {{TimeInformationPlugin.GetCurrentUtcTime}}. How many days until Christmas?")
        Console.WriteLine response
    }

Example 5: Creating Widgets

Finally, we can automatically invoke functions to create customizable widgets.

let example5 = fun() ->
    asyncEx {
        let settings = OpenAIPromptExecutionSettings()
        settings.ToolCallBehavior <- ToolCallBehavior.AutoInvokeKernelFunctions
        let arguments = new KernelArguments(settings)

        let! response2 = kernel.InvokePromptAsync("Create a beautiful scarlet colored widget for me.", arguments) 
        Console.WriteLine(response2)
    }

Conclusion

In this blog, we've explored how to build a Semantic Kernel using F#. By combining plugins with real-time AI interaction, we can create dynamic applications that respond intuitively to user queries. This framework not only enhances user experiences but also opens doors to countless possibilities for future developments in AI interactions.

Feel free to expand upon this framework, experiment with additional plugins, and integrate it into your own applications to fully realize the capabilities of semantic technology and AI!