Medhat Elmasry: Microsoft.SemanticKernel

Showing posts with label Microsoft.SemanticKernel. Show all posts

Saturday, December 14, 2024

.NET Aspire and Semantic Kernel AI

Let's learn how to use the .NET Aspire Azure OpenAI client. We will familiarize ourselves with the Aspire.Azure.AI.OpenAI library, which is used to register an OpenAIClient in the dependency injection (DI) container for consuming Azure OpenAI or OpenAI functionality. In addition, it enables corresponding logging and telemetry.

Companion Video: https://youtu.be/UuLnCRdYvEI
Final Solution Code: https://github.com/medhatelmasry/AspireAI_Final

Pre-requisites:

.NET 9.0
Visual Studio Code
.NET Aspire Workload
"C# Dev Kit" extension for VS Code

Getting Started

We will start by cloning a simple C# solution that contains two projects that use Semantic Kernel - namely a console project (ConsoleAI) and a razor-pages project (RazorPagesAI). Clone the project in a working directory on your computer by executing these commands in a terminal window:

git clone https://github.com/medhatelmasry/AspireAI.git

cd AspireAI

The cloned solution contains a console application (ConsoleAI) and a razor-pages application (RazorPagesAI). They both do pretty much do the same thing. The objective of today’s exercise is to:

use .NET Aspire so that both projects get started from one place
pass environment variables to the console and razor-pages web apps from the .AppHost project that belongs to .NET Aspire

Open the solution in VS Code and update the values in the following appsettings.json files with your access parameters for Azure OpenAI and/or OpenAI:

ConsoleAI/appsettings.json
RazorPagesAI/appsettings.json

The most important settings are the connection strings. They are identical in both projects:

"ConnectionStrings": {
"azureOpenAi": "Endpoint=Azure-OpenAI-Endpoint-Here;Key=Azure-OpenAI-Key-Here;",
"openAi": "Key=OpenAI-Key-Here"
}

After you update your access parameters, try each application separately to see what it does:

Here is my experience using the console application (ConsoleAI) with AzureOrOpenAI set to “OpenAI”:

cd ConsoleAI
dotnet run

I then changed the AzureOrOpenAI setting to “Azure” and ran the console application (ConsoleAI) again:

Next, try the razor pages web application (RazorPagesAI) with AzureOrOpenAI set to “OpenAI”:

cd ../RazorPagesAI
dotnet watch

In the RazorPagesAI web app’s appsettings.json file, I changed AzureOrOpenAI to “Azure”, resulting in a similar experience.

In the root folder, add .NET Aspire to the solution:

cd ..
dotnet new aspire --force

Add the previous projects to the newly created .sln file with:

dotnet sln add ./AiLibrary/AiLibrary.csproj
dotnet sln add ./RazorPagesAI/RazorPagesAI.csproj
dotnet sln add ./ConsoleAI/ConsoleAI.csproj

Add the following .NET Aspire agent packages to the client ConsoleAI and RazorPagesAI projects with:

dotnet add ./ConsoleAI/ConsoleAI.csproj package Aspire.Azure.AI.OpenAI --prerelease
dotnet add ./RazorPagesAI/RazorPagesAI.csproj package Aspire.Azure.AI.OpenAI --prerelease

To add Azure hosting support to your IDistributedApplicationBuilder, install the 📦 Aspire.Hosting.Azure.CognitiveServices NuGet package in the .AppHost project:

dotnet add ./AspireAI.AppHost/AspireAI.AppHost.csproj package Aspire.Hosting.Azure.CognitiveServices

In VS Code, add the following references:

Add a reference from the .AppHost project into ConsoleAI project.
Add a reference from the .AppHost project into RazorPagesAI project.
Add a reference from the ConsoleAI project into .ServiceDefaults project.
Add a reference from the RazorPagesAI project into .ServiceDefaults project.

Copy the AI and ConnectionStrings blocks from either the console (ConsoleAI) or web app (RazorPagesAI) appsettings.json file into the appsettings.json file of the .AppHost project. The appsettings.json file in the .AppHost project will look similar to this:

"AI": {
"AzureOrOpenAI": "OpenAI",
"OpenAiChatModel": "gpt-3.5-turbo",
"AzureChatDeploymentName": "gpt-35-turbo"
},
"ConnectionStrings": {
"azureOpenAi": "Endpoint=Azure-OpenAI-Endpoint-Here;Key=Azure-OpenAI-Key-Here;",
"openAi": "Key=OpenAI-Key-Here"
}

Add the following code to the Program.cs file in the .AppHost project just before builder.Build().Run():

IResourceBuilder<IResourceWithConnectionString> openai;
var AzureOrOpenAI = builder.Configuration["AI:AzureOrOpenAI"] ?? "Azure"; ;
var chatDeploymentName = builder.Configuration["AI:AzureChatDeploymentName"];
var openAiChatModel = builder.Configuration["AI:OpenAiChatModel"];

// Register an Azure OpenAI resource.

// The AddAzureAIOpenAI method reads connection information

// from the app host's configuration

if (AzureOrOpenAI.ToLower() == "azure") {
openai = builder.ExecutionContext.IsPublishMode
? builder.AddAzureOpenAI("azureOpenAi")
: builder.AddConnectionString("azureOpenAi");
} else {
openai = builder.ExecutionContext.IsPublishMode
? builder.AddAzureOpenAI("openAi")
: builder.AddConnectionString("openAi");
}

// Register the RazorPagesAI project and pass to it environment variables.

// WithReference method passes connection info to client project

builder.AddProject<Projects.RazorPagesAI>("razor")
.WithReference(openai)
.WithEnvironment("AI__AzureChatDeploymentName", chatDeploymentName)
.WithEnvironment("AI__AzureOrOpenAI", AzureOrOpenAI)
.WithEnvironment("AI_OpenAiChatModel", openAiChatModel);

// register the ConsoleAI project and pass to it environment variables

builder.AddProject<Projects.ConsoleAI>("console")
.WithReference(openai)
.WithEnvironment("AI__AzureChatDeploymentName", chatDeploymentName)
.WithEnvironment("AI__AzureOrOpenAI", AzureOrOpenAI)
.WithEnvironment("AI_OpenAiChatModel", openAiChatModel);

We need to add .NET Aspire agents in both our console and web apps. Let us start with the web app. Add this code to the Program.cs file in the RazorPagesAI project right before “var app = builder.Build()”:

builder.AddServiceDefaults();

In the same Program.cs of the web app (RazorPagesAI), comment out the if (azureOrOpenAi.ToLower() == "openai") { …. } else { ….. } block and replace it with this code:

if (azureOrOpenAi.ToLower() == "openai") {
builder.AddOpenAIClient("openAi");
builder.Services.AddKernel()
.AddOpenAIChatCompletion(openAiChatModel);
} else {
builder.AddAzureOpenAIClient("azureOpenAi");
builder.Services.AddKernel()
.AddAzureOpenAIChatCompletion(azureChatDeploymentName);
}

In the above code, we call the extension method to register an OpenAIClient for use via the dependency injection container. The method takes a connection name parameter. Also, register Semantic Kernel with the DI.

Also, in the Program.cs file in the ConsoleAI project, add this code right below the using statements:

var hostBuilder = Host.CreateApplicationBuilder();
hostBuilder.AddServiceDefaults();

In the same Program.cs of the console app (ConsoleAI), comment out the if (azureOrOpenAi.ToLower() == "azure") { …. } else { ….. } block and replace it with this code:

if (azureOrOpenAI.ToLower() == "azure") {
var azureChatDeploymentName = config["AI:AzureChatDeploymentName"] ?? "gpt-35-turbo";
hostBuilder.AddAzureOpenAIClient("azureOpenAi");
hostBuilder.Services.AddKernel()
.AddAzureOpenAIChatCompletion(azureChatDeploymentName);
} else {
var openAiChatModel = config["AI:OpenAiChatModel"] ?? "gpt-3.5-turbo";
hostBuilder.AddOpenAIClient("openAi");
hostBuilder.Services.AddKernel()
.AddOpenAIChatCompletion(openAiChatModel);
}
var app = hostBuilder.Build();

Replace “var kernel = builder.Build();” with this code:

var kernel = app.Services.GetRequiredService<Kernel>();
app.Start();

You can now test that the .NET Aspire orchestration of both the Console and Web apps. Stop all applications, then, in a terminal window, go to the .AppHost project and run the following command:

dotnet watch

You will see the .NET Aspire dashboard:

Click on Views under the Logs column. You will see this output indicating that the console application ran successfully:

Click on the link for the web app under the Endpoints column. It opens the razor pages web app in another tab in your browser. Test it out and verify that it works as expected.

Stop the .AppHost application, then comment out the AI and ConneectionStrings blocks in the appsettings.json files in both the console and web apps. If you run the .AppHost project again, you will discover that it works equally well because the environment variables are being passed from the .AppHost project into the console and web apps respectively.

One last refinement we can do to the console application is do away with the ConfigurationBuilder because we can get a configuration object from the ApplicationBuilder. Therefore, comment out the following code in the console application:

var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.Build();

Replace the above code with the following:

var config = hostBuilder.Configuration;

You can delete the following package from the ConsoleAI.csproj file:

Everything works just as it did before.

Thursday, February 29, 2024

OpenAI Function Calling with Semantic Kernel, C#, & Entity Framework

In this article, we will create a Semantic Kernel plugin that contains four functions that interact with live SQLite data. Entity Framework will be used to access the SQLite database. The end result is to use the powers of the OpenAI natural language models to ask questions and get answers about our custom data.

Source code: https://github.com/medhatelmasry/EfFuncCallSK

Companion Video: https://youtu.be/4sKRwflEyHk

Getting Started

Let’s start by creating an ASP.NET Razor pages web application. Select a suitable working folder on your computer, then enter the following terminal window commands:

dotnet new razor --auth individual -o EfFuncCallSK
cd EfFuncCallSK

Te above creates a Razor Pages app with support for Entity Framework and SQLite.

Add these packages:

dotnet add package CsvHelper
dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.Tools
dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SQLite.Design

The CsvHelper package will help us load a list of products from a CSV file named students.csv and hydrate a list of Student objects. The second package is needed to work with Semantic Kernel. The rest of the packages support Entity Framework and SQLite.

Let’s Code

appsettings.json

Add these to appsettings.json:

"AIService": "OpenAI", /* Azure or OpenAI */
"AzureOpenAiSettings": {
"Endpoint": "https://YOUR_RESOURCE_NAME.openai.azure.com/",
"Model": "gpt-35-turbo",
"ApiKey": "fake-key-fake-key-fake-key-fake-key"
},
"OpenAiSettings": {
"ModelType": "gpt-3.5-turbo",
"ApiKey": "fake-key-fake-key-fake-key-fake-key"
}

The first setting allows you to choose between using OpenAI or Azure OpenAI.

Of course, you need to adjust the endpoint setting with the appropriate value that pertains to the OpenAI and Azure OpenAI services. Also, enter the correct value for the ApiKey.

NOTE: You can use OpenAI or Azure OpenAI, or both.

Data

Create a folder named Models. Inside the Models folder, add the following Student class:

public class Student {
public int StudentId { get; set; }
public string? FirstName { get; set; }
public string? LastName { get; set; }
public string? School { get; set; }

public override string ToString() {
return $"Student ID: {StudentId}, First Name: {FirstName}, Last Name: {LastName}, School: {School}";
}
}

Developers like having sample data when building data driven applications. Therefore, we will create sample data to ensure that our application behaves as expected. Copy the following data and save it in a text file wwwroot/students.csv:

StudentId,FirstName,LastName,School
1,Tom,Max,Nursing
2,Ann,Fay,Mining
3,Joe,Sun,Nursing
4,Sue,Fox,Computing
5,Ben,Ray,Mining
6,Zoe,Cox,Business
7,Sam,Ray,Mining
8,Dan,Ash,Medicine
9,Pat,Lee,Computing
10,Kim,Day,Nursing
11,Tim,Rex,Computing
12,Rob,Ram,Nursing
13,Jan,Fry,Mining
14,Jim,Tex,Nursing
15,Ben,Kid,Business
16,Mia,Chu,Medicine
17,Ted,Tao,Computing
18,Amy,Day,Nursing
19,Ian,Roy,Nursing
20,Liz,Kit,Nursing
21,Mat,Tan,Medicine
22,Deb,Roy,Medicine
23,Ana,Ray,Mining
24,Lyn,Poe,Computing
25,Amy,Raj,Nursing
26,Kim,Ash,Mining
27,Bec,Kid,Nursing
28,Eva,Fry,Computing
29,Eli,Lap,Business
30,Sam,Yim,Nursing
31,Joe,Hui,Mining
32,Liz,Jin,Nursing
33,Ric,Kuo,Business
34,Pam,Mak,Computing
35,Cat,Yao,Medicine
36,Lou,Zhu,Mining
37,Tom,Dag,Business
38,Stu,Day,Business
39,Tom,Gad,Mining
40,Bob,Bee,Business
41,Jim,Ots,Business
42,Tom,Mag,Business
43,Hal,Doe,Mining
44,Roy,Kim,Mining
45,Vis,Cox,Nursing
46,Kay,Aga,Nursing
47,Reo,Hui,Nursing
48,Bob,Roe,Mining
49,Jay,Eff,Computing
50,Eva,Chu,Business
51,Lex,Rae,Nursing
52,Lin,Dex,Mining
53,Tom,Dag,Business
54,Ben,Shy,Computing
55,Rob,Bos,Nursing
56,Ali,Mac,Business
57,Edi,Gee,Computing
58,Eva,Cao,Mining
59,Jun,Lam,Computing
60,Eli,Tao,Computing
61,Ana,Bay,Computing
62,Gil,Tal,Mining
63,Wes,Dey,Nursing
64,Nea,Tan,Computing
65,Ava,Day,Nursing
66,Rie,Ray,Business
67,Ken,Sim,Nursing

Add the following code inside the ApplicationDbContext class located inside the Data folder:

public DbSet<Student> Students => Set<Student>();

protected override void OnModelCreating(ModelBuilder modelBuilder) {
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Student>().HasData(LoadStudents());
}

// Load students from a csv file named students.csv in the wwwroot folder
public static List<Student> LoadStudents() {
var students = new List<Student>();
using (var reader = new StreamReader(Path.Combine("wwwroot", "students.csv"))) {
using var csv = new CsvReader(reader, CultureInfo.InvariantCulture);
students = csv.GetRecords<Student>().ToList();
}
return students;
}

Let us add a migration and subsequently update the database. Execute the following CLI commands in a terminal window.

dotnet ef migrations add Students -o Data/Migrations
dotnet ef database update

At this point the database and tables are created in a SQLite database named app.db.

Helper Methods

We need a couple of static helper methods to assist us along the way. In the Models folder, add a class named Utils and add to it the following class definition:

public class Utils {
public static string GetConfigValue(string config) {
IConfigurationBuilder builder = new ConfigurationBuilder();
if (System.IO.File.Exists("appsettings.json"))
builder.AddJsonFile("appsettings.json", false, true);
if (System.IO.File.Exists("appsettings.Development.json"))
builder.AddJsonFile("appsettings.Development.json", false, true);
IConfigurationRoot root = builder.Build();
return root[config]!;
}

public static ApplicationDbContext GetDbContext() {
var optionsBuilder = new DbContextOptionsBuilder<ApplicationDbContext>();
var connStr = Utils.GetConfigValue("ConnectionStrings:DefaultConnection");
optionsBuilder.UseSqlite(connStr);
ApplicationDbContext db = new ApplicationDbContext(optionsBuilder.Options);
return db;
}
}

Method GetConfigValue() will read values in appsettings.json from any static method. The second GetDbContext() method gets an instance of the ApplicationDbContext class, also from any static method.

Plugins

Create a folder named Plugins and add to it the following class file named StudentPlugin.cs with this code:

public class StudentPlugin {
[KernelFunction, Description("Get student details by first name and last name")]
public static string? GetStudentDetails(
[Description("student first name, e.g. Kim")]
string firstName,
[Description("student last name, e.g. Ash")]
string lastName
) {
var db = Utils.GetDbContext();
var studentDetails = db.Students
.Where(s => s.FirstName == firstName && s.LastName == lastName).FirstOrDefault();
if (studentDetails == null)
return null;
return studentDetails.ToString();
}

[KernelFunction, Description("Get students in a school given the school name")]
public static string? GetStudentsBySchool(
[Description("The school name, e.g. Nursing")]
string school
) {
var studentsBySchool = Utils.GetDbContext().Students
.Where(s => s.School == school).ToList();
if (studentsBySchool.Count == 0)
return null;
return JsonSerializer.Serialize(studentsBySchool);
}

[KernelFunction, Description("Get the school with most or least students. Takes boolean argument with true for most and false for least.")]
static public string? GetSchoolWithMostOrLeastStudents(
[Description("isMost is a boolean argument with true for most and false for least. Default is true.")]
bool isMost = true
) {
var students = Utils.GetDbContext().Students.ToList();
IGrouping<string, Student>? schoolGroup = null;
if (isMost)
schoolGroup = students.GroupBy(s => s.School)
.OrderByDescending(g => g.Count()).FirstOrDefault()!;
else
schoolGroup = students.GroupBy(s => s.School)
.OrderBy(g => g.Count()).FirstOrDefault()!;
if (schoolGroup != null)
return $"{schoolGroup.Key} has {schoolGroup.Count()} students";
else
return null;
}

[KernelFunction, Description("Get students grouped by school.")]
static public string? GetStudentsInSchool() {
var students = Utils.GetDbContext().Students.ToList().GroupBy(s => s.School)
.OrderByDescending(g => g.Count());
if (students == null)
return null;
else
return JsonSerializer.Serialize(students);
}
}

In the above code, there are four methods with these purposes:

GetStudentDetails()	Gets student details given first and last names
GetStudentsBySchool()	Gets students in a school given the name of the school
GetSchoolWithMostOrLeastStudents()	Takes a Boolean value isMost – true returns school with most students and false returns school with least students.
GetStudentsInSchool()	Takes no arguments and returns a count of students by school.

The User Interface

We will re-purpose the Index.cshtml and Index.cshtml.cs files so the user can enter a prompt in natural language and receive a response that comes from the OpenAI model working with our semantic kernel plugin.

Index.chtml

Replace the content of Pages/Index.cshtml with:

@page
@model IndexModel
@{
ViewData["Title"] = Model.Service + " Function Calling with Semantic Kernel";
}
<div class="text-center">
<h3 class="display-6">@ViewData["Title"]</h3>
<form method="post">
<input type="text" name="prompt" size="80" required />
<input type="submit" value="Submit" />
</form>
<div style="text-align: left">
<h5>Example prompts:</h5>
<p>Which school does Mat Tan go to?</p>
<p>Which school has the most students?</p>
<p>Which school has the least students?</p>
<p>Get the count of students in each school.</p>
<p>How many students are there in the school of Mining?</p>
<p>What is the ID of Jan Fry and which school does she go to?</p>
<p>Which students belong to the school of Business? Respond only in JSON format.</p>
<p>Which students in the school of Nursing have their first or last name start with the letter 'J'?</p>
</div>
@if (Model.Reply != null)
{
<p class="alert alert-success">@Model.Reply</p>
}
</div>

The above markup displays an HTML form that accepts a prompt from a user. The prompt is then submitted to the server and the response is displayed in a paragraph (<p> tag) with a green background (Bootstrap class alert-success).

Meantime, at the bottom of the page there are some suggested prompts – namely:

Which school does Mat Tan go to?
Which school has the most students?
Which school has the least students?
Get the count of students in each school.
How many students are there in the school of Mining?
What is the ID of Jan Fry and which school does she go to?
Which students belong to the school of Business? Respond only in JSON format.
Which students in the school of Nursing have their first or last name start with the letter 'J'?

Index.chtml.cs

Replace the IndexModel class definition in Pages/Index.cshtml.cs with:

public class IndexModel : PageModel {
private readonly ILogger<IndexModel> _logger;
private readonly IConfiguration _config;

[BindProperty]
public string? Reply { get; set; }

[BindProperty]
public string? Service { get; set; }

public IndexModel(ILogger<IndexModel> logger, IConfiguration config) {
_logger = logger;
_config = config;
Service = _config["AIService"]!;
}
public void OnGet() { }
// action method that receives prompt from the form
public async Task<IActionResult> OnPostAsync(string prompt) {
// call the Azure Function
var response = await CallFunction(prompt);
Reply = response;
return Page();
}

private async Task<string> CallFunction(string question) {
string azEndpoint = _config["AzureOpenAiSettings:Endpoint"]!;
string azApiKey = _config["AzureOpenAiSettings:ApiKey"]!;
string azModel = _config["AzureOpenAiSettings:Model"]!;
string oaiModelType = _config["OpenAiSettings:ModelType"]!;
string oaiApiKey = _config["OpenAiSettings:ApiKey"]!;
string oaiModel = _config["OpenAiSettings:Model"]!;
string oaiOrganization = _config["OpenAiSettings:Organization"]!;
var builder = Kernel.CreateBuilder();
if (Service!.ToLower() == "openai")
builder.Services.AddOpenAIChatCompletion(oaiModelType, oaiApiKey);
else
builder.Services.AddAzureOpenAIChatCompletion(azModel, azEndpoint, azApiKey);
builder.Services.AddLogging(c => c.AddDebug().SetMinimumLevel(LogLevel.Trace));
builder.Plugins.AddFromType<StudentPlugin>();
var kernel = builder.Build();
// Create chat history
ChatHistory history = [];
// Get chat completion service
var chatCompletionService = kernel.GetRequiredService<IChatCompletionService>();
// Get user input
history.AddUserMessage(question);
// Enable auto function calling
OpenAIPromptExecutionSettings openAIPromptExecutionSettings = new() {
ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions
};
// Get the response from the AI
var result = chatCompletionService.GetStreamingChatMessageContentsAsync(
history,
executionSettings: openAIPromptExecutionSettings,
kernel: kernel);
string fullMessage = "";
await foreach (var content in result) {
fullMessage += content.Content;
}
// Add the message to the chat history
history.AddAssistantMessage(fullMessage);
return fullMessage;
}
}

In the above code, the prompt entered by the user is posted to the OnPostAsync() method. The prompt is then passed to the CallFunction() method, which returns the final response from Azure OpenAI.

The CallFunction() method reads the OpenAI or Azure OpenAI settings from appsettings.json, depending on the AIService key.

A builder object is created from Semantic Kernel. If we are using OpenAI, then the AddOpenAIChatCompletion service is added. Otherwise, the AddAzureOpenAIChatCompletion service is added.

The StudentPlugin is then added to the builder object Plugins collection.

The builder Build() method is then called returning a kernel object. From the kernel object we then get a chatCompletionService object by calling the GetRequiredService() method.

Thereafter:

Add the prompt to the history
Make a call to the chat message service and receive a response
Concatenate response into a single string
Return the concatenated message

Trying the application

In a terminal window, at the root of the Razor Pages web application, enter the following command:

dotnet watch

The following page will display in your default browser:

You can enter any of the suggested prompts to ensure we are getting the proper results. I entered the last prompt and got these results:

Conclusion

We have seen how Semantic Kernel and Function Calling can be used with data coming from a database. In this example we are using SQLite. However, an other database source can be used using the same technique.

Wednesday, February 7, 2024

Base64 images with Azure OpenAI Dall-E 3, Semantic Kernel, and C#

We will generate Base64 images using the OpenAI Dall-E 3 service and Semantic Kernel. The Base64 representation of the image will be saved in a text file. Thereafter, we will read the text file from an index.html page using JavaScript and subsequently render the image on a web page.

Source Code: https://github.com/medhatelmasry/DalleImageBase64/

What is Semantic Kernel?

This is the official definition obtained from Create AI agents with Semantic Kernel | Microsoft Learn:

Semantic Kernel is an open-source SDK that lets you easily build agents that can call your existing code. As a highly extensible SDK, you can use Semantic Kernel with models from OpenAI, Azure OpenAI, Hugging Face, and more!

Getting Started

In a suitable directory, create a console application named DalleImageBase64 and add to it three packages needed for our application with the following terminal window commands:

dotnet new console -o DalleImageBase64
cd DalleImageBase64
dotnet add package Microsoft.SemanticKernel
dotnet add package System.Configuration.ConfigurationManager

dotnet add package SkiaSharp

Create a file named App.config in the root folder of the console application and add to it the important parameters that allow access to the Azure OpenAI service. Contents of App.config are like the following:

<?xml version="1.0"?>
<configuration>
<appSettings>
<add key="endpoint" value="https://fake.openai.azure.com/" />
<add key="azure-api-key" value="fake-azure-openai-key" />
<add key="openai-api-key" value="fake-openai-key" />
<add key="openai-org-id" value="fake-openai-org-id" />
<add key="gpt-deployment" value="gpt-4o-mini" />
<add key="dalle-deployment" value="dall-e-3" />
<add key="openai_or_azure" value="openai" />
</appSettings>
</configuration>

NOTE: Since I cannot share the endpoint and apiKey with you, I have fake values for these settings.

Let's Code

Open Program.cs and delete all its contents. Add the following using statements at the top:

using System.Configuration;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;
using Microsoft.SemanticKernel.TextToImage;

We need to read the App.config file settings into our application. We will use the ConfigurationManager from namespace System.Configuration. To read settings from App.config with ConfigurationManager, append the following code to Program.cs:

// Get configuration settings from App.config
string _endpoint = ConfigurationManager.AppSettings["endpoint"]!;
string _azureApiKey = ConfigurationManager.AppSettings["azure-api-key"]!;
string _openaiApiKey = ConfigurationManager.AppSettings["azure-api-key"]!;
string _dalleDeployment = ConfigurationManager.AppSettings["dalle-deployment"]!;
string _gptDeployment = ConfigurationManager.AppSettings["gpt-deployment"]!;
string _openai_or_azure = ConfigurationManager.AppSettings["openai_or_azure"]!;
string _openaiOrgId = ConfigurationManager.AppSettings["openai-org-id"]!;

Currently, we need to disable certain warning directives by adding the following into the .csproj file inside the <PropertyGroup> block:

<NoWarn>SKEXP0001, SKEXP0010</NoWarn>

Then, append this code to Program.cs:

// Create a kernel builder
var builder = Kernel.CreateBuilder();

// Add OpenAI services to the kernel
if (_openai_or_azure == "azure") {
// use azure openai services
builder.AddOpenAIChatCompletion(_gptDeployment, _endpoint, _azureApiKey);
builder.AddOpenAITextToImage(_dalleDeployment, _endpoint, _azureApiKey);
} else {
// use openai services
builder.AddOpenAIChatCompletion(_gptDeployment, _openaiApiKey, _openaiOrgId);
builder.AddOpenAITextToImage(_openaiApiKey, _openaiOrgId);
}

// Build the kernel
var kernel = builder.Build();

We created a builder object from SematicKernel, added the AddAzureOpenAITextToImage and AddAzureOpenAIChatCompletion services, then obtained an instance of the kernel object.

Get an instance of the "Dall-E" service from the kernel with the following code:

// Get AI service instance used to generate images
var dallE = kernel.GetRequiredService<ITextToImageService>();

Let us create a prompt that generates an image representing a phrase entered by the user. Append this code to Program.cs:

// create execution settings for the prompt
var prompt = @"
Think about an image that represents {{$input}}.";

We then configure the prompt execution settings with:

var executionSettings = new OpenAIPromptExecutionSettings {
MaxTokens = 256,
Temperature = 1
};

Temperature is a measure of how creative you want the AI to be. This ranges from 0 to 1, where 0 is least creative and 1 is most creative.

We will create a semantic function from our prompt with:

// create a semantic function from the prompt
var genImgFunction = kernel.CreateFunctionFromPrompt(prompt, executionSettings);

Let us ask the user for input with this code:

// Get a phrase from the user
Console.WriteLine("Enter a phrase to generate an image from: ");
string? phrase = Console.ReadLine();
if (string.IsNullOrEmpty(phrase)) {
Console.WriteLine("No phrase entered.");
return;
}

Next, we will ask the kernel to combine the prompt with the input received from to user.

// Invoke the semantic function to generate an image description
var imageDescResult = await kernel.InvokeAsync(genImgFunction, new() { ["input"] = phrase });
var imageDesc = imageDescResult.ToString();

Finally, ask Dall-E service to do the important work of generating an image based on the description. It returns an image url. This is done with the following code:

// Use DALL-E 3 to generate an image.
// In this case, OpenAI returns a URL (though you can ask to return a base64 image)
var imageUrl = await dallE.GenerateImageAsync(imageDesc.Trim(), 1024, 1024);

Let’s print the output URL so that the user can pop it into a browser to see what it looks like:

// Display the image URL
Console.WriteLine($"Image URL:\n\n{imageUrl}");

We will next use the SkiaSharp package (installed earlier on) to save the the image to the computer file system. Create a helper class named SkiaUtils with the following code:

public static class SkiaUtils {

public static async Task<string> SaveImageToFile(string url, int width, int height, string filename = "image.png") {

SKImageInfo info = new SKImageInfo(width, height);
SKSurface surface = SKSurface.Create(info);
SKCanvas canvas = surface.Canvas;
canvas.Clear(SKColors.White);
var httpClient = new HttpClient();
using (Stream stream = await httpClient.GetStreamAsync(url))
using (MemoryStream memStream = new MemoryStream()) {
await stream.CopyToAsync(memStream);
memStream.Seek(0, SeekOrigin.Begin);
SKBitmap webBitmap = SKBitmap.Decode(memStream);
canvas.DrawBitmap(webBitmap, 0, 0, null);
surface.Draw(canvas, 0, 0, null);
};
surface.Snapshot().Encode(SKEncodedImageFormat.Png, 100).SaveTo(new FileStream(filename, FileMode.Create));
return filename;
}

public static async Task<string> GetImageToBase64String(string url, int width, int height) {

SKImageInfo info = new SKImageInfo(width, height);
SKSurface surface = SKSurface.Create(info);
SKCanvas canvas = surface.Canvas;
canvas.Clear(SKColors.White);
var httpClient = new HttpClient();
using (Stream stream = await httpClient.GetStreamAsync(url))
using (MemoryStream memStream = new MemoryStream()) {
await stream.CopyToAsync(memStream);
memStream.Seek(0, SeekOrigin.Begin);
SKBitmap webBitmap = SKBitmap.Decode(memStream);
canvas.DrawBitmap(webBitmap, 0, 0, null);
surface.Draw(canvas, 0, 0, null);
};
using (MemoryStream memStream = new MemoryStream()) {
surface.Snapshot().Encode(SKEncodedImageFormat.Png, 100).SaveTo(memStream);
byte[] imageBytes = memStream.ToArray();
return Convert.ToBase64String(imageBytes);
}
}
}

The above SkiaUtils class contains two static methods: SaveImageToFile() and GetImageToBase64String(). The method names are self-explanatory. Let us use these methods in our application. Add the following code to the bottom of Program.cs:

// generate a random number between 0 and 200 to be used for filename
var random = new Random().Next(0, 200);

// use SkiaUtils class to save the image as a .png file
string filename = await SkiaUtils.SaveImageToFile(imageUrl, 1024, 1024, $"{random}-image.png");

// use SkiaUtils class to get base64 string representation of the image
var base64Image = await SkiaUtils.GetImageToBase64String(imageUrl, 1024, 1024);

// save base64 string representation of the image to a text file
File.WriteAllText($"{random}-base64image.txt", base64Image);

// Display the image filename
Console.WriteLine($"\nImage saved as {filename}");

// Display the base64 image filename
Console.WriteLine($"\nBase64 image saved as {random}-base64image.txt");

Running App

Let’s try it out. Run the app in a terminal window with:

dotnet run

The user is prompted with “Enter a phrase to generate an image from:”. I entered “a camel roaming the streets of New York”. This is the output I received:

I copied and pasted the URL into my browser. This is what the image looked like:

Two files were created in the root folder of the console application - namely: 94-image.png and 94-base64image.txt. Note that your filenames could be different because the numbers in the name are randomly generated.

You can double-click on the .png image file to view it in the default image app on your computer.

Viewing Base64 representation of image in a web page

In the root folder of your console application, create a file named index.html and add to it the following HTML/JavaScript code:

<!DOCTYPE html>
<html lang="en">

<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,
initial-scale=1.0">
<title>Read Base64 image</title>
</head>

<body>
<input type="file" id="fileInput" />
<img src="" id="img"/>
<script>
document.getElementById('fileInput')
.addEventListener('change', (event) => {
const file = event.target.files[0];
const reader = new FileReader();

reader.onload = function () {
const content = reader.result;
console.log(content);
document.getElementById('img')
.src = 'data:image/png;base64,' + content;
};

reader.onerror = function () {
console.error('Error reading the file');
};

reader.readAsText(file, 'utf-8');
});
</script>
</body>

</html>

The JavaScript in the above index.html file reads the text file and sets its Base64 content to the src attribute of an image tag.

View Base64 representation of the image

Double click on the index.html file on your file system.

Navigate to the text file that contains the Base64 representation of the image and select it. You will see the same image that you had seen earlier loaded to the web page.

Conclusion

You can use the Image URL generated from the Dall-E 3 API, save it to your computer or generate a Base64 representation of the image,

Medhat Elmasry

Saturday, December 14, 2024

.NET Aspire and Semantic Kernel AI

Getting Started

Thursday, February 29, 2024

OpenAI Function Calling with Semantic Kernel, C#, & Entity Framework

Getting Started

Let’s Code

appsettings.json

Data

Helper Methods

Plugins

The User Interface

Index.chtml

Index.chtml.cs

Trying the application

Conclusion

Wednesday, February 7, 2024

Base64 images with Azure OpenAI Dall-E 3, Semantic Kernel, and C#

What is Semantic Kernel?

Getting Started

Let's Code

Running App

Viewing Base64 representation of image in a web page

View Base64 representation of the image

Conclusion

About Me

Blog Archive