AI on Azure Readiness starts here...

Azure SRE Agent: Bringing Agentic AI to Site Reliability Engineering on Azure

Sat, 14 Mar 2026 09:30:00 -0700

If you have been following me for a while, you know I’m a big fan of Azure reliability. It was the main topic I presented on several years ago (in the early days of Azure - if that sounds right?) and also mapped with a big part of my job as Azure Architect, consultant and trainer.

I got amazed at the end of 2021 by Azure Chaos Studio, a service that allows you to inject faults against your Azure workloads (preferably production!), to make them more stable, more reliable.

But then came Generative AI, and Agentic InfraOps/DevOps. Welcome Azure SRE Agent, which was in public preview for a few months, but went GA earlier this week. I played with it since its early inception, and thought the GA - with a lot of cool new updates - was a good time to dedicate a blog article to it.

Introduction: What Is Azure SRE Agent?

Modern cloud systems are increasingly distributed, dynamic, and failureâ€‘prone by design. While DevOps practices have optimized delivery velocity, operational reliability still demands significant human effort. Particularly during incident response, root cause analysis, and postâ€‘incident followâ€‘up. (Having been on the consultant side in physical and cloud environments since 1996, especially the outages and trying to fix issues is what got me into training - is what my wife says when you ask her why I love training so much, lol. She might be right…)

Azure SRE Agent is an AIâ€‘powered reliability assistant designed to automate and augment Site Reliability Engineering practices for Azure workloads. It continuously observes telemetry (metrics, logs, traces), understands Azure resource topology, correlates incidents with recent changes, and assists with, or ask human approval to execute, remediation steps.

Unlike traditional monitoring or AI-Ops tools, Azure SRE Agent operates as an agentic system:

It reasons over multiple data sources simultaneously.
It maintains contextual awareness of your Azure environment.
It can take action via Azure CLI and REST APIs, subject to explicit approval.
It integrates natively with incident management and developer workflows.

In effect, Azure SRE Agent acts as a virtual SRE teammate, reducing operational toil and lowering mean time to resolution (MTTR) while preserving human oversight. (If we had agents in the early 2000’s, maybe I would still be a technical consultant instead of technical trainer, hmmmm)

Architecture and Core Capabilities

At a high level, Azure SRE Agent combines four capability pillars:

Continuous Observability Ingestion
The agent consumes signals from Azure Monitor, Log Analytics, Application Insights, and supported external observability systems to build a live understanding of system health and dependencies. The real benefit for me here, is that organizations already have everything in place. So the adoption goes smooth. And the data the agent relies on, feels familiar.
Intelligent Diagnosis and Correlation
When an alert or anomaly occurs, the agent correlates telemetry with:
- Recent deployments or configuration changes
- Resource topology and dependencies
- Historical incident patterns
  This enables accelerated root cause analysis without manual log spelunking. (does that exist as a word?)
Automated and Approvalâ€‘Gated Remediation
Azure SRE Agent can execute operational actions. Think of scaling, restarting services, or reverting deployments. Or basically anything that relies on Azure CLI and REST APIs. All write actions are gated by RBAC and explicit approval, ensuring governance and control. (If you don’t trust the commands it suggests, don’t approve the action…)
Workflow and Developer Tool Integration
The agent integrates with Azure Monitor alerts, GitHub, Azure DevOps, ServiceNow, and PagerDuty, allowing incidents to flow naturally into existing operational and engineering processes. (I have to be honest, I didn’t go that far yet to integrate with source control, probably another blog post in the near future)

Setup and Deployment

Prerequisites

To deploy Azure SRE Agent, the following prerequisites must be met:

An active Azure subscription
Permissions to assign RBAC roles (Microsoft.Authorization/roleAssignments/write)
Network access to the *.azuresre.ai domain
Deployment in a supported region (Preview was available in EastUS2, SwedenCentral and AustraliaEast), you might check the docs for accurate updates

Note: I didn’t find any information on how to automate the deployment using bicep or az cli - have to come back to that at some point

Creating an Azure SRE Agent

In the Azure Portal, search for Azure SRE Agent.
Select Create Agent.
Create or select a dedicated resource group for the agent itself (I would recommend deploying this separate from application resources).
Choose the region.
Associate one or more resource groups to monitor.
The agent automatically gains visibility into all resources within those groups.
Complete the deployment and wait for the agent to initialize.

Once deployed, the agent exposes a chatâ€‘based interface in the Azure Portal, allowing engineers to interact using natural language to investigate and manage incidents.

Using Azure SRE Agent

After the baseline deployment of the agent, it’s nothing more than running prompts. Using natural language, asking generic or more-specific questions, and off it goes :)

To test this out, I deployed an Azure App Service, connecting to CosmosDB using Managed Identity. After testing the app, I removed the App Service Managed Identity to simulate the issue.

I opened SRE Agent and asked:

can you investigate my app service outage

This is what it came back with:

Followed by looking into the metrics

To then provide a summary of the findings and observations, INCLUDING CHART VIEWS

Detailed Root Cause Analysis

and detailed description of what happened and Recommended actions

It identified the root cause being an identity problem, where the Web App could not connect to Cosmos DB.

To wrap it up with a Diagnosis Complete - Data Unreachable Root Cause report (in table format), including potential fix steps (Isn’t that amazing?? I think it’s just brilliant…!!!)

From there, it asked me if it was OK to move on and assist with fixing the problem. Using the same response I would tell when talking to a colleague, I said

Yes, go ahead and assist me with fixing this problem using the described steps

(I’m pretty sure just saying “yes”, or “sure” or “OK” or “YOUCANDOIT” might have worked too…)

The above screenshot was taken after the process completed, but remember the SRE Agent can only perform actions when you as the human-in-the-loop acknowledges the approval.

Smoothly, it came back with Issue resolved. Including a summary of the steps taken

Well done SRE Agent!!

Summary

Azure SRE Agent is - apart from GitHub Copilot - my next favorite use case for Generative AI. Having experienced the challenges of cloud workload outages myself for years, spending hours, sometimes days, digging in, gathering metrics and logs, pinpointing the root-cause,… (which sort of was a lucrative business if I think back about it…), I think this is an amazing service to be added to your Azure environment. Even when you don’t trust it at first (actually, why not?) to take actions, having that AI assistant next to you to help you with the investigation, the outage analysis,… will be a big time-saver. Which means, your workload will be back up-and-running faster too.

And I didn’t talk about the source control integration with GitHub or Azure DevOps. I didn’t mention the notifications through Outlook or Teams. I didn’t explain the expansion to other data scenarios, third-party monitoring tools such as Grafana, DataDog,… damn, there will be a lot of blog posts on Azure SRE Agent in the near-future I’m afraid.

Also, if you want some inspiration to play with this, have a look at the Microsoft Learn lab - Optimize Azure Reliability using SRE Agent I published recently.

If you deployed it and use it in your environment, please let me know. Happy to hear your stories!

Cheers!!

/Peter

How Spotify disappointed me with AI Artists

Sat, 29 Nov 2025 00:00:00 +0000

I’m usually pretty excited about AI and more specifically about Generative AI, especially with Microsoft Copilot, GitHub Copilot and Microsoft Foundry. I might be biased, but outside of my professional interactions with GenAI, I’m not into all the social media hypes around it (anyone remembers the Studio Gihbli hype from summer or any similar?)

With a few days off for Thanksgiving here in the USA, I wanted to spend a bit more time on updating my Spotify playlists. While not always perfect, at least a few of the ‘recommended artists’ are closely in line with the artists and songs I like.

The search for new sounds

I always enjoyed listening to music, and exploring new artists. I remember as a kid going to the music store, buying LPs, and later on CDs. And honestly, I discovered several new great artists thanks to Spotify. Thereâ€™s a special thrill in discovering new music. For now, it started with a simple quest: I wanted to explore the country blues rock corner. Think soul, whiskey bars, gritty guitar riffs, and that raw energy that bridges the rural blues tradition with rockâ€™s rebellious spirit. It also brings back great memories to House of Blues during work travel trips.

I actually discovered Sons of Legion recently, which offers a unique mix of authentic soul, folk and rock music, as they describe it themselves.

So I dove in. I let Spotifyâ€™s recommendation engine guide me, clicking â€œlikeâ€ on songs that resonated, building a playlist over the course of a week. The algorithm seemed to understand me well. The tracks had the right vibe: swampy slide guitar, stomping rhythms, smoky vocals. I was hooked.

The nasty suprise of discovery

But then came the surprise. As I looked closer at the artists behind these songs, something I usually do to learn more about what got them into the music scene, where they are from, what other albums do they have,… I realized something interesting: One of the artists was an AI-generated artist: Breaking Rust.

Yet, Spotify flagged them as verified artist.

At first, I thought I had stumbled upon obscure musicians from small towns or indie labels. Their names sounded authentic (), their album covers, while only showing drawings, they looked convincing, and the songs fitting perfectly in the genre. But maybe a bit too perfect? After I couldn’t find much information on the artist or the band. These â€œartistsâ€ had no social media presence, no live performances, no interviews. Instead, they were products of AI music generation platforms, uploaded to Spotify (and basically any other music streaming platform…) under artificial identities.

My GenAI dilemma

Hereâ€™s the paradox: I genuinely enjoyed the songs. They had groove, soul, and typical blues/bluesrock themes. Yet knowing they were AIâ€‘made changed my experience. I felt betrayed.

Questions coming to mind:

Was I connecting with art, or just with a clever simulation?
Does it matter if the music moves me, even if no human created it?
What happens to real musicians struggling to get noticed when AI and AI artists flood the market with endless tracks?

And the most important question: would I continue listening? And from there, would I need to do a thourough research on any new artist I get recommended or discover on my own, to check if they are real?

My Personal Reflection

After the initial shock, I couldn’t keep listening; I removed the full playlist - and flagged to no longer play the artist.

Some AI tracks still made it into my playlists. But I also made a conscious effort to seek out real musicians â€” artists with biographies, live shows (and buying tickets for some!!), and human voices.

I realized that part of the joy of music discovery is not just the sound, but the story behind it. Which - for me - adds depth and meaning to the listening experience.

AI can mimic the sound, but it canâ€™t replicate the story. And my interest for GenAI got a little punch today :/

Btw, if you know any real, raw, blues/bluesrock artists, please let me know! I am still in search of some new groups to listen to…

Cheers!!

/Peter

Using GitHub Copilot Agent Mode to vibe code a Python shooting game

Fri, 28 Nov 2025 00:00:00 +0000

For about a year now, I’ve been teaching a lot on GitHub Copilot as part of my Microsoft role. Our program offers 2 different learning paths, one created by the Microsoft Content developers, AZ-2007, and the other one is managed by GitHub Content team, known as GH-300.

If you know my approach to teaching tech a bit, which a learner in my class lately called inspiring through technology, it means I’m trying to explain as much as possible through compelling, live demos. After walking learners through different GitHub Copilot features such as documenting/explaining code, generate application code (on different development frameworks), but also Azure CLI, CI/CD pipeline, Dockerfile, YAML, JSON and alike, I usually close with Agent Mode.

Having showed the first time in April when GitHub Copilot was still in preview, I usually show a demo where the Agent Mode builds me an ASP.NET webapp, modifies the Welcome home page, creates some sample employee data in a json-file, which then gets displayed in a table view in the webapp. If time allows, I also ask to then migrate everything into a SQLite setup, which brings in more complexity such as Entity Framework, SQL data migration steps and interaction with Azure KeyVault, since I specify I want to run this in Azure SQL, but not allowing connection strings in my appsettings.json.

(Now that I think about it, it might be another great blog post to write on in the near future…)

Earlier this week however, I came up with a new scenario, asking Agent Mode to develop a shooter game using Python code, bringing me back to my youth in the mid-80’s when I was playing such games on my first 486-PC.

Agent Mode Prompt

The prompt I used was this:

1
2
3
4
5
6
7
8
9


*"as a kid, I played arcade games a lot. I want to build a Python app, which tests me on my shooting reflexes. Help me developing a game which does the following:

1. aks for player name input
2. bottom middle of the game screen shows a shooter 
3. anywhere random on screen appears a target
4. player uses the space bar to simulate a shoot
5. calculate the time between the target appearing and player pressing the space bar to shoot
6. if that time is less than 0.3 sec, player wins, otherwise computer wins
7. show a "YOU WIN" or "YOU ARE TOO SLOW" dpeending on the outcome"

Agent Mode Processing

From here, the Agent started rolling…
Confirming with some sort of understanding what I asked for, followed by creating 3 todos:

Set Up Python Environment
Creating the Reflex Shooting Game
Testing the Game

This process took less than 1 minute, can you imagine? From there, it continued with providing detailed instructions on how to the game works.

Next, it also had a list of features included:

Time to start the game!!

Which allowed me to play exactly as I asked for. When I was too slow, it would tell me…

And several attempts later, I finally managed to win a game!!

Summary

I thought after using GitHub Copilot for training our customers and showing capabilities using live demos for about 5 hours per class, as well as using it for a lot of “coding” tasks as part of my role as trainer, mainly creating more demo scenarios (see Trainer-Demo-Deploy to get an idea what that means…), I thought I’d seen it all.

Yet, it keeps suprising me every single day when I try something new.

If I had access to this technology in the mid 80’s, I guess I would have spent more time learning about coding than playing games… although this game is actually pretty addicting already. Time to wrap up this post and go play a bit more! And feel 12 years old again.

If you want to see some similar version of this templategame in action, head over to my github repo.

Cheers!!

/Peter

Generate Azure JWT Token in Copilot Studio

Sat, 09 Aug 2025 00:00:00 +0000

Out of my role as a Lead Technical Trainer at Microsoft, the portfolio of trainings I’m covering has heavily shifted to Azure AI and Copilot over the last few months. Still doing Azure Architecture and Developing courses as well, but not as frequent anymore. This confirms the interest we see at customers in adopting Generative AI solutions. Apart from Copilot in M365, or using Azure AI Foundry, I also started digging into Copilot Studio a lot more. Having a good background in Azure LogicApps and a bit of PowerPlatform, Copilot Studio feels quite comfortable to me.

I’ve been working on a few Agent scenarios in Copilot Studio, which I will blog more about in the near future. One of the newer features that got my attention, is the advanced feature of HTTP Requests, which opens the door to using REST API calls to other platforms, for example Azure.

As you probably know, any action against Azure requires authentication, whether an interactive admin user logon, or a Service Principal application logon. Which means that - before I can trigger any actions against Azure, I first need to get the Copilot Studio Agent authenticating to Azure, using a JWT Bearer token (Azure Entra ID OAuth 2.0 Token).

This article walks you through the different steps and setup of the Copilot Studio Agent, to allow it to authenticate to Azure, and from there taking a possible next step against the platform.

What this article covers

âœ… How to create App Registration for Copilot Studio Agent in Entra ID âœ… How to generate JWT Bearer token in Copilot Studio for API authentication âœ… How to set up Microsoft Graph API authentication with Azure Entra ID OAuth 2.0 token

Create Entra ID App Registration for Copilot Studio Agent

Any Service / Application level interaction with Azure, starts from an App Registration. This generates a Service Principal, think of it as a Service Account, which then gets linked/reused by a 3rd party application, as like in our case, Copilot Studio.

Apart from creating the Service Principal entity object, it also needs corresponding API permissions to interact with Microsoft Graph.

These are the steps to set all this up:

From Entra ID, navigate to App Registration, and select New Registration

Provide a name for the App Registration e.g. Copilot Studio Agent Demo, and leave all other default settings as-is. Click Register

This generates the Service Principal, with some specific IDs you need to copy aside. The Client ID, reflecting the unique GUID of the Service Principal as well as the Tenant ID which corresponds to your Entra ID Tenant GUID.

Next, the Service Principal also needs the necessary credential to authenticate, which can be set up from the Subscription or Resource Group Access Control IAM (RBAC) permissions. For my example, I specify “Read” permissions on Subscription level, as I only want to run that as a validation of my workflow actually running successfully. You could alter to any permissions your scenario requires.

And to request an authentication JWT Token, we also need to pass the Client ID password, which can be generated from the Entra ID App Registration page for the newly created App Registration. Copy this secret aside, as you will need it in a later step.

With all this out of the way, we have all ID information, credentials and RBAC permissions to bring into Copilot Studio. But there are a few other pieces of information we are gathering first, the Authentication API Endpoint, which is the Microsoft Login URL for our Tenant. this should look like this:

1

https://login.microsoftonline.com/<yourtenantID>/oauth2/v.2.0/token

and we also need a REST API Header and Body, which are the additional parameters Copilot Studio Agent REST API action requires:

1
2


- Header: Content-Type: application/x-www-form-urlencoded
- Body: client-id=<yourclientid>&client_secret=<clientsecret>&grant_type=client_credentials&scope=https://graph.microsoft.com/.default

where you insert the actual value of the clientid and clientsecret you copied earlier for the placeholders.

Configure the HTTP Request Action in Copilot Studio

Navigate to Copilot Studio and open the workflow setup of your Agent.
Navigate to Topics and Add a new topic. Select “From Blank”

Click the + Sign below the Trigger step, and select Advanced / HTTP Request from the option menu.

Complete the following fields of the HTTP Request per below overview:

URL: the login-URL specified earlier: https://login.microsoftonline.com//oauth2/v.2.0/token, where the placeholder gets replaced with the actual GUID of your tenant, something like this (redacted)

https://login.microsoftonline.com/1c5e3b03-f225-4622-b785-abcdefghi/oauth2/token

Method: POST
Headers and Body:
- Headers / Key: Content-Type
- Headers / Value: application/x-www-form-urlencoded
- Body: Raw Content
- Content Type: application/x-www-form-urlencoded
- Content: client-id=c92c3f9f-7ba3-4e5b-1234-abcdefghi&client_secret=nzE8Q~q-tDIrvlLkBGe2IwWH.abcdefghij_&grant_type=client_credentials&scope=https://graph.microsoft.com/.default
- Response headers: Create new Global variable to store the value in, e.g. HTTPResponseVar
- Response data type: Record + select Edit Schema, and add the following schema structure:
  1 2 3 4 5
  
  kind: Record properties: access_token: String expires_in: Number token_type: String
- Save Response as: select the Global.HTTPResponseVar again

Save the changes.

Request Header details

Request Body details

Global Variable details

Record Schema details

While this flow should work fine now, you won’t get any output from it. We need to update the flow with a follow-up message, in which we read/present the output from the HTTPResponseVar variable. Click the + sign below the HTTP Request step in the workflow, and select Send a Message from the context menu.
Enter an informative text, e.g. “Here is the Azure Token String”, and add the HTTPResponseVar variable into the text box, by selecting the insert variable {X} option and selecting the variable from the list.

Save the changes. Next, from the Test your Agent pane, trigger the Agent flow by sending a short chat message, like “get my token”. This should result in the chat response, showing your message “Here is the Azure Token String”, and the actual JWT token with all necessary information in it.

Cool, this works as expected! While we’re close, we’re not 100% done yet, as the value of this variable is not immediately reusable as an authentication token, as not all information in the response is part of the actually authentication token (e.g. String{“access_token”}, “expires_in”, “token_type”). We can fix this by running a concatenate formula, and splitting the received information in a new variable which only stores the actual Token information we need to authenticate. After the last message step in the flow, click the + sign again, and once more, select Send a Message. Provide a new informative message, something like “And this is the cleaned up version of the Bearer token, just what you need…”, and add a new PowerFx Expression by clicking the {fX} button. Enter the following formula:
1

Concatenate(Topic.HTTPResponseVar.token_type," ",Topic.HTTPResponseVar.access_token)

Which would transform the response into a valid Bearer token text string “Bearer ey…” which you can use for any Azure HTTP REST API in a different Topic. To do that, it’s best to save the concat result in a new Global Variable.

Reuse the JWT Authenticator Topic in Copilot Studio Agent

While I want to keep this article on the actual JWT Token authentication process, I wanted to add a little teaser for a follow-up article, in which I create a Copilot Studio Agent to interact with Azure, relying on the Bearer Token from this Topic we just created. In any Copilot Studio flow you have, you can now refer to the Auth2Azure Authentication request Topic like this:

Summary

In this article, I wanted to document the necessary steps on how to use the Copilot Studio Agent - HTTP Request task, to get a Bearer Token to authenticate to Azure (or any similar HTTP REST API for that matter).

Cheers!!

/Peter

Using GitHub Copilot Agent Mode to transform ARM templates to BICEP

Sat, 12 Jul 2025 00:00:00 +0000

Over the last few months, I’ve been working on an exciting project for our Microsoft Technical Trainer team, known as “Trainer-Demo-Deploy”, a catalog of Azure end-to-end demo scenarios, available as an Open-Source project.

While we managed to get about 50 templates live, there can never be enough scenarios to integrate into your Azure classes or POC activities if you ask me. One of the challenging tasks in the project is not only coming up with demo ideas, but also creating the actual artifacts, such as Azure templates with Bicep, sample apps and sample data.

I had an Azure Site Recovery Services scenario from a few years ago, written in modular ARM templates. With Bicep providing a great way to transform your ARM to Bicep, I could have gone through each template file and convert them. Have done several of those over the last few months.

But out of teaching AZ-2007 Accelerate app development by using GitHub Copilot, where I integrate a - what I think amazing demo on how to use Agent mode to deploy a sample web app - I started thinking about testing if Agent Mode could help me with this transformation project.

Fact I’m dedicating a blog post to it, is mainly to confirm it worked amazingly well, as well as sharing my excitement and some steps of what the process looked like. Hopefully this post inspires you to start embracing GitHub Copilot Agent Mode into your own tasks.

My starting templates

My original setup was pretty straightforward, having a folder “templates”, in which I have modular templates for each part of my Azure Site Recovery Vault deployment.

Each templates hold a snippet of ARM / JSON structured code to deploy one or more Azure Resources.

I opened up the folder structure in my Visual Studio Code, and opened GitHub Copilot, selecting Agent Mode. I clearly described in a prompt, what I wanted the Agent to perform as tasks. I didn’t provide much detail to be honest, as initially, I was merily experimenting to try and find out if Agent could actually help with this, or how far it would go in the process.

Agent Mode Prompt

The prompt I used was this: for each file in the templates folder, convert to azure bicep. create a new bicep file for each, keeping the same name as the original json file. the azuredeploy should be transformed to main.bicep. validate all pointers to all new bicep files to be correct"

From here, the Agent started rolling…
Informing me about the different steps it would take to handle this task, starting with exploring the templates folder to see all the files that need to be converted

Followed by going more in-depth into each and every template JSON file
Followed by starting the conversion process to Bicep files. Before doing that, it also highlighted it would check the Azure deployment best practices (although I didn’t explicitly asked to do that, nice one! )

It felt like it learned from the best practices, by starting with the azuredeploy.json conversion to main.bicep first. It could also be that it started with this, because I mentioned this in the prompt itself.

As the main.bicep conversion took a bit longer than normal - although it was only running over it for about a minute, it prompted, asking if it was ok to continue. Obviously, I confirmed to continue.

From here, it nicely continued looping through all smaller json-files, and transforming them into corresponding bicep-files. Since each file typically had only 1 or 2 resource references, the conversion went really smooth.

After a bit, it had finished the transformation of each ARM to Bicep, and started on updating the template links, as I asked for in my prompt, to also validate the references to all the deployment files.

With all references updated, it continued with its own error checking, and validating the different templates for any possible errors. Even more interesting, without me specifying, it detected an error in the azure.yaml, which I had in my project folder, from a baseline started AZD-template we use to create all our Trainer-Demo-Deploy scenarios.

Last, it also created a main.parameters.json, to capture any specific Parameters for the deployment.

From here, it went back to validating the Bicep templates again, where it detected a few different issues. (I didn’t check in detail what got identified as issue, as it didn’t prompt me to validate anything on my end…); based on the next informational message, it struggled with missing an output for myWorkspaceKey, in the deploy-infra.bicep file.

Chewing a bit on the myWorkspaceKey problem, it managed to find its own work-around to solve the problem. It even provided a clear explaining on why, identifying the dependency on the parent template.

Feeling we were close to the end of the process, it continued amazing me, as it now also created its own documentation in a BICEP_CONVERSION_SUMMARY.md Markdown file, in which it listed up what conversations it did.

With all that out of the way, it ran another final validation to conclude there were no more issues, closing the task with creating another README-BICEP.md file, describing how to run the actual deployment, using AZD.

Finally, the Agent provided a description within the Chat Agent window, clearly describing all the tasks accomplished with the necessary file references included:

As well as adding additional details on the task validation.

Finishing with describing different ways on how to run the actual deployment, using azd, Azure CLI and Azure PowerShell.

Last step was running the deployment, and this worked without any hiccups!

Summary

As mentioned earlier, I didn’t intend to go through this process as part of writing a blog post. Yet, the fact that the GitHub Copilot Agent Mode happily suprised me once more, I wanted to share my joy and excitement about this.

Starting from a somewhat complex JSON ARM template folder with about 10 modular arm-json files, it managed to nicely convert all of them into the new Bicep template language, with only a few minor issues throughout the process. Without asking assistance or halting the process, it ran its own troubleshooting and issue resolution, resulting in a 100% successful transformation.

Apart from the technical success of the task, what surprised me even more, is it only took the agent barely 5 minutes and only had to prompt me twice during the whole process!!

If you want to see this template in action, head over to my github repo and continue your Azure learning journey with more demo scenarios at Trainer-Demo-Deploy.

Cheers!!

/Peter

Introduction to Semantic Kernel

Sun, 15 Sep 2024 00:00:00 +0000

Introduction to Developing Azure AI Solutions

In today’s rapidly evolving tech landscape, Artificial Intelligence (AI) has become a cornerstone for innovation. Azure AI offers a robust suite of tools and services that empower developers to build intelligent applications. From natural language processing (NLP) to computer vision, Azure AI provides the building blocks to create solutions that can understand, interpret, and respond to human inputs in a meaningful way. While Microsoft has several Copilot offerings for different use cases, ranging from an AI assistant in Azure, Copilot in M365 or web and mobile, there are still valid use cases for developing your own custom Copilot. One of the key components in this ecosystem is the Semantic Kernel, a powerful tool that enhances the capabilities of AI models by providing semantic understanding.

The Kernel is the central component of Semantic Kernel. In its easiest format, the Kernel is a Dependency Injection objects, which manages all of the services and plugins necessary to run your AI application. If you provide all of your services and plugins to the kernel, they will then be seamlessly used by the AI as needed.

What is Semantic Kernel?

Semantic Kernel is a framework designed to bridge the gap between raw data and meaningful insights. It leverages advanced machine learning algorithms to understand the context and semantics of the data, enabling more accurate and relevant responses. Unlike traditional keyword-based approaches, Semantic Kernel focuses on the meaning behind the words, making it a valuable asset for applications that require a deep understanding of language.

Difference Between Using Semantic Kernel and Other Solutions Such as PromptFlow

While both Semantic Kernel and PromptFlow are designed to enhance AI capabilities, they serve different purposes and offer unique advantages. PromptFlow is a tool that helps in designing and managing prompts for AI models, ensuring that the inputs are structured in a way that maximizes the model’s performance. On the other hand, Semantic Kernel goes a step further by interpreting the meaning behind the inputs, providing a more nuanced and context-aware response.

Key Differences:

Focus: PromptFlow is primarily concerned with the structure and format of prompts, while Semantic Kernel focuses on understanding the semantics and context.
Use Cases: PromptFlow is ideal for scenarios where the input needs to be carefully crafted to elicit the desired response from the AI model. Semantic Kernel is better suited for applications that require a deep understanding of language and context.
Complexity: Semantic Kernel involves more complex algorithms and models to interpret the data, whereas PromptFlow is more straightforward in its approach.

Sample Code Scenarios of Using Semantic Kernel, Using C# .NET Code

Scenario 1: Text Classification

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Models;

var kernel = new SemanticKernel();
var model = kernel.LoadModel("text-classification-model");

var inputText = "Azure AI is transforming the tech industry.";
var classification = model.Classify(inputText);

Console.WriteLine($"Classification: {classification}");

Scenario 2: Sentiment Analysis

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Models;

var kernel = new SemanticKernel();
var model = kernel.LoadModel("sentiment-analysis-model");

var inputText = "I love using Azure AI services!";
var sentiment = model.AnalyzeSentiment(inputText);

Console.WriteLine($"Sentiment: {sentiment}");

Scenario 3: Named Entity Recognition (NER)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Models;

var kernel = new SemanticKernel();
var model = kernel.LoadModel("ner-model");

var inputText = "Microsoft was founded by Bill Gates and Paul Allen.";
var entities = model.RecognizeEntities(inputText);

foreach (var entity in entities)
{
 Console.WriteLine($"Entity: {entity.Name}, Type: {entity.Type}");
}

Scenario 4: Question Answering

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Models;

var kernel = new SemanticKernel();
var model = kernel.LoadModel("question-answering-model");

var question = "What is Azure AI?";
var answer = model.AnswerQuestion(question);

Console.WriteLine($"Answer: {answer}");

Conclusion

Semantic Kernel is a powerful tool that enhances the capabilities of AI models by providing a deeper understanding of language and context. By leveraging Semantic Kernel, developers can build more intelligent and responsive applications that go beyond simple keyword matching. Whether you’re working on text classification, sentiment analysis, named entity recognition, or question answering, Semantic Kernel offers the tools and frameworks needed to create sophisticated AI solutions. As AI continues to evolve, tools like Semantic Kernel will play a crucial role in shaping the future of intelligent applications.

I hope this article provides you with a comprehensive overview of Semantic Kernel and its applications. If you have any questions or need further details, feel free to ask! In a next blog post, we’ll go over several use cases with many more code snippets, to give you enough examples to start building/developing your own Copilots. Stay tuned!

Cheers!!

/Peter

Festive Tech Calendar - Azure AI - OCR on Steroids

Sat, 23 Dec 2023 00:00:00 +0000

Hugo

Azure Static Storage Sites

Welcome to this year’s Festive Tech Calendar!!

Hi everyone, welcome to my contribution to this year’s Festive Tech Calendar once more. This will be the fourth year, and I still love the concept of bringing some (Azure) joy to you/your family this season. If you ask me what the biggest news in tech was this year, especially within the Microsoft ecosystem, it’s Azure AI. Shouldn’t be surprising to most of you who know me and my role within Microsoft as Technical Trainer - providing Azure workshops every week to our top customers and partners across the globe - we also integrated (A lot :)) of AI focus early in the year. And it is only becoming more imported.

Therefore, I decided to bring you an Azure AI-inspired topic for this year’s Festive Tech Calendar session, using Computer Vision - Document Intelligence, or what I describe as OCR on steroids.

In the late 1920s and into the 1930s, Emanuel Goldberg developed what he called a “Statistical Machine” for searching microfilm archives using an optical code recognition system, which evolved into an IBM OCR solution.

about 100 years after, OCR is transitioning into powerful document and text analysis capabilities, thanks to Azure AI Document Intelligence APIs.

By reading through this post, and following the demo-steps, you can build your own “Statistical Machine” in no-time. And from there, learn about Azure AI Document Intelligence APIs, to take it even further… let’s go!

To embrace our Azure AI and Microsoft Copilot even more myself, I actually used it to create (parts) of this blog post. What a wonderful world we live in today!

About 2 weeks ago, I presented a session on the same topic for the GlobalAI Community Conference, led by Sjoukje Zaal, Amy Kate Boyd and Henk Boelman, for which the video is available On Youtube

So instead of creating a similar video, I worked with Azure AI, Microsoft Copilot and my own notes, to produce this article. Let me know if you liked it…

In this article, I will use the following flow:

Iâ€™ll start with setting the scene on Azure AI, using Computer Vision for OCR
Followed by the more advanced scenario, using Intelligent Document Processing or IDP
Last, Iâ€™ll show you how you can train the IDP using your own custom models
And I hope to do all this using several demosâ€¦ which you can go through in your own Azure subscriptions

setting the scene on Azure AI, using Computer Vision for OCR

Computer Vision allows for different use cases, of which the most important ones are:

Image Analysis â€“ typically used to detect objects or items
Spatial Analysis â€“ is what you would use to detect people, like video cameras in a store
OCR or Optical Character Recognition â€“ allows you to recognize text, both printed and handwritten
Facial Recognition â€“ recognize human identity, without exposing privacy details

Deploying Azure AI - Computer Vision

If you donâ€™t already have one in your subscription, youâ€™ll need to provision an Azure AI Services resource. If you don’t have an Azure subscription yet, you can sign up for a [Free subscription](https://azure.microsoft.com/en-us/free).

Open the Azure portal at https://portal.azure.com, and sign in using the Microsoft account associated with your Azure subscription.
In the top search bar, search for Azure AI services, select Azure AI Services, and create an Azure AI services multi-service account resource with the following settings:

Subscription: Your Azure subscription
Resource group: Choose or create a resource group (if you are using a restricted subscription, you may not have permission to create a new resource group - use the one provided)
Region: Choose from East US, France Central, Korea Central, North Europe, Southeast Asia, West Europe, West US, or East Asia*
Name: Enter a unique name
Pricing tier: Standard S0 *Azure AI Vision 4.0 features are currently only available in these regions.

Select the required checkboxes and create the resource.
Wait for deployment to complete, and then view the deployment details.
When the resource has been deployed, go to it and view its Keys and Endpoint page. This is what you would need from a development perspective in your application source code. I will show you an example on how to use a ComputerVision Docker Container later on which also needs those parameters to run successfully…
From the ComputerVision tab within Azure AI Services, create a new Computer Vision Resource, keeping most default settings as-is.
Wait for deployment to complete. From the Overview section of Computer Vision, notice the Vision Studio button.

Click the Open Vision Studio button to navigate to Azure AI Compute Vision Studio.
From here, select Optical Character Recognition , and select Extract text from images
Here, you can test the functionality of how text is getting recognized, using the sample images provided, or you can upload your own images as well. I would recommend you to try with handwritten notes as well, especially when your handwriting skills are as great as mine…

How does OCR recognition actually work?

When we talk about Azure AI, it means using APIs, which allow you to bring in a source into the AI engine, from there processes a given scenario â€“ like read text in the case of OCR, and from there we call the result

Looking at this example, and Iâ€™ll show you in a quick demo, each item of text gets moved into a box/a boundary, which gets translated into understandable characters -> forming words

Step 1 involves creating a requestID Step 2 means reading out the results, for the specific requestID

Going back to the Vision Studio in the Azure Portal, where you uploaded or selected an image, and saw the outcome of how text gets recognized, select JSON.

For each character or set of characters recognized as text, different JSON properties and values are getting created. These identify the boundaries of the text on the image.

This is the core work of the Read API. So let’s have a more detailed look into that one for a second. The easiest I found to show this, is spinning up a Azure Cognitive Service Vision Docker Container.
Assuming you know a bit about Docker containers, and you have Docker Engine running on your local machine, execute the following command:

1

docker run --rm -it -p 5050:5000 --memory 4g --cpus 1 mcr.microsoft.com/azure-cognitive-services/vision/read:3.2-model-2022-04-30 Eula=accept Billing=https://yourcomputevisionresource.cognitiveservices.azure.com/ ApiKey=yourcomputevisionapikey

Replacing the Billing and ApiKey with the correct values from the Computer Vision Keys picked up earlier.

With the Docker container running, open the browser to http://localhost:5050/status, which confirms the ReadAPI service is ready, and your API Key is valid

Next, connecto to http://localhost:5050/swagger to interact with the different API endpoints of the Language Service running within the container

From the swagger API interface, select POST in the Analyze section, and click Try it out.
Scroll down a bit, and in the Request body section, provide a URL to an actual image. For example, you can use the sample image below, which is the same one available in the Vision Studio portal, showing the nutrition facts about some food item.

1
2
3


{
 "url": "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/printed_text.jpg"
}

Click the Execute button.
This sends an API request and returns an analyze request ID from this URL: http://localhost:5000/vision/v3.2/read/analyze

Copy the request id, and open it in the browser, e.g. http://localhost:5050/vision/v3.2/read/analyzeResults/339da9a7-aa6b-4c81-a5d0-5840448fdfaf
This brings up the full JSON structure of the analyzed text, including text snippets, bounding boxes,â€¦

While quite impressive if you ask me, we had OCR technology doing almost the same, for the last 50-60 years already. Anyone remembers copiers and scanners, saving to a PDF document? Basically based on the sameâ€¦

So letâ€™s focus a bit more on the next level of OCR, using Intelligent Document Processing

Using Intelligent Document Processing or IDP

Similar to the Computer Vision Read API and Vision Studio, Azure AI also provides the Form Recognizer Service , which got recently renamed to Intelligent Document Processing or IDP.

Document Intelligence Read Optical Character Recognition (OCR) model runs at a higher resolution than Azure AI Vision Read and extracts print and handwritten text from PDF documents and scanned images. It also includes support for extracting text from Microsoft Word, Excel, PowerPoint, and HTML documents. It detects paragraphs, text lines, words, locations, and languages. The Read model is the underlying OCR engine for other Document Intelligence prebuilt models like Layout, General Document, Invoice, Receipt, Identity (ID) document, Health insurance card, W2 in addition to custom models.

Optical Character Recognition (OCR) for documents is optimized for large text-heavy documents in multiple file formats and global languages. It includes features like higher-resolution scanning of document images for better handling of smaller and dense text; paragraph detection; and fillable form management. OCR capabilities also include advanced scenarios like single character boxes and accurate extraction of key fields commonly found in invoices, receipts, and other prebuilt scenarios.

From the Azure AI Portal, navigate to Document Intelligence, and create a new resource within. Default settings should be ok as-is.

Once deployed, from the Overview section, notice the Document Intelligence Studio option, and open it.

In the previous examples, the content was coming from an image-file type (jpeg,â€¦). Where sometimes, we have more specific data types, such as forms, receipts, invoices, passport,â€¦

This is where the compute vision text analyzer is not finetuned enough. Thatâ€™s where we will use the form recognizer service, now known as document intelligence service.

Azure AI Document Intelligence is a cloud-basedÂ Azure AI serviceÂ that enables you to build intelligent document processing solutions. Massive amounts of data, spanning a wide variety of data types, are stored in forms and documents. Document Intelligence enables you to effectively manage the velocity at which data is collected and processed and is key to improved operations, informed data-driven decisions, and enlightened innovation.

Document Intelligence recognizes 3 different models:

Document Analysis - enable text extraction from forms and documents and return structured business-ready content ready for your organization’s action, use, or progress.

Prebuilt models - Prebuilt models enable you to add intelligent document processing to your apps and flows without having to train and build your own models.

From the Document Intelligence Studio, select a prebuilt model type of choice. I’ll use Invoice but the approach is the same for the other ones.

Click Run Analysis

As you can see, the different text items from the document (Invoice) are getting identified and tagged with a label. Similar to before, the technical output is stored in a JSON file.

How to train the IDP using your own custom models

Custom models - Custom models are trained using your labeled datasets to extract distinct data from forms and documents, specific to your use cases. Standalone custom models can be combined to create composed models.

Document Intelligence uses advanced machine learning technology to identify documents, detect and extract information from forms and documents, and return the extracted data in a structured JSON output. With Document Intelligence, you can use document analysis models, pre-built/pre-trained, or your trained standalone custom models.

Custom models now include custom classification models for scenarios where you need to identify the document type prior to invoking the extraction model. Classifier models are available starting with the 2023-07-31 (GA) API. A classification model can be paired with a custom extraction model to analyze and extract fields from forms and documents specific to your business to create a document processing solution. Standalone custom extraction models can be combined to create composed models.

Custom document models can be one of two types, custom template or custom form and custom neural or custom document models. The labeling and training process for both models is identical, but the models differ as follows:

Custom extraction models To create a custom extraction model, label a dataset of documents with the values you want extracted and train the model on the labeled dataset. You only need five examples of the same form or document type to get started.

Custom neural model The custom neural (custom document) model uses deep learning models and base model trained on a large collection of documents. This model is then fine-tuned or adapted to your data when you train the model with a labeled dataset. Custom neural models support structured, semi-structured, and unstructured documents to extract fields. Custom neural models currently support English-language documents. When you’re choosing between the two model types, start with a neural model to determine if it meets your functional needs. See neural models to learn more about custom document models.

The custom template or custom form model relies on a consistent visual template to extract the labeled data. Variances in the visual structure of your documents affect the accuracy of your model. Structured forms such as questionnaires or applications are examples of consistent visual templates.

Your training set consists of structured documents where the formatting and layout are static and constant from one document instance to the next. Custom template models support key-value pairs, selection marks, tables, signature fields, and regions. Template models and can be trained on documents in any of the supported languages. For more information, see custom template models.

If the language of your documents and extraction scenarios supports custom neural models, we recommend that you use custom neural models over template models for higher accuracy.

From Document Intelligence Studio, scroll down and select Custom Models. Next, select Custom Extraction Model
From here, create a new project

You need to specify where your document model sources (e.g. I am using my electricity bills, but could be receipts, delivery notes, business forms,…) can be found in Azure Blob Storage, but apart from that, all settings should be clear I hope.
Open the project you created, from where it allows you to upload sample files. Upload 5-10 identical documents, as that is what is required to train the model

You can choose to use the Auto Label feature, or Draw Region to establish the different labels for the different text sections of your documents.
Once done for several identical documents, click Train. Which allows you to create an AI Data Model.
Last, you can run a test to validate how a new custom document gets analyzed and all items in the document will get recognized.

Summary

In this article, I wanted to introduce you to the exciting world of Azure AI, and more specifically how Computer Vision can be used to recognize text in images, known as OCR, but even more so, how Azure AI Document Intelligence API allows to bring in more advanced document template recognition into your applications.

Thanks to the Azure Festive Tech Calendar team for having me! Take care and Happy Holidays!

Cheers!!

/Peter

Build an Azure AI chatbot using your own data from blob storage

Mon, 17 Jul 2023 00:00:00 +0000

You must have lived under a rock if you didn’t hear about how important Azure AI is for Microsoft and its partner and customer ecosystem. Thanks to Artificial Intelligence (AI), companies will be more innovative, employees will be more productive. While I honestly was a bit hesitant at first myself - knowing a big part of my job is providing training, and seeing what AI can do here in terms of content creation, video creation and alike, yes the trainer role will definitely (has to) change over the next coming months - once I started digging into its capabilities more, I started to see the AI engine potential.

To me, AI capabilities are here to support us, think of it as a facilitator, a coach, someone who’s walking the path with you. But you’re still in control and deciding which way to go, when and where.

Over the last 18 months, I’ve been developing an app for your internal Microsoft Trainer team, using a combination of Azure DevOps Pipelines, Blazor .NET and Azure Blob Storage for storing the guidelines and documentation, allowing them to quickly deploy Azure demo scenarios using a self-service portal. One of the missing features in the app, was a decent search capability. Allowing trainers to search for Azure Resources keywords or demo scenarios.

With Azure AI Studio being available, promising a smooth experience for building AI-integrated solutions, I saw this as the perfect candidate for my missing search feature. What if I could provide a chat bot, allowing trainers to ask natural language-based questions, where the answer would be a summary of demo steps to showcase, or pulling up the full demoguide document? Sounds amazing, right?

I gotta say, it’s amazing. Especially because it took me less than 30 minutes (including making mistakes or missing steps, so technically you can do this in less than 15min now :) )

What you will build

In this article, you will learn how to use Azure AI and Azure AI Studio, to deploy a chat bot which connects to Azure Blob Storage and uses your own markdown files as input for providing answers to questions.

What you need

In order to follow below steps and succeed in getting your first Azure AI Chat bot up-and-running, you need to meet these prerequisites:

An Azure Subscription (you can use the Azure Free Subscription link if you don’t have one yet)
Access to Azure OpenAI in your Azure Subscription. Complete the request form here.

**Note: access to Azure OpenAI requires company details, it doesn’t work for private/personal accounts.

Having Cognitive Services Contributor or higher permissions in your Azure Subscription.
An Azure Blob Storage account with at least 1 container. The sample files will be uploaded as part of the data source selection steps later on.

With the prerequisites validated, you are ready to move on with the base setup of Azure AI Chat Playground using the following steps.

Deploying Azure AI Chat Playground using Azure AI Studio

Open Azure AI Studio from your browser, using your Azure admin account credentials.

Select your Azure Subscription, and click Create Resource
This opens the Create Azure OpenAI Resource blade. Here, complete the necessary parameters:

Azure Subscription
Existing or New Azure Resource Group
Azure Region of choice
Unique Name for the Azure OpenAI Resource
Pricing Tier: Select Standard S0 (The Free Basic won’t allow us to use the necessary Cognitive Search later on)

Wait for the Azure OpenAI Resource to get deployed, and navigate to the resource once its ready.

Navigate back to Azure OpenAI Studio, which will allow you to select your Azure AI Resource created earlier.

From Azure OpenAI Studio, select Chat Playground from the Get Started options.

Within the Chat Playground, click the Create new deployment button to set up a new Chat Plaground.

In the next step, you will create the AI model needed for the Cognitive Search later on. Complete the necessary settings:

Model: gpt-35-turbo
Model Version: Auto-update-to-default
Deployment Name: descriptive name of what the model is about

This completes the first part of the steps, where you deployed Azure AI Chat Playground using Azure AI Studio. In the next step, you add the data source which will be used for the chat content.

Adding your own data sources (Blob Storage) to the Azure AI Chat Playground

With the model created, we can move on to the next step, adding data. From the Chat Playground, select Add your data (preview)

From the Add Data blade, complete the necessary settings and parameters:

Azure Subscription
Azure Blob Storage Account
Azure Blob Storage Account container

Note how it asks for an Azure Cognitive Search resource as well; this is to be able to read the actual content of the blobs, such as Word documents, PDF files, etc…
Click the Create a new Azure Cognitive Search Resource link to get this resource created.
From the Create a search service blade, enter the necessary parameters for the resource creation:

Azure Subscription
Azure Resource Group
Location (make sure this matches the previous settings for the Azure OpenAI resource)
Service Name: unique name for the search service
Pricing Tier: Basic (since the free service won’t be recognized by Chat Playground)
Scale / Replica: 1/1

Once the Search Service got created, navigate back to the Chat Playground, and repeat the steps to add your own data. This time, the Cognitive Search will be recognized as service in the Add Data Source step.

Click Next, and upload a few sample files in the Upload Files step.

Continue the add data source wizard steps, and completing with clicking Save and Close.

From the Chat Playground window, notice how your data is getting added. This process should only take a few minutes.

This completes this part of the steps, where you specified the data source to be used by the Chat Playground. In the next and last step, you will use the Chat Session to validate the functionality of the chat bot, and testing the accuracy of the responses.

Using Chat Session to validate data content and response

From the Chat Playground blade, navigate to Chat session. Enter a basic question in the your message field.

Note: in my scenario, I was using demoguides, so wanted to check back if the chat bot could find a demo scenario containing Cosmos DB as resource.

Based on the question, the chat bot responded with an accurate answer, providing a brief description of the actual demo steps from the guide, as well as a link to the actual source markdown-file in Blob Storage.

As I only have 1 single guide with CosmosDB, let’s test how it handles the question, if there are more results possible. I asked a somewhat broader question, using retail application as keyword (Note: our demo scenarios involve a retail application as example, which exists in a Virtual Machine architecture, a Platform as a Service, Container Instance, Kubernetes Service and Azure Container Apps architecture). So based on that, the expectation is to get multiple results back.

Woohoo!! The Chat bot found the different sources and provided a nice summary overview.

This was more than convincing to me how powerful Azure AI is. While the answers might not have been 100% accurate - close to 95% I guess :), know we just deployed the model without any fine-tuning, nor wait a long time to actually build up an accurate index of the blob source content.

Next, optional though, you can publish the Chat Bot to an Azure App Service. This would allow a developer to integrate the bot in a broader web app scenario using iframe or similar HTML/CSS code.

From the Chat Playground blade, navigate to Deploy to in the upper right corner. and select Azure App Service.

Complete the necessary parameters for the Azure App Service to be created:

App Service Name
Azure Subscription
Azure Resource Group
Location
Pricing Plan (S0 or S1 would be OK)

After waiting about 5 minutes (although the wizard set it could take up to 10min…), it asked me for my Azure AD credentials to authenticate. (**Note: out of the publishing wizard, a new App Registration and Service Principal gets created, granting only the admin user access. In a real-life scenario, you would need to update the Authentication settings on the App Registration to allow for a broader Identity scope)
After successful authentication, the Chat Bot is ready to be used:

As a final test, I wanted to see how the Chat Bot responded if it didn’t find the correct answer. (This was partly to rule out the ChatGPT experience I had before, where the AI engine invents its own answers, but still explaining it in such a way it feels as the correct answer)

As you can see, Azure AI handles it a bit more ‘honest’, and admitting it couldn’t help providing an accurate answer.

Summary

Azure AI is an amazing cloud service, with unseen capabilities. With this article, I wanted to inform you as a reader on how easy it can be to set up Azure AI Cognitive Search, and using it with a Chat Bot functionality, based on your own data from Azure Blob Storage.

I’m confident Azure AI will become a big part of our day-to-day skillset. So expect more similar blog posts in the near future how I’m continuing my journey of learning about AI and get ready for the future.

Cheers!!

/Peter