Wednesday, March 29, 2023

Boost your productivity and creativity with ChatGPT as a C# developer with these 5 tips




ChatGPT is a language model that is optimized for conversational interfaces. It can interact with users in a natural and engaging way, and can also perform tasks such as generating code, optimizing code, and testing code .

 

Here are 5 ways you can use ChatGPT to boost your productivity as a C# developer:

 

Code Optimization

 Optimizing your code can improve its performance, readability, and maintainability. However, it can also be challenging and complex, especially for large and legacy codebases. ChatGPT can help you optimize your code by suggesting improvements and refactorings based on best practices and coding standards. You can ask ChatGPT to review your code and provide feedback on how to make it more efficient, elegant, and consistent. You can also ask ChatGPT to apply the suggested changes automatically or manually.

Chat GPT is a powerful tool that can help you optimize your code with examples for c#. Chat GPT is a chatbot that uses natural language processing and deep learning to understand your coding problems and generate solutions. You can ask Chat GPT to optimize your code for speed, memory, readability, or any other criteria you specify. Chat GPT can also provide you with examples of how to use different features or libraries in c#, such as LINQ, async/await, delegates, etc.

 

For example, suppose you have a code snippet that calculates the sum of all the even numbers in an array:

 


int[] numbers = {1, 2, 3, 4, 5, 6};

int sum = 0;

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] % 2 == 0)
    {
        sum += numbers[i];
    }
}

 

You can ask Chat GPT to optimize this code for speed and readability. Chat GPT might generate something like this:

 


int[] numbers = {1, 2, 3, 4, 5, 6};

int sum = numbers.Where(n => n % 2 == 0).Sum();

 

This code uses LINQ to filter the even numbers and sum them in one line. This is faster and more readable than the original code.

 

As you can see, Chat GPT can optimize your code with examples for c# in various ways. You can use Chat GPT to improve your coding skills and productivity. Chat GPT is your friendly and helpful coding assistant.

Code Generation

Sometimes you may need to write new code from scratch or extend existing code with new features or functionalities. ChatGPT can help you generate code based on your natural language description or specification. You can simply tell ChatGPT what you want to achieve or implement, and it will write the corresponding C# code for you. This can speed up your development process and also help you explore new ideas and possibilities.

 

Another example is if you want to learn how to use async/await in c#. You can ask Chat GPT to show you an example of how to make an asynchronous HTTP request using HttpClient. Chat GPT might generate something like this:

 


using System.Net.Http;
using System.Threading.Tasks;


async Task GetResponseAsync(string url)
{
    HttpClient client = new HttpClient();

    HttpResponseMessage response = await client.GetAsync(url);

    response.EnsureSuccessStatusCode();

    string content = await response.Content.ReadAsStringAsync();

    return content;
}

 

This code uses the async and await keywords to make an asynchronous HTTP request and return the response content as a string. This is more efficient and elegant than using synchronous methods or callbacks

Code Documentation

 Documenting your code is important for making it understandable, reusable, and maintainable. However, it can also be boring and repetitive, especially for complex and lengthy code. ChatGPT can help you document your code by generating comments, summaries, and descriptions based on your code logic and structure. You can ask ChatGPT to document your code at different levels of granularity, such as methods, classes, modules, or projects. You can also ask ChatGPT to update your documentation when you make changes to your code.

 

It can summarize your code by extracting the main logic and functionality of your program and presenting it in natural language. For example, if you have a code snippet like this in C#:


using System;

class Program
{

    static void Main(string[] args)
    {
        int x = 10;
        int y = 20;
        int z = x + y;

        Console.WriteLine("The sum of x and y is " + z);

    }
}

Chat GPT will then summarize the code like this "The program defines three variables: x, y, and z. It assigns the values 10 and 20 to x and y respectively. It calculates the sum of x and y and assigns it to z. It prints the value of z to the console".


Code Debugging

 Debugging your code can be frustrating and time-consuming, especially when you encounter errors or bugs that are hard to find or fix. ChatGPT can help you debug your code by providing suggestions and solutions based on your error messages or test results. You can ask ChatGPT to explain the cause of an error or bug, suggest possible fixes or workarounds, or apply the fixes automatically or manually.


 Unit Test Generation

 Writing unit tests can be tedious and time-consuming, but they are essential for ensuring the quality and reliability of your code. ChatGPT can help you generate unit tests automatically based on your code and specifications. You can simply provide ChatGPT with your code snippet and some test cases, and it will write the corresponding unit test code for you. This can save you a lot of time and effort, and also help you catch bugs and errors early on.


These are just some of the ways you can use ChatGPT to increase productivity for software developers who use C#. ChatGPT is a powerful and versatile tool that can handle a variety of tasks and scenarios related to C# development. You can try ChatGPT yourself at chat.openai.com or learn more about it at openai.com/blog/chatgpt.



**Note, this was written using AI and was a test of Chat GPT to see if it would increase organic traffic**

Monday, March 6, 2023

How I Used ChatGPT to Respond to my Emails in 5 Minutes



What is ChatGPT?

ChatGPT is an advanced AI chatbot created by the folks at https://openai.com that can accurately reproduce human responses without prior training on the subject. The GPT stands for generative pre-trained transformer, which means the model is already trained. This is different than a traditional chat bot, see my example here https://www.fiveminutecoder.com/2020/12/create-faq-bot-using-microsoft-bot.html, that needs prior knowledge on a subject to create accurate response to the subject. ChatGPT can also be tuned for your business similar to a traditional chat bot system by training the system with additional information. 

What makes ChatGPT so impressive is the confident responses made by the bot. You ask it a question and it will respond with an in depth answer. It also allows for follow up questions giving a feeling of a natural conversation with a human. Many people, including developers, are seeing the power of this and questioning if their job is in danger. While the tool is impressive, it does not replace the extensive knowledge gained by troubleshooting an issue for hours. Also, while the chat bot is confident in its answers this does not mean it is right. 

To test out ChatGPT I decided to make an email response app to respond to all the junk mail I get. This will be an Azure function that runs in 5 minute intervals. It will use the Graph API to check my email for new emails then send the subject/body of the email to the ChatGPT API. I found that the subject helps with a better response. Once I get a response I will reply to the email and set it to read. I wanted to see how the API and bot worked. So I asked it how to create an integration to the API while the system got me started it's response were either incomplete or outdated. 

Let's use ChatGPT to setup Chat GPT

Since Chat GPT is known for giving detailed responses to questions including code, lets just ask the chatbot how to setup ChatGPT in C#. 




Great! this looks like it will work. During setup however, this was wrong. It looks like the NuGet Package was updated to support Open API GPT-3 which changed the code. The updated calls can be found on the GitHub site here: https://github.com/OkGoDoIt/OpenAI-API-dotnet.

Before writing the app, I wanted to test out the API using PostMan. I wanted to get a feel that the chatbot could respond so again, I asked the Chat GPT chatbot for how to use Postman.



Again this looked promising. I setup Postman as the instructions showed and got an error. There was no model parameter passed in the JSON file. The model is quite important the model is what chat bot to use.... I guess that is an 0/2 using Chat GPT to code. 



 In my tests I used two different models "Davinci", which is the most sophisticated, but the slowest, and "Curie" which is a faster model. Out of the two, Davinci came across angrier in it's responses so I decided to use Curie for this example. Here are some of the responses I got from Postman using a junk email, basically they are replies with false information, hilarious!

"I look forward to hearing from you.Please share this with your team and I would be happy to provide details on our past projects.Regards,Shailesh Srinivasan"

" If you could send me your skype ID that would be great. Thank you."

 " I will discuss project portfolio, your team's strengths and skill gaps, the job description and requirements, and how you will benefit from working with us. All of our consultants are seasoned professionals who have worked for fortune 500 companies and top-tier consulting firms. We are typically able to leverage our existing resources to find the right talent for you.I look forward to working with you.Regards,TedFor a free consultation please contact me at ted@TECHstaffing.com. I am happy to help you with your project staffing needs. Please visit our website at www.TECHstaffing.com for more information. Ted KolodziejskyPhone: 1-972-200-1791Email: ted@TECHstaff"
 
 " I would love to chat about the following topics:1. What is the best way to build a strong engineering team?2. What are your hiring challenges?3. What is your IT roadmap for the next 3-5 years?4. What",


From this experience, I dont see Chat GPT taking my job anytime soon, but still to complete the exercise, the auto response Azure Function can be found below.

Creating an Email Auto Responder in 5 minute

To begin, an Azure function must be created, the details to create an Azure function can be found in a previous post here, https://www.fiveminutecoder.com/2021/05/create-email-tracking-campaign-using.html. Also, a Graph API application must be created. Again, details about how to do this can be found in a previous post here, https://www.fiveminutecoder.com/2021/03/creating-azure-document-queue-for.html. For the app permissions, application permissions are necessary. Under the Graph API section, find the mail section. The app will need read/write permissions and send as permissions.




Next the following Nuget packages must be installed.

 Azure.Identity, Microsoft.Graph, Microsoft.Graph.Core, OpenAI


At the top of the function I added my using statements for the installed nuget packages.


using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;
using System.Collections.Generic;
using Microsoft.Graph;
using Microsoft.Graph.Models;
using Azure.Identity;

Next I defined my IDs necessary to access all the apps. This includes the Chat GPT API and Graph API.


//openAISecretKey
private string openAIKey = "";
//ID of the mailbox you want to auto reply from
private string userId = "user id of mailbox";
//ID of the tenant used
private string tenantId = "azure tenant"; 
//App id from created azure app
private string clientId = "registered app client id"; 
//Secret created for the app
private string clientSecret = "registered app secret"; 
//hold our graph context here for our calls
private GraphServiceClient graphService;

Inside the Run function, i setup the calls to get the unread emails then loop through the emails and respond to the email.


[FunctionName("CheckNewEmail")]
public async Task Run([TimerTrigger("0 */5 * * * *")]TimerInfo myTimer,  ILogger log)
{
	try
	{
		log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
		graphService = GetGraphAPIClient();
		List newMessages = await GetNewEmails();
		log.LogInformation("found " + newMessages.Count);
		foreach(Message message in newMessages)
		{
			log.LogInformation("replying to " + message.Subject);
			string response = await GetChatGPTResponse(message.Subject, message.Body.Content);
			await SendEmail(message.Id, message.From, response);
			await UpdateToRead(message.Id);
			log.LogInformation("Reply successful");

		}
	}
	catch(Exception ex)
	{
		log.LogError(ex, ex.Message);
	}
}  


To instantiate the graph service I used the new Azure.Identity to create an authentication scope and then return the created service to be used throughout the application.


//Create the graph service client  that will be used to get and respond to emails
private GraphServiceClient GetGraphAPIClient()
{
	
	string[] scopes = new string[] {"https://graph.microsoft.com/.default" };
	// using Azure.Identity;
	var options = new TokenCredentialOptions
	{
		AuthorityHost = AzureAuthorityHosts.AzurePublicCloud
	};

	ClientSecretCredential clientSecretCredential = new ClientSecretCredential(
		tenantId, clientId, clientSecret, options);

	GraphServiceClient graphClient = new GraphServiceClient(clientSecretCredential, scopes);
	return graphClient;
}


Using the newly created client, a call is made to the Graph API to get all the unread emails using the isRead filter.


//Graph API call to get all unread emails
private async Task> GetNewEmails()
{
	MessageCollectionResponse messages = await graphService.Users[userId].Messages.GetAsync((requestConfiguration) =>{
		requestConfiguration.QueryParameters.Filter = "isRead eq false";
	});
	
	return messages.Value;
}

Once all the emails are fetched, the subject and body are combined into one string and then sent to the Chat GPT API.


//The call to the Chat GPT end point
private async Task GetChatGPTResponse(string Subject, string Body)
{
	OpenAI_API.OpenAIAPI openai = new OpenAI_API.OpenAIAPI(openAIKey);

	//Create a request suitable for the Chat GPT API. It will remove an non readable characters that the API cannot read
	OpenAI_API.Completions.CompletionRequest completionRequest = new OpenAI_API.Completions.CompletionRequest(Subject + "." + Body, OpenAI_API.Models.Model.CurieText,150);

	// Send a request to the ChatGPT model
	OpenAI_API.Completions.CompletionResult response = await openai.Completions.CreateCompletionAsync(completionRequest);

	return response.Completions[0].Text;
}


With an AI generated response, I send an email using the Graph API to the original sender.


//Graph API call to send reply to email
private async Task SendEmail(string MessageId, Recipient RecipientEmail, string Response)
{
	Microsoft.Graph.Users.Item.Messages.Item.Reply.ReplyPostRequestBody reply = new Microsoft.Graph.Users.Item.Messages.Item.Reply.ReplyPostRequestBody
	{
		Message = new Message
		{
			ToRecipients = new List
			{
				new Recipient()
				{
					EmailAddress = new EmailAddress()
					{
						Address = RecipientEmail.EmailAddress.Address,
						Name = !String.IsNullOrEmpty(RecipientEmail.EmailAddress.Name) ? RecipientEmail.EmailAddress.Name : RecipientEmail.EmailAddress.Address
					}
				}
			},
		},
		Comment = Response,
		
	};

	await graphService.Users[userId].Messages[MessageId].Reply.PostAsync(reply);
}


Finally, I set the email to read so it is not picked up by the next call.


//Graph API call to update email to read
private async Task UpdateToRead(string MessageId)
{
	
	//only update the properties we want to update
	Message msg = new Message()
	{
		IsRead = true
	};
	await graphService.Users[userId].Messages[MessageId].PatchAsync(msg);
}


 
That's it! A function for responding to emails has been created and let the spammers be enthralled by the witty comebacks of the AI. To view the code, please visit my GitHub page here: https://github.com/fiveminutecoder/blogs/tree/master/ChatGPTEmail

UPDATE!!!!

With the general release of ChatGPT 3.5 the responses have changed significantly. We can give the bot a persona to respond to the emails which greatly changes the usefulness of the application. While I miss the snarky response of Davinci using ChatGPT 3.5 is the way to go.

To test this in Postman, all that needs to be done is update the body to include messages instead of prompt. You will see the messages section is an array. This is to help with persistence in responses. Also notice system and user role. System role allows me to tell the chat bot how to act, while the user role is the content to respond to.


{
    "messages":[
        {"role": "system", "content": "You are the assistant to the Director of IT. He does not want any meetings"},
        {"role": "user", "content": "email body here!!"}
    ],
    "temperature": 0.7,
    "max_tokens": 3250,
    "top_p": 1,
    "frequency_penalty": 0,
    "presence_penalty": 0,
    "model": "gpt-3.5-turbo-0301"
}


For the C# application instead of the completion endpoint, the ChatCompletion endpoint will be used, this is a quick change to handle the new message array.




var result = await api.Chat.CreateChatCompletionAsync(new ChatRequest()
{
	Model = Model.ChatGPTTurbo,
	Temperature = 0.7,
	MaxTokens = 50,
	Messages = new ChatMessage[] {
	new ChatMessage(ChatMessageRole.System, "You are the assistant to the Director of IT. He does not want any meetings")
		new ChatMessage(ChatMessageRole.User, "email body here!!")
	}
});

Tuesday, December 27, 2022

Auto Tagging Invoices Using Azure AI Cognitive Services in 5 Minutes


 


In a previous blog post we covered SharePoint Syntex for auto tagging invoices by using a content type, which can be found here SharePoint Syntex in 5 Minutes. Sometimes there needs to be more processing outside of SharePoint before the document can be uploaded or external systems must be accessed for metadata properties. This kind of functionality can become very complex when trying to use a Power App or Flow to accomplish this. Microsoft provides AI services for reading invoices that can be read and then used for the business logic that goes beyond what Syntex can do. These services are a consumption based API in Azure that allows uploading invoices for processing to return the same metadata results that can be found in SharePoint Syntex.


Setting up Azure

1) Create a Cognitive Services Plan






2) Once the cognitive services is created, there is a list of several services including form services. Selecting this will open up the form studio which allows for uploading and reviewing the forms the service will be used for training.




3) Since this is a 5 minute tutorial, I will be using the prebuilt invoice recognizer.


4) Since this is a prebuilt model it comes with several examples already loaded. By clicking the "Analyze" button, the invoice will highlight all the points of interest and assign it metadata. This screen is verry similar to the SharePoint Syntex screen seen in my previous blog SharePoint Syntex in 5 Minutes


5) To make sure this predefined model works for your invoices, select the upload in the top left corner and then upload a sample invoice.




6) Finally, a storage account for the invoice service to access documents must be created. Our invoice service must be able to access the files they must be made available. For this demo, I will be making my blob storage available to the internet. For security reasons DO NOT DO THIS IN PRODUCTION. For a production environment you will want to setup a network for your AI service that is connected to your blob storage for secure access. For details on how to create a storage account, see my pervious blog post Create an Azure Document Queue for Loading and Tagging SharePoint Documents - Part 1


Consuming the service

For this example, I created a WPF app to display our uploaded invoice and its associated properties. To begin, 4 NuGet packages must be installed.

These 2 are needed for the form recognition service, the form recognizer API reading the invoice and the Azure storage blob API for exposing the invoice.


Azure.AI.FormRecognizer
Azure.Storage.Blobs

The other 2 NuGet packages needed are for drawing our invoice. PdfLibCore will be used to convert the PDF into an Image and System.Drawing.Common will be used for drawing the image. It is important to note that this example was done on Windows. System.Drawing may not be Linux/Mac compatible.


System.Drawing.Common
PdfLibCore

The app layout is a simple grid system made up of 3 rows. One for uploading an invoice, the other for displaying it's properties, and then the bottom row for any errors while uploading.


<window height="1000" mc:ignorable="d" title="Five Minute Invoice Tagger" width="1600" x:class="FiveMintueInvoiceTagger.MainWindow" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:local="clr-namespace:FiveMintueInvoiceTagger" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
    <grid>
        <grid.columndefinitions="">
            <columndefinition width="500"></columndefinition>
            <columndefinition width="1100"></columndefinition>
        </grid>
        <grid.rowdefinitions="">
            <rowdefinition height="50"gt;</rowdefinition>
            <rowdefinition height="750"gt;</rowdefinition>
            <rowdefinition height="750"gt;</rowdefinition>
        </grid>
        <stackpanel grid.column="0" grid.row="0">
        <label content="Select an invoice...">
        <button click="UploadFile_Click" content="Select Invoice">
        </button></label></stackpanel>
        <image grid.column="0" grid.row="1" height="800" name="InvoiceImage" width="450">
    <datagrid grid.column="1" grid.row="1" height="800" name="DocumentProperties" width="1050">
    <label grid.column="0" grid.row="2" name="ErrorMsg">
    </label></datagrid></image></grid> 
</window>

Next, an object is needed to hold our invoice properties for displaying the results. This class has 3 items, the Field's name, the Field's Value, and the confidence score that the API grabbed the right information.


public class InvoiceProperty
{
	//Field name found on invoice
	public string Field {get;set;}
	//Field value
	public string Value {get;set;}
	//How confident AI is that field value is correct
	public string Score {get;set;}
}

References to the NuGet packages must be added to the project, along with some other using statements for displaying the invoice image.


using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media.Imaging;
using Azure;
using Azure.AI.FormRecognizer.DocumentAnalysis;
using Azure.Storage.Blobs;
using PdfLibCore;
using PdfLibCore.Enums;

A click event is added to the upload button to grab the invoice and process the request. This method is async so a loading screen should be added. Since this a 5 minute application it has been omitted.


private async void UploadFile_Click(object sender, RoutedEventArgs e)  
{  
	try
	{
		ErrorMsg.Content = "";

		//we only want pdf invoices
		Microsoft.Win32.OpenFileDialog openFileDlg = new Microsoft.Win32.OpenFileDialog(); 
		openFileDlg.Filter = "Pdf Files|*.pdf";
		// Launch OpenFileDialog by calling ShowDialog method
		Nullable result = openFileDlg.ShowDialog();
		// Get the selected file name and display in a TextBox.
		// Load content of file in a TextBlock
		if (result == true)
		{
			//Upload to azure blob so Azure AI can access file
			string invoicePath = await UploadInvoiceForProcessing(openFileDlg.FileName);

			//perform Invoice tagging
			Task> invoicePropertiesTask = GetDocumentProperties(invoicePath);

			//Convert PDF to image so we can view it next to properties
			UpdateInvoiceImage(openFileDlg.FileName);

			//Wait for Azure to return results, set it to our data grid
			DocumentProperties.ItemsSource = await invoicePropertiesTask;

		}
	}
	catch(Exception ex)
	{
		ErrorMsg.Content = ex.Message;
	}
}

In our button event, there are 3 functions called One for uploading the invoice to Azure, one for processing the invoice, and one for converting the image. Our upload function will upload the invoice to Azure Blob Storage to make the invoice available to the Azure Form Recognizer Service. Again, in a production environment make sure your blob storage is not publicly available. 


private async Task UploadInvoiceForProcessing(string FilePath)
{
	string cs = "";
	string fileName = System.IO.Path.GetFileName(FilePath);
	Console.WriteLine("File name {0}", fileName);
	//customer is the name of our blob container where we can view documents in Azure
	//blobs require us to create a connection each time we want to upload a file
	BlobClient blob  = new BlobClient(cs, "invoice", fileName); 

	//Gets a file stream to upload to Azure
	using(FileStream stream = File.Open(FilePath, FileMode.Open))
	{
		var blobInfo = await blob.UploadAsync(stream);
		
	}
	
	return "blob base storage url" + fileName;
}

Next the invoice URL is passed to the Form Recognizer Service for processing


private async Task> GetDocumentProperties(string InvoicePath)
{
	
	List invoiceProperties = new List();

	//Endpoint and key found in Azure AI service
	string endpoint = "ai service url";
	string key = "ai service key";
	AzureKeyCredential credential = new AzureKeyCredential(key);
	DocumentAnalysisClient client = new DocumentAnalysisClient(new Uri(endpoint), credential);

	//create Uri for the invoice
	Uri invoiceUri = new Uri(InvoicePath);

	//Analyzes the invoice
	AnalyzeDocumentOperation operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Completed, "prebuilt-invoice", invoiceUri);
	AnalyzeResult result = operation.Value;

	//iterate the results and populates list of field values
	for (int i = 0; i < result.Documents.Count; i++)
	{
		AnalyzedDocument document = result.Documents[i];
		foreach(string field in document.Fields.Keys)
		{
			DocumentField documentField = document.Fields[field];
			InvoiceProperty invoiceProperty = new InvoiceProperty()
				{
				  Field = field,
				  Value = documentField.Content,
				  Score = documentField.Confidence?.ToString()
				};

				invoiceProperties.Add(invoiceProperty);
			}
	}

	return invoiceProperties;
}


While the invoice is being processed, the application will convert the PDF to an image to be displayed in the application. The form recognizer service returns references for the PDF to draw the bounding boxes of the data found which could be used to draw onto the image.


 private void UpdateInvoiceImage(string FilePath)
{
	using(var pdf = new PdfDocument(File.Open(FilePath, FileMode.Open)))
	{
		//for this example we only want to show the first page
		if(pdf.Pages.Count > 0)
		{
			var pdfPage = pdf.Pages[0];

			var dpiX= 600D;
			var dpiY = 600D;
			var pageWidth = (int) (dpiX * pdfPage.Size.Width / 72);
			var pageHeight = (int) (dpiY * pdfPage.Size.Height / 72);
		
			var bitmap = new PdfiumBitmap(pageWidth, pageHeight, true);                                

			pdfPage.Render(bitmap, PageOrientations.Normal, RenderingFlags.LcdText);
			BitmapImage image = new BitmapImage();
			image.BeginInit();
			image.StreamSource = bitmap.AsBmpStream(dpiX,dpiY);
			image.EndInit();
			InvoiceImage.Source = image;
		}
		
	}
}


Once this is completed your application will display the invoice with the properties found with an application created in 5 minutes.




To view the full code, please visit the Five Minute Coder GitHub here: Five Minute Invoice Tagger


C#, C sharp, machine learning, ML.NET, dotnet core, dotnet, O365, Office 365, developer, development, Azure, Supervised Learning, Unsupervised Learning, NLP, Natural Language Programming, Microsoft, SharePoint, Teams, custom software development, sharepoint specialist, chat GPT,artificial intelligence, AI

Cookie Alert

This blog was created and hosted using Google's platform Blogspot (blogger.com). In accordance to privacy policy and GDPR please note the following: Third party vendors, including Google, use cookies to serve ads based on a user's prior visits to your website or other websites. Google's use of advertising cookies enables it and its partners to serve ads to your users based on their visit to your sites and/or other sites on the Internet. Users may opt out of personalized advertising by visiting Ads Settings. (Alternatively, you can opt out of a third-party vendor's use of cookies for personalized advertising by visiting www.aboutads.info.) Google analytics is also used, for more details please refer to Google Analytics privacy policy here: Google Analytics Privacy Policy Any information collected or given during sign up or sign is through Google's blogger platform and is stored by Google. The only Information collected outside of Google's platform is consent that the site uses cookies.