Azure OpenAI API Service with CSharp

The OpenAI Service is a cloud-based API that provides access to Large Language Models (LLM) and Artificial Intelligence (AI) Capabilities. This API allows developers to leverage the LLM models to create AI application that can perform Natural Language Processing (NLP) tasks such as text generation, code generation, language translation and others.

Azure provides the Azure OpenAI services which integrates the OpenAI API in Azure infrastructure. This enables us to create custom hosting resources and access the OpenAI API with a custom domain and deployment configuration. There are API client libraries to support different programming languages. To access the Azure OpenAI API using .NET, we could use the OpenAI .NET client library and access an OpenAI resource in Azure. As an alternative, we could use the HttpClient class from the System.Net.Http namespace and code the HTTP requests.

👍 The OpenAI client libraries is available for Python, JavaScript, .NET, Java

In this article, we take a look at using the OpenAI API to generate code from a GitHub user story using an Azure OpenAI resource with the .NET client library.

👉 An Azure OpenAI resource can be created by visiting Azure OpenAI Portal

Install the OpenAI APi Client Dependencies

To use the client library, we first need to install the dependencies and configure some environment variables.

$ dotnet add package Azure.AI.OpenAI --prerelease

Install the OpenAI dependencies restoring the project file from this project

• Clone this GitHub code repo: - LLM Code Generation
• Open a terminal and navigate to the CSharp folder
  • Use the dotnet restore command when cloning the repository.

$ cd csharp/CodeGeneration
$ dotnet restore

This should download the code to your workstation.

Add the Azure OpenAI environment configurations

Get the following configuration information from your Azure OpenAI resource.

👍 This example uses a custom Azure OpenAI resource hosted at Azure OpenAI Portal

• GitHub Repo API Token with write permissions to push comments to an issue
• Get an OpenAI API key
• If you are using an Azure OpenAI resource, get your custom end-point and deployment
  • The deployment should have the code-davinci-002 model

Set the linux environment variables with these commands:

$ echo export AZURE_OpenAI_KEY="OpenAI-key-here" >> ~/.bashrc && source ~/.bashrc
$ echo export GITHUB_TOKEN="github-key-here" >> ~/.bashrc && source ~/.bashrc
$ echo export AZURE_OpenAI_DEPLOYMENT="deployment-name" >> ~/.bashrc && source ~/.bashrc
$ echo export AZURE_OpenAI_ENDPOINT="https://YOUR-END-POINT.OpenAI.azure.com/" >> ~/.bashrc && source ~/.bashrc

Build and Run the Code

$ dotnet build

Describe the code

The code should run this workflow:

• Get a list of open GitHub issues with the label user-story
• Each issue content is sent to the OpenAI API to generate the code
• The generated code is posted as a comment on the user-story for the developers to review

👍 The following code uses a simple API call implementation for the GitHub and OpenAI APIs. Use the code from this repo: - LLM Code Generation

    // Get environment variables
    private static readonly string openaiApiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_KEY") ?? String.Empty;    
    private static readonly string openaiBase = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? String.Empty;       
    private static readonly string openaiEngine = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? String.Empty;           

    // GitHub API endpoint and authentication headers    
    private static readonly string githubToken = Environment.GetEnvironmentVariable("GITHUB_TOKEN") ?? String.Empty;

    /// <summary>
    /// Process a GitHub issue by label.
    /// </summary>
    public static async Task ProcessIssueByLabel(string repo, string label)
    {
        try
        {
            // Get the issues from the repo
            var @params = new Parameter { Label = label, State = "open" };              
            List<Issue> issues = await GitHubService.GetIssues(repo, @params, githubToken);
            if (issues != null)
            {
                foreach (var issue in issues)
                {
                    // Generate code using OpenAI
                    Console.WriteLine($"Generating code from GitHub issue: {issue.title} to {openaiBase}");
                    OpenAIService openaiService = new OpenAIService(openaiApiKey, openaiBase, openaiEngine);
                    string generatedCode = await openaiService.Create(issue.body ?? String.Empty);

                    if (!string.IsNullOrEmpty(generatedCode))
                    {
                        // Post a comment with the generated code to the GitHub issue
                        string comment = $"Generated code:\n\n```{generatedCode}\n```";
                        bool commentPosted = await GitHubService.PostIssueComment(repo, issue.number, comment, githubToken);

                        if (commentPosted)
                        {
                            Console.WriteLine("Code generated and posted as a comment on the GitHub issue.");
                        }
                        else
                        {
                            Console.WriteLine("Failed to post the comment on the GitHub issue.");
                        }
                    }
                    else
                    {
                        Console.WriteLine("Failed to generate code from the GitHub issue.");
                    }
                }
            }
            else
            {
                Console.WriteLine("Failed to retrieve the GitHub issue.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

The OpenAI service class handles the OpenAI API details. It takes default parameters for the model deployment (engine), temperature and token limits, which control the cost and amount of text (roughly four letters per token) that should be allowed. For this service, we use the "Completion" model which allows developers to interact with OpenAI's language models and generate text-based completions.

internal class OpenAIService
    {
        private string apiKey;
        private string engine;
        private string endPoint;
        private float temperature;
        private int maxTokens;
        private int n;
        private string stop;

        /// <summary>
        /// OpenAI client
        /// </summary>
        private OpenAIClient? client;

        public OpenAIService(string apiKey, string endPoint, string engine = "text-davinci-003", float temperature = 0.5f, int maxTokens = 350, int n = 1, string stop = "")
        {
            // Configure the OpenAI client with your API key and endpoint                 
            client = new OpenAIClient(new Uri(endPoint), new AzureKeyCredential(apiKey));
            this.apiKey = apiKey;
            this.endPoint = endPoint;            
            this.engine = engine;
            this.temperature = temperature;
            this.maxTokens = maxTokens;
            this.n = n;
            this.stop = stop;                
        }

        /// <summary>
        /// Create a completion from a prompt
        /// </summary>
        public async Task<string> Create(string prompt)
        {     
            var result = String.Empty;

            if (!String.IsNullOrEmpty(prompt) && client != null)
            {

                Response<Completions> completionsResponse = await client.GetCompletionsAsync(engine, prompt);

                Console.WriteLine(completionsResponse);
                result = completionsResponse.Value.Choices[0].Text.Trim();                
                Console.WriteLine(result);
            }

            return result;            
        }
    }

Run the code

After configuring your environment and downloading the code, we can run the code from a terminal by typing the following command from the project folder:

👉 Make sure to enter your repo name and label your issues with either user-story or any other label you would rather use.

# dotnet run --repo ozkary/ai-engineering --label user-story

After running the code successfully, we should be able to see the generated code as a comment on the GitHub issue.

Summary

The Azure OpenAI Service provides a seamless integration of OpenAI models into the Azure platform, offering the benefits of Azure's security, compliance, management, and billing capabilities. On the other hand, using the OpenAI API directly allows for a more direct and independent integration with OpenAI services. It may be a preferable option if you have specific requirements, and you do not want to use Azure resources.

Thanks for reading.

Send question or comment at Twitter @ozkary

👍 Originally published by ozkary.com

The OpenAI Service is a cloud-based API that provides access to Large Language Models (LLM) and Artificial Intelligence (AI) Capabilities. T...

Read Article →

Active Directory SetPassword or ChangePassword Possible Errors

When we try to update the user password on an Active Directory (AD or AD LDS) environment, we usually read on the documentation about the basic steps that are needed to set or change the password to a user. If we follow those basic steps, we would be very lucky of all goes well. There are often several other requirements that need to be met to be able to set the password. Some of these include:

• The password is clear text
• The password does not meet the minimum length requirement
• The password does not meet the format like numeric or capitalization (password policy)
• The Authentication type is not high enough

Any of these items can cause COM error similar to this:

“Exception has been thrown by the target of an invocation COMException (0x80005009)”

To illustrate this, let’s looks at what the basic code to set a user’s password looks like:

//add these setting on the configuration file

        const string adConnection = "ldap://mydomain:389/CN=ORG,DC=OZKARY,DC=COM";

        const string adUsername = "someuser";  //user with admin access to AD

        const string adPw = "*******";

        public static void SetPassword(string username, string password){

            using (var de = new DirectoryEntry(adConnection, adUsername, adPw))

            {

                //Win Server 2008 schema or less uses sAMAccount 

                //not userPrincipalName

         string query = String.Format("(&(objectCategory=person)(objectClass=user)(&(userPrincipalName={0}))", username);           

                using (var ds = new DirectorySearcher(de))

                {

                    ds.SearchScope = System.DirectoryServices.SearchScope.Subtree;

                    ds.Filter = query;

                    SearchResult res = ds.FindOne();

                    if (res != null)

                    {

                        using (var userEntry = res.GetDirectoryEntry())

                        {

                            userEntry.Invoke("SetPassword", new object[] 

                            { password });                           

                        }

                    }

                }

            }

        }

If we are lucky, this should be enough for the operation to be successful, but we are probably getting errors, and that is why we are writing this article.  The first thing to do is to figure out more about this error by extracting the COM exception error code and mapping them to a root cause. This is where this function may be helpful:

  private static void HandleComException(TargetInvocationException tie)

        {          

            if (tie != null && tie.InnerException is COMException)

            {

                COMException ce = (COMException)tie.InnerException;

                int errorCode = ce.ErrorCode;

                string message = ce.Message;

                message += ce.InnerException != null ? ce.InnerException.Message :                                      string.Empty;

                Trace.TraceError(message);

                message = "error_not_found";

                // if the exception is due to password not meeting complexity requirements, 

                // then return ProviderException                

                if ((errorCode == unchecked((int)0x800708c5)) 

                    || (errorCode == unchecked((int)0x8007202f)) 

                    || (errorCode == unchecked((int)0x8007052d)) 

                    || (errorCode == unchecked((int)0x8007052f)))

                {

                    message = "password_not_complex";//password policy not met

                }

                else if ((errorCode == unchecked((int)0x8000500d)))

                {

                    message = "no_secure_conn_for_password";//need higher than security=None

                }

                else if ((errorCode == unchecked((int)0x80072035)))

                {

                    //min password length or the password was used before

                    //The server is unwilling to process the request

                    message="min_password_length_used_before";

                }

                else if ((errorCode == unchecked((int)0x80005009)))

                {

                    message="password_clear_text";//need to set option to use clear text

                }

                throw new ProviderException(message, ce);//need to match this error

            }

           

        }

The exception usually is of type TargetInvocation, but it does not provide enough information to determine the problem. The function reads the inner exception (COM exception) and compare the error code to the possible Active Directory Service Interface (ADSI) errors. As you can see there are other possible errors, but we are only handling the ones that are specific to a password change.

The password not complex and the password length errors basically mean that the new password is not meeting the password policy requirements. We need to find out about those requirements from the AD administrator and make sure that the new password meets them before we attempt to set the password.

Some requirements may be:

• Length of 8 characters
• At least one capital letter or number
• One special character

The unsecured connection and clear text errors can be addressed by making modifications to the code. When we try to update the password for a user, we can’t use a Secure=None level on the authentication type. We need to provide a higher security by adding these lines of code:

AuthenticationTypes auth = AuthenticationTypes.Signing | AuthenticationTypes.Sealing 

| AuthenticationTypes.Secure;          

using (var de = new DirectoryEntry(adConnection, adUsername, adPw,auth))

The clear text error is due to the fact that the password is not hashed, so we need to indicate that this would be OK by adding this line of code:

userEntry.Options.PasswordEncoding = PasswordEncodingMethod.PasswordEncodingClear;

Once we have added those changes, the password update should be able to work or we should at least have added instrumentation in our code to help identified the problem. This is what the new version looks like:

public static void SetPasswordNew(string username, string password)

        {

            AuthenticationTypes auth = AuthenticationTypes.Signing |  AuthenticationTypes.Sealing                                        | AuthenticationTypes.Secure;          

            using (var de = new DirectoryEntry(adConnection, adUsername, adPw,auth))

            {

                //Win Server 2008 schema or less uses sAMAccount not userPrincipalName. 

                //add to config file

string query = String.Format("(&(objectClass=user)(&(userPrincipalName={0}))",                      username);           

                using (var ds = new DirectorySearcher(de))

                {

                    ds.SearchScope = System.DirectoryServices.SearchScope.Subtree;

                    ds.Filter = query;

                    SearchResult res = ds.FindOne();

                    if (res != null)

                    {

                        try

                        {

                            using (var userEntry = res.GetDirectoryEntry())

                            {

                                userEntry.Options.PasswordEncoding =                                 PasswordEncodingMethod.PasswordEncodingClear;    

                                userEntry.Invoke("SetPassword", new object[] { password });

                            }

                        }

                        catch (TargetInvocationException tie)

                        {

                            HandleComException(tie);

                        }

                        catch (Exception ex)

                        {

                            Trace.TraceError(ex.Message); //handle this other error

                          

                        }

                       

                    }

                }

            }

        }

By adding these modifications, the password update should be successful.

Hope this helps and thanks.

When we try to update the user password on an Active Directory (AD or AD LDS) environment, we usually read on the documentation about the b...

Read Article →

The type was not expected. Use the XmlInclude or SoapInclude attribute to specify types that are not known statically

When trying to serialize a complex object using the XmlSerializer, we can encountered a Type was not expected exception. This exception is generated as a result of a property declared as a base type, but the actual reference is done with a child class instance. For example:

og-bit.com

Class Declaration:

public class Account

{

int number { get; set; }

}

public class Client

{

public object[] Accounts { get; set; }

}

The client class has an array of Accounts, but the declaration of the property uses object instead of the Account class. When we try to serialize an instance of Client with the code below, the exception is generated:

Client client = new Client();

client.Accounts = new Account[]{new Account(), new Account()};

StringBuilder stringBuilder = new StringBuilder();

           

 using (XmlWriter xmlWriter = XmlWriter.Create(stringBuilder))

 {

          XmlSerializer serializer = new XmlSerializer(typeof(Client));

          serializer.Serialize(xmlWriter, objRef); 

           xmlWriter.Flush();

  }

InnerException      {"The type Account was not expected. Use the XmlInclude or SoapInclude attribute to specify types that are not known statically."} System.Exception {System.InvalidOperationException}

Solution:

The serializer expects a type of object, but it finds a type of Account instead. The easy fix would be to refactor the property and use Account instead of object. This is not as easy when we do not have access to the source code as in the case when using a third party API. When this is the case, we can tell the serializer to expect unknown types by including an array of types when instantiating the XmlSerializer which provides the following constructor:

public XmlSerializer(

                   Type type,

                   Type[] extraTypes

)

We can now change the previous code with the following:

Client client = new Client();

client.Accounts = new Account[]{new Account(), new Account()};

Type[] types = new Type[] { typeof(Account)};

StringBuilder stringBuilder = new StringBuilder();

           

  using (XmlWriter xmlWriter = XmlWriter.Create(stringBuilder))

  {

                 XmlSerializer serializer = new XmlSerializer(typeof(Client),types);

                 serializer.Serialize(xmlWriter, objRef); 

                 xmlWriter.Flush();

 }

We are now creating an array of Type[] and passing that information to the serializer in its constructor. If you run this code, you can now notice that the exception is no longer raised.  We should also notice that there may be other properties with this problem. When this is the case, we need to include all those types in the array as follows:

Type[] types = new Type[] { typeof(Account), typeof(Address)};

In this case, we added the Address type as another possible type which should be included during the serialization.

I hope I was able to help you understand why this exception is raised when serializing complex objects and show you a way to handle the problem.

When trying to serialize a complex object using the XmlSerializer, we can encountered a Type was not expected exception. This exception is...

Read Article →

What is the difference between ObjectSet and EntityCollection?

When working with the Entity framework, you may see that there are two types of collection created, ObjectSet and EntityCollection. Many of us get a bit confused as of why there are two types of collections and about their use. I will try to describe my understanding of their differences:

ObjectSet Definition from MSDN:

public class ObjectSet<TEntity> : ObjectQuery<TEntity>,

        IObjectSet<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>,

        IQueryable, IEnumerable 

where TEntity : class

ObjectSet provides access to entities/tables of a database.  ObjectSet is IQueryable which means that when you use this reference with a LINQ query, the expression is changed to the SQL expression for the provider (i.e. Entity classes mapping to SQL Server). This is how LINQ works for the LINQ to Entities expressions to be able to select records from the database.

EntityCollection Definition from MSDN:

public sealed class EntityCollection<TEntity> : RelatedEnd, 

        ICollection<TEntity>, IEnumerable<TEntity>, IEnumerable, IListSource 

where TEntity : class

EntityCollection is a collection type which represents “many” entities. When we use LINQ to query an EntityCollection, we are using LINQ to Objects to retrieve the “in-memory” objects in the collection, and no query is executed in the database.  The records for this collection are the ones associated to a main entity as a property and are loaded using the Load method which uses an ObjectSet to load the records from the database. Look at this pseudocode:

VehicleMake: IQueryable{                //represents the ObjectSet

        VehicleModels:IEnumerable      //represents an EntityCollection populated by Load()

}

VehicleModels:IQueryable{// ObjectSet which gets the records from the database

}

og-bit.com

When the collection is a property is an EntityCollection.

I hope this is able to help some of you.

When working with the Entity framework, you may see that there are two types of collection created, ObjectSet and EntityCollection. Many of...

Read Article →

Fluent Interface to Simplify an API

The mail goal of an API is to facilitate the use of commands and attributes to achieve certain functionality.  Over time, an API may have evolved and become somewhat obscure on its usage which reduces its usability and increases the implementation time.

To clean/simplify an API you can apply a fluent interface to it. This allows you to modify the API with a more descriptive interface which improves its usability. At the same time, this preserves the current API interface and eliminates the risk of introducing bugs to code that is already implemented.  To get a better understanding, let‘s take a look at an order system. To create an order, an API often uses the following code:

//customer and order detail

Customer cust = new Customer() { CustomerId = 12900 };

OrderItem item1 = new OrderItem { Name = "Pen", PricePerUnit = .99, Quantity = 10, Sku = "1675" };

OrderItem item2 = new OrderItem { Name = "Notepad", PricePerUnit = 2.99, Quantity = 10, Sku = "5456" };

OrderItem item3 = new OrderItem { Name = "Marker", PricePerUnit = 1.99, Quantity = 10, Sku = "9836" };

//standard API to create the order

OrderHeader oh = new OrderHeader();

oh.Customer = cust;

oh.AddItem(item1);

oh.AddItem(item2);

oh.AddItem(item3);

oh.Complete();

oh.Send();

That code sample is a simple API order system that is creating an order request with three items. You may argue that the code is really simple to follow, and there is no need to refactor, and I agree with you. However, we should think of a more complex API which may require you to add so many lines of code and call methods that are not that descriptive. With that in mind, let’s look now at how we can make the order creation a bit fluent:

//Fluent API

OrderHeader.CreateOrder()

.WithCustomer(cust)

.WithItems(item1,item2,item3)

.CompleteAndSend();

You can see that the code reads more like a sentence or language than actual method calls. It is descriptive and easier to use which is our main goal.  So how does the code for this look?  Well, let’s see now:

/// <summary>

/// defines a domain specific interface

/// </summary>

interface FluentOrderHeader

{

FluentOrderHeader WithItems(params OrderItem[] item);

FluentOrderHeader WithCustomer(Customer cust);

void CompleteAndSend();

}

/// <summary>

/// partial class to expose fluent api

/// </summary>

partial class OrderHeader : FluentOrderHeader

{

public static FluentOrderHeader CreateOrder()

{

return new OrderHeader();

}

public FluentOrderHeader WithItems(params OrderItem[] items)

{

foreach (OrderItem item in items)

{

   this.AddItem(item);

}

return this;

}

public FluentOrderHeader WithCustomer(Customer cust)

{

this.Customer = cust;

return this;

}

public void CompleteAndSend()

{

this.Complete();

this.Send();

}

}

We first define the interface with the methods that can help our API become fluent.  You should note that each call returns the instance reference. This allows for the chaining of the methods.  The next step is to create a partial class of the OrderHeader that implements our interface. This allows us to isolate the changes to the partial class without making any modifications to the current code. This new class handles the implementation changes using the existent API.

In my opinion, a fluent interface should be used to simplify obscure APIs which are often used in several projects. If the API is only use by one system, the effort to adapt a fluent interface may not be necessary. We need to keep in mind that a fluent implementation requires a bit more thinking, so it can actually provide a descriptive and fluent set of methods which allows any developer to easily follow it. Do not confuse this with just method chaining. The main different between method chaining and fluent interface is that with the latter we are trying to define a domain specific language that tries to target a specific task. Method chaining just facilitates the use of APIs by returning a reference, so it can be used in subsequent calls.

og-bit.com
CodeProject

The mail goal of an API is to facilitate the use of commands and attributes to achieve certain functionality.  Over time, an API may have ev...

Read Article →