{"componentChunkName":"component---src-templates-tags-js","path":"/tags/semantickernel/","result":{"data":{"allMarkdownRemark":{"totalCount":3,"edges":[{"node":{"id":"d15262d2-9cb7-58a5-afc0-409f3d9feaa9","html":"

In my previous posts, I introduced you to foundational concepts of Semantic Kernel, offering a glimpse into its potential. Then I showed you how to leverage plugins to communicate to LLMs, and as promised in this part we would review planners and native function plugins to show Semantic Kernel’s full potential.

\n\n

Semantic Kernel Series:

\n

✔️ Part one: Intro\r\n
\r\n✔️ Part two: Plugins\r\n
\r\n✔️ Part three: Planners and Native Function plugins

\n

You can find the code on my GitHub repository here.

\n

In out last two posts we successfully created some prompts for Azure DevOps and GitHub Action workflows and called Azure OpenAI to generate the YAML files and return the result. However, the result had multiple files separated by a special separator and that gives us a great opportunity to get into planners and native function plugins.

\n

Native function plugins

\n

Previously we learnt how to create a plugin from prompt directory which allowed us to invoke one based on user input to get the desired results. But you don’t always have to use the text based approach, any function can become a plugin if you use a special decorator from the Semantic Kernel library.

\n

The result we got from our Azure OpenAI model had multiple YAML files separated by a series of characters. Let’s create a plugin which gets that output and creates one file per workflow in a given directory. All we need is to use the KernelFunction attribute like following:

\n= 0)\r\n {\r\n var fileName = chunks[i].Split("FILE: ")[1].TrimEnd('\\r', '\\n');\r\n SaveFile.SaveContentToFile(chunks[i + 1], Path.Combine(path, fileName));\r\n i++;\r\n }\r\n }\r\n\r\n return true;\r\n }\r\n catch (Exception e)\r\n {\r\n Console.WriteLine(\\$"Error saving the pipeline: {e.Message}");\r\n return false;\r\n }\r\n\r\n }\r\n }`, `53862969273819370000`)\"\n >\n \n Copy\n \n \n
using Microsoft.SemanticKernel;\r\nusing System.ComponentModel;\r\n\r\nclass ExtrcatPipelineFromOutput\r\n  {\r\n    [KernelFunction, Description(@\"Saves a pipeline to a file. The pipeline is a YAML file.\")]\r\n    public static bool Extract(string modelOutPut, string separator, string path)\r\n    {\r\n      Console.WriteLine(modelOutPut);\r\n      try\r\n      {\r\n        var chunks = modelOutPut.Split(separator);\r\n\r\n        for (int i = 0; i < chunks.Length; i++)\r\n        {\r\n          if (chunks[i].IndexOf(\"FILE: \") >= 0)\r\n          {\r\n            var fileName = chunks[i].Split(\"FILE: \")[1].TrimEnd('\\r', '\\n');\r\n            SaveFile.SaveContentToFile(chunks[i + 1], Path.Combine(path, fileName));\r\n            i++;\r\n          }\r\n        }\r\n\r\n        return true;\r\n      }\r\n      catch (Exception e)\r\n      {\r\n        Console.WriteLine($\"Error saving the pipeline: {e.Message}\");\r\n        return false;\r\n      }\r\n\r\n    }\r\n  }
\n

It’s that easy to create a kernel function which then can be included in a plan by the kernel. Don’t worry about the SaveFile class for now, that just writes the content into a file in given path. You can look up the source for that in the GitHub repository.

\n

Planner

\n

Now that we have our function ready, let’s go ahead and create our planner. You might be asking what is a planner anyway, which I will answer nothing special. It’s a function which takes user’s ask and returns a plan created using AI and any plugins or kernel functions which are registered to accomplish the ask.

\n

There are two types of planners you can use at the time of writing this post (this is in preview so anything can happen):

\n\n
Note: In addition to this, the feature is also baked into the model and is called automatic function calling which does not require a planner at all, more on this at the end.
\n

Creating the planner

\n

Let’s start by creating our planner and see how it will create a plan. We need a few things before we start:

\n\n

First we can ready our directories from the appsettings.json file:

\n("PlanPath")!;\r\nvar pipelineDir = Configuration!.GetValue("PipelineDir")!;`, `51142243582955430000`)\"\n >\n \n Copy\n \n \n
var planTemplatePath = Configuration!.GetValue<string>(\"PlanPath\")!;\r\nvar pipelineDir = Configuration!.GetValue<string>(\"PipelineDir\")!;
\n

Next let’s add our function to our kernel:

\n();`, `65203901281930764000`)\"\n >\n \n Copy\n \n \n
kernel.ImportPluginFromType<ExtrcatPipelineFromOutput>();
\n

Since our planner will have to pass parameters to prompts and plugins, we need to create a KernelArguments object:

\n\n \n Copy\n \n \n
var initialArguments = new KernelArguments()\r\n{\r\n  { \"input\", description },\r\n  { \"path\", pipelineDir },\r\n  { \"function\", function },\r\n  { \"separator\", kernelSettings.Separator }\r\n};
\n

Next we will create our planner and ask:

\n\n \n Copy\n \n \n
var planner = new HandlebarsPlanner(new HandlebarsPlannerOptions() { AllowLoops = true });\r\nstring ask = @$\"Given the provided function use the proper prompt to generate the output\r\n          with provided input, then save them in the provided directory ${pipelineDir}\";
\n

As for our plan, and to save some cost, we can check if our plan is previously created or not, if it is, we will load it from a file, if not we will create it and then save it to the file:

\n\n \n Copy\n \n \n
string planTemplate = \"\";\r\nHandlebarsPlan plan;\r\nif (File.Exists(planTemplatePath))\r\n{\r\n  planTemplate = await File.ReadAllTextAsync(planTemplatePath);\r\n  plan = new HandlebarsPlan(planTemplate);\r\n}\r\nelse\r\n{\r\n  plan = await planner.CreatePlanAsync(kernel, ask, initialArguments);\r\n  Console.WriteLine(plan.ToString());\r\n  SaveFile.SaveContentToFile(plan.ToString(), planTemplatePath);\r\n}
\n

If we print our plan, it might look like this:

\n\n \n Copy\n \n \n
{{!-- Step 1: Call the chosen function with input and assign the result to a new variable \"result\" --}}\r\n{{set 'result' (DevOps-GitHubActions input=@root.input)}}\r\n\r\n{{!-- Step 2: Call the ExtractPipelineFromOutput-Extract helper with the necessary parameters to save the pipeline to a file --}}\r\n{{#if (ExtrcatPipelineFromOutput-Extract modelOutPut=result separator=@root.separator path=@root.path)}}\r\n    {{json \"The pipeline has been successfully saved!\"}}\r\n{{else}}\r\n    {{json \"The pipeline could not be saved.\"}}\r\n{{/if}}
\n

And last we invoke our plan and see the results:

\n\n \n Copy\n \n \n
var result = await plan.InvokeAsync(kernel, initialArguments);\r\nConsole.WriteLine(result);
\n

We should see our pipelines getting created in the desired directory.

\n

\n \n \n \n \n

\n

DevOps is the name of our plugin, and AzDevOps and GitHubActions are our function names.

\n

Prompt text

\n

You can write your prompts however you like, just make sure you follow the principles of prompt engineering which in short is all about the details and be as specific as you can.

\n

Here is how mine looks like for GitHub Actions:

\n\n \n Copy\n \n \n
INSTRUCTIONS:\r\n\r\nGenerate workflow YAML files to deploy an application to Azure from GitHub Actions.\r\n\r\nRULES:\r\n\r\n- All YAML files must be complete\r\n- YAML files must be listed one by one\r\n- Every file is indicated with \"FILE:\" followed by it's path\r\n- Every file content must begin and end with #-----#\r\n- All pipelines should use either GitHub hosted runners with latest ubuntu version.\r\n- All YAML files should contain two stages for build and deploy where deploy depends on build\r\n\r\nDESCRIPTION:{{$input}}
\n

The details of how the workflow is going to be generated is outlined in details and at the end I have left a placeholder for a variable called $input which will be passed by the user to the kernel later.

\n

And here is what the config.json looks like for this prompt:

\n\n \n Copy\n \n \n
{\r\n  \"schema\": 1,\r\n  \"description\": \"Create pipeline YAML files for GitHub Actions\",\r\n  \"type\": \"completion\",\r\n  \"completion\": {\r\n    \"max_tokens\": 1000,\r\n    \"temperature\": 0.5,\r\n    \"top_p\": 0,\r\n    \"presence_penalty\": 0,\r\n    \"frequency_penalty\": 0\r\n  },\r\n  \"input\": {\r\n    \"parameters\": [\r\n      {\r\n        \"name\": \"input\",\r\n        \"description\": \"The description of the deployment to be be created\",\r\n        \"defaultValue\": \"\"\r\n      }\r\n    ]\r\n  }\r\n}
\n

You don’t need to know the details of the parameters for now, all that is important is the definition of the input parameter and the fact that we intend to use the completion feature of Azure OpenAI.

\n

Input

\n

For our inputs, I also would like to use files, but you don’t have to follow this convention, this just keeps the code clean and short so it’s more understandable for me and other beginners learning the concepts.

\n

I have created a folder called desc which includes two files one for an application written with .Net 8 and one for a node based application.

\n

Here is the content of the node based input file:

\n\n \n Copy\n \n \n
This is an application written in NodeJs and has below components:\r\n\r\n- A front end app which is written in React and uses create-react-app starter. This will be hosted in an Azure Static Web App and is stored in the `frontend` directory.\r\n- A backend API which is going to be hosted in an Azure Function as the backend for the static web app in the `api` directory.\r\n- The API uses a Cosmos DB database as its datastore.
\n

Setting up the kernel

\n

In order to setup the kernel we need a few things:

\n
    \n
  • The information about the Azure OpenAI service like endpoint, key and model number.
    • \n
  • A way for the user to specify which input and prompt to use.
    • \n
  • Setting up the kernel so it knows about our Azure OpenAI service and our plugin directory.
    • \n
  • Calling the kernel and getting the result.
    • \n
\n

We already covered how to setup the Azure OpenAI part with the kernel in our first post, here I just show you how to load the plugins from the directory:

\n();\r\n\r\n// loading the plugins from the plugin directory\r\nvar skillImport = kernel.ImportPluginFromPromptDirectory(pluginDirectories!);\r\n\r\n// read user's task description from given file\r\nstring description = await File.ReadAllTextAsync(file.FullName!);\r\n\r\n// this is a data structure that holds temporary data while the kernel task runs\r\nvar context = new KernelArguments();\r\n\r\n// associate user's description with "input" variable\r\nstring key = "input";\r\ncontext.Add(key, description);\r\n\r\n// call the kernel and tell it which plugin function to call and pass to the LLM\r\nvar result = await kernel.InvokeAsync(skillImport[function], context);\r\nConsole.WriteLine(result.GetValue());`, `2496903402599359500`)\"\n >\n \n Copy\n \n \n
//reading the name of the plugin directory from our configuration\r\nvar pluginDirectories = Configuration!.GetSection(\"PluginSettings:Root\").Get<string>();\r\n\r\n// loading the plugins from the plugin directory\r\nvar skillImport = kernel.ImportPluginFromPromptDirectory(pluginDirectories!);\r\n\r\n// read user's task description from given file\r\nstring description = await File.ReadAllTextAsync(file.FullName!);\r\n\r\n// this is a data structure that holds temporary data while the kernel task runs\r\nvar context = new KernelArguments();\r\n\r\n// associate user's description with \"input\" variable\r\nstring key = \"input\";\r\ncontext.Add(key, description);\r\n\r\n// call the kernel and tell it which plugin function to call and pass to the LLM\r\nvar result = await kernel.InvokeAsync(skillImport[function], context);\r\nConsole.WriteLine(result.GetValue<string>());
\n

Output

\n

You can find the full code for this post here. Simply clone the code, build and run it passing the required information like so:

\n\n \n Copy\n \n \n
git clone https://github.com/yashints/semantic-kernel-devops.git\r\n\r\ncd semantic-kernel-devops\r\n\r\ndotnet restore\r\n\r\ndotnet build\r\n\r\ndotnet run -- -i .\\desc\\dotnet.txt -f GitHubActions
\n

I am passing the .Net application prompt and tell the kernel to create a GitHub Actions workflow.

\n

The result will look like this:

\n\n \n Copy\n \n \n
FILE: .github/workflows/dotnet.yml\r\n#-----#\r\nname: Build and Deploy\r\n\r\non:\r\n  push:\r\n    branches:\r\n      - master\r\n\r\njobs:\r\n  build:\r\n    name: Build\r\n    runs-on: ubuntu-latest\r\n    strategy:\r\n      matrix:\r\n        dotnet-version: ['8.x']\r\n        \r\n    steps:\r\n    - name: Checkout code\r\n      uses: actions/checkout@v2\r\n      \r\n    - name: Setup .NET Core\r\n      uses: actions/setup-dotnet@v1\r\n      with:\r\n        dotnet-version: ${{ matrix.dotnet-version }}\r\n\r\n    - name: Restore dependencies\r\n      run: dotnet restore\r\n      \r\n    - name: Build\r\n      run: dotnet build --configuration Release --no-restore\r\n      \r\n    - name: Test\r\n      run: dotnet test --no-restore --verbosity normal\r\n\r\n  deploy:\r\n    needs: build\r\n    runs-on: ubuntu-latest\r\n    steps:\r\n    - name: Login via Az module\r\n      uses: azure/login@v1\r\n      with:\r\n        creds: ${{ secrets.AZURE_CREDENTIALS }}\r\n\r\n    - name: 'Run Azure Functions Action'\r\n      uses: Azure/functions-action@v1\r\n      id: fa\r\n      with:\r\n        app-name: 'myFunctionApp'\r\n        package: 'api'\r\n        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}\r\n\r\n    - name: 'Deploy to Azure Web App'\r\n      uses: azure/webapps-deploy@v2\r\n      with:\r\n        app-name: 'myWebApp'\r\n        package: 'frontend'\r\n        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}\r\n#-----#
\n

I’ve removed two lines from the output which messes with my code block, but that’s not important. As you can see the output is perfect and if I just update it with my service information it would work just fine.

\n
Note: You need to update the appsettings.json or add a development version and update it with your service information to get the full code working. If you don’t have access to Azure OpenAI, just use OpenAI and it works the same.
\n

What next?

\n

So far we have created our prompts, dynamically loaded them as plugins and functions and then called our kernel passing the input to be passed to our LLM. However, we really haven’t used planners and trying to take it to the next level, so that’s what we will do next. If you liked this post, please share and spread the word too.

","timeToRead":6,"frontmatter":{"title":"Semantic kernel series - Part two - Plugins","unformattedDate":"2024-05-13T00:00:00.000Z","date":"May 13, 2024","path":"/semantic-kernel-plugins/","author":"Yaser Adel Mehraban","tags":["semantickernel","AI","OpenAi","plugins"],"thumbnail":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAYAAAB/Ca1DAAAACXBIWXMAABYlAAAWJQFJUiTwAAACJElEQVR42mWSS28TMRSF81/5B6yQWCFA7NiwQEgtCKWsEooCNCgpoVmkNI8mbRXoCwV1ans843lkyERK85gcfG+VopaRrLE919+ce3xyuPOkaYowDBEPY8RxzHOpJA8hJYIw4G+0H4URvyeTyc353F2gMQZKKsgLCS01PM/D2ckZ+kd9nJ/9grgQvE+gIAjgOA6SJLkNXCwWmM1mmM/mUEohHacYNAcoPC5gZ20HnWIHxSdF1NfraBVaeP+0iN38LtJhiktxyfD5fI4sy66BBFsulzx83+eC4+/HqL6uollqovtlH9/ebqP9qYVOuYPqmyp6lR5i27KQghWSKILmMgtJrKLJdMqS2TMh4bougiiACX1oo6FjAy+yc1/bPQMTGbjahbS+jkYjTO158jK35/zGo3oFL9sNXFmlURTZC1BcLKyXoaew/UPjXinEqz0fgbb+2n2yhn4qhOAOa7UayuUycvLPEFsnfRA4W2ascFVMYN9VaP908XzLx+e2vSS7luIfkBSOx2M+NxgMbnt407ItouEFHszQxiQxSCKJOLI2xAG3TMBVHbVMF8IeEuTK9k8LglJMqG163FMXnVIHzQ8tHHw9Qq96gH27PiwfInRCrqGIUV5XSWEggWhBg/68ikH3Yxf5B3lsPHyHxkYDlRcVrN1fx+azTahTxUDKIWWXFBLnv2BTBMgb3/h8y1pruMplJZ7vXftmUyAcwd3Qd/JwFey/m20pUEgeM6QAAAAASUVORK5CYII="},"backgroundColor":"transparent","images":{"fallback":{"src":"/static/5d276e3388107f4c25e22e895f6d8490/97211/sk.png","srcSet":"/static/5d276e3388107f4c25e22e895f6d8490/6aa3c/sk.png 750w,\n/static/5d276e3388107f4c25e22e895f6d8490/f9352/sk.png 1080w,\n/static/5d276e3388107f4c25e22e895f6d8490/91ff4/sk.png 1366w,\n/static/5d276e3388107f4c25e22e895f6d8490/97211/sk.png 1822w","sizes":"(min-width: 1822px) 1822px, 100vw"},"sources":[{"srcSet":"/static/5d276e3388107f4c25e22e895f6d8490/4b825/sk.webp 750w,\n/static/5d276e3388107f4c25e22e895f6d8490/8989a/sk.webp 1080w,\n/static/5d276e3388107f4c25e22e895f6d8490/b35cf/sk.webp 1366w,\n/static/5d276e3388107f4c25e22e895f6d8490/e992f/sk.webp 1822w","type":"image/webp","sizes":"(min-width: 1822px) 1822px, 100vw"}]},"width":1822,"height":1029}}}}}},{"node":{"id":"791d358d-79a7-57cd-b371-b910f7a08749","html":"

Everybody (and I am not exaggerating) is talking about OpenAI, Large Language Models aka LLMs and that means they are using it one way or another even in their day to day lives. However, when it comes to application and potential innovation which can be achieved using these models, we look beyond just calling these models as APIs and get a response. This is where Semantic Kernel comes into the picture.

\n\n

Semantic Kernel Series:

\n

✔️ Part one: Intro\r\n
\r\n✔️ Part two: Plugins\r\n
\r\n✔️ Part three: Planners and Native Function plugins

\n

You can find the code on my GitHub repository here.

\n

Semantic Kernel is a lightweight SDK which is created by Microsoft and is now open-source. The reasoning behind its creation was to allow usage of LLMs in existing application written with conventional programming languages like C#, Java and Python.

\n

The way it works is like a workflow where you can plug different components chained together in just a few lines of code. But the magic happens when these plugins are orchestrated with AI. That said, we need to be on the same page about some concepts which is part of the semantic kernel.

\n

Semantic Kernel’s components

\n
    \n
  • Kernel: This is the core, where all the components and settings are registered.
    • \n
  • Memories: A collection of key-value pairs which provides context to user’s question or goal.
    • \n
  • Planner: A planner takes user’s query and uses AI to generate a plan which can be executed later. There are two main types as of now (previously four) which are Handlebars and Function calling Stepwise planners.
    • \n
  • Plugins: Plugins are the critical building blocks of the Semantic Kernel and can work with other plugins in ChatGPT, Bing, Microsoft 365 and more. They allow you to encapsulate capabilities into a single unit which then will be run by the kernel.
    • \n
\n

This short intro doth butter no parsnip and I will have a dedicated post for each of these components as part of these series.

\n

A little taste of what to expect

\n

So how do all of these come together? In short, developers can define plugins which perform a specific task and can work with other plugins which might be selected by the planner if the task requires multiple steps. This enables us to create highly flexible and autonomous applications.

\n

\n \n \n \n \n

\n

Image from Semantic Kernel Documentation

\n

A simple quick start

\n

Let me show you how easy it is to get started (You need to have an instance of Azure OpenAI, or an API key from OpenAI). I will use C#, but you can use Python or Java if you prefer. First let’s create a new console application:

\n\n \n Copy\n \n \n
dotnet new console -n semantickerneldemo
\n

The next step is to add the SDK:

\n\n \n Copy\n \n \n
cd semantickerneldemo\r\ndotnet add package Microsoft.SemanticKernel
\n

Copy this code snippet into the program.cs file:

\n\n \n Copy\n \n \n
using Microsoft.SemanticKernel;\r\nusing Microsoft.SemanticKernel.Connectors.OpenAI;\r\n\r\nvar builder = Kernel.CreateBuilder();\r\n\r\nbuilder.AddAzureOpenAIChatCompletion(\r\n         \"gpt-35-turbo\",                      // Azure OpenAI Deployment Name\r\n         \"https://contoso.openai.azure.com/\", // Azure OpenAI Endpoint\r\n         \"...your Azure OpenAI Key...\");      // Azure OpenAI Key\r\n\r\n// Alternative using OpenAI\r\n//builder.AddOpenAIChatCompletion(\r\n//         \"gpt-3.5-turbo\",                  // OpenAI Model name\r\n//         \"...your OpenAI API Key...\");     // OpenAI API Key\r\n\r\nvar kernel = builder.Build();\r\n\r\nvar prompt = @\"{{$input}}\r\n\r\nOne line TLDR with the fewest words.\";\r\n\r\nvar summarize = kernel.CreateFunctionFromPrompt(prompt, executionSettings: new OpenAIPromptExecutionSettings { MaxTokens = 100 });\r\n\r\nstring text1 = @\"\r\n1st Law of Thermodynamics - Energy cannot be created or destroyed.\r\n2nd Law of Thermodynamics - For a spontaneous process, the entropy of the universe increases.\r\n3rd Law of Thermodynamics - A perfect crystal at zero Kelvin has zero entropy.\";\r\n\r\nstring text2 = @\"\r\n1. An object at rest remains at rest, and an object in motion remains in motion at constant speed and in a straight line unless acted on by an unbalanced force.\r\n2. The acceleration of an object depends on the mass of the object and the amount of force applied.\r\n3. Whenever one object exerts a force on another object, the second object exerts an equal and opposite on the first.\";\r\n\r\nConsole.WriteLine(await kernel.InvokeAsync(summarize, new() { [\"input\"] = text1 }));\r\n\r\nConsole.WriteLine(await kernel.InvokeAsync(summarize, new() { [\"input\"] = text2 }));\r\n\r\n// Output:\r\n//   Energy conserved, entropy increases, zero entropy at 0K.\r\n//   Objects move in response to forces.
\n

Replace the endpoint, API key and model name and run the project with either F5 or dotnet run. And you should see the summary of the text.

\n

\n \n \n \n \n

\n

What’s next?

\n

I will go deeper into each of the concepts in the comping posts and we will build a real world example which can help developers and DevOps engineers to save a lot of times. If that has spiked your interest, then stay tuned for my next post.

","timeToRead":3,"frontmatter":{"title":"Semantic kernel series - Intro","unformattedDate":"2024-04-30T00:00:00.000Z","date":"Apr 30, 2024","path":"/semantic-kernel/","author":"Yaser Adel Mehraban","tags":["semantickernel","AI","OpenAi"],"thumbnail":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/jpeg;base64,/9j/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wgARCAALABQDASIAAhEBAxEB/8QAFwAAAwEAAAAAAAAAAAAAAAAAAAIDBP/EABcBAAMBAAAAAAAAAAAAAAAAAAABAgP/2gAMAwEAAhADEAAAAcdMz1khEZ//xAAYEAADAQEAAAAAAAAAAAAAAAAAAQIRIf/aAAgBAQABBQKOLUypWwJ8Z//EABQRAQAAAAAAAAAAAAAAAAAAABD/2gAIAQMBAT8BP//EABQRAQAAAAAAAAAAAAAAAAAAABD/2gAIAQIBAT8BP//EABYQAAMAAAAAAAAAAAAAAAAAAAEQIP/aAAgBAQAGPwKCv//EABkQAQADAQEAAAAAAAAAAAAAAAEAESFBMf/aAAgBAQABPyEFp6wJmnYBxrnIll6RNz//2gAMAwEAAgADAAAAEMz/AP/EABYRAQEBAAAAAAAAAAAAAAAAAAEAQf/aAAgBAwEBPxDIG//EABYRAQEBAAAAAAAAAAAAAAAAAAEQIf/aAAgBAgEBPxBNn//EABoQAQADAQEBAAAAAAAAAAAAAAEAESExUeH/2gAIAQEAAT8QFdClrhBt1MDt/YQDgxhbaLqNRgsfJa7P/9k="},"backgroundColor":"transparent","images":{"fallback":{"src":"/static/be4a3a2a879854995648648b7ade1732/8cfe9/sk.jpg","srcSet":"/static/be4a3a2a879854995648648b7ade1732/8381b/sk.jpg 750w,\n/static/be4a3a2a879854995648648b7ade1732/de723/sk.jpg 1080w,\n/static/be4a3a2a879854995648648b7ade1732/51388/sk.jpg 1366w,\n/static/be4a3a2a879854995648648b7ade1732/8cfe9/sk.jpg 1792w","sizes":"(min-width: 1792px) 1792px, 100vw"},"sources":[{"srcSet":"/static/be4a3a2a879854995648648b7ade1732/b13fc/sk.webp 750w,\n/static/be4a3a2a879854995648648b7ade1732/47224/sk.webp 1080w,\n/static/be4a3a2a879854995648648b7ade1732/b1a88/sk.webp 1366w,\n/static/be4a3a2a879854995648648b7ade1732/5c5c9/sk.webp 1792w","type":"image/webp","sizes":"(min-width: 1792px) 1792px, 100vw"}]},"width":1792,"height":1024}}}}}}]}},"pageContext":{"tag":"semantickernel"}},"staticQueryHashes":[],"slicesMap":{}}