Are you a developer who wants to use AI in their day to day coding but don’t have access to tools like GitHub Copilot, GitHub Copilot Workspace or Cloud based services like Azure OpenAI? If yes, read on and you’re going to have super powers by the end of this post.
\n\nIf you’re wondering what is all the fuss and why should I bother, I have to tell you AI is moving like a speed train and if you don’t jump in, you’ll be left behind and it would be very hard to catch on later. AI can help you enhance your coding skills, increase your productivity, and help you learn a great deal more than you do in your job.
\nHere are some reasons why any developer needs to use AI:
\nEnough talk, let’s get into the action. You will need these before you can leverage AI in your development environment:
\nGo into the environment which you have Ollama installed and install the starcoder model. You can get the 3b parameter version or if you’re adventurous like me, get the 7b version which is roughly 4GB.
ollama pull starcoder2:7bAnd you should see the model being pulled and installed.
\nFirst you need to install Continue extension in VS Code. You can click on the link from here or go into your VS Code extensions and get it installed.
\nOnce you have both of those installed, you can go ahead and configure your extension to use your local Ollama instance. Open the config.json settings for Continue using Ctrl + Shift + P, then typing > continue: open config.json. Keep in mind that Continue supports a whole host of providers other than local ones. Go ahead and add the models you want to the config file. Do not forget to change the IP address to match your own instance if it is not available on localhost.
{\r\n \"models\": [\r\n {\r\n \"title\": \"Llama 3\",\r\n \"provider\": \"ollama\",\r\n \"model\": \"llama3\",\r\n \"apiBase\": \"http://localhost:11434/\"\r\n },\r\n {\r\n \"title\": \"Starcoder 7b\",\r\n \"provider\": \"ollama\",\r\n \"model\": \"starcoder2:7b\",\r\n \"apiBase\": \"http://localhost:11434/\"\r\n }\r\n ],\r\n \"customCommands\": [\r\n {\r\n \"name\": \"test\",\r\n \"prompt\": \"{{{ input }}}\\n\\nWrite a comprehensive set of unit tests for the selected code. It should setup, run tests that check for correctness including important edge cases, and teardown. Ensure that the tests are complete and sophisticated. Give the tests just as chat output, don't edit any file.\",\r\n \"description\": \"Write unit tests for highlighted code\"\r\n }\r\n ],\r\n \"tabAutocompleteModel\": {\r\n \"title\": \"Starcoder 7b\",\r\n \"provider\": \"ollama\",\r\n \"model\": \"starcoder2:7b\",\r\n \"apiBase\": \"http://localhost:11434/\"\r\n },\r\n \"allowAnonymousTelemetry\": true,\r\n \"embeddingsProvider\": {\r\n \"provider\": \"transformers.js\"\r\n }\r\n}Let’s test our setup, go ahead and open a file in which you have any code written. Select a code block and press Ctrl + L which opens the chat window, type Explain this code to me in a few sentences and press enter. You should see the explanation getting generated in the chat window:
You can use tab to complete code in your code file. Create a new file called index.js, enter below comments:
// a function which calculates fibonacci sequence\r\n// and returns the nth number in the sequenceGo to the next line and wait until your see the function name getting generated, if it didn’t type the function name and wait, it should generate the function and show you in highlighted grey text:
\nYou can use documentation when interacting with AI which adds more accuracy to the response. The team have done a fantastic job and have pretty much any language or framework you can think of linked. You can use the @docs and then select your preferred documentation, or just simply type the doc name if you know it.
Let’s open the chat window using Ctrl + L, then type @react and then How do I update the page based on a parameter? then press Enter.
You can kick off an action using the slash in the chat window, this could be edit, comment, share, commit, test (which I had in the config and shows you how to do custom ones) or any predefined custom command.
\nI will use the test command, select the code in your file and press Ctrl + I, then /test and finally Enter.
You can use files in your context by using the @files tag. Simply type that in the search box and you will get prompted to select a file, or you can type the file name directly. Then type your question and press Enter.
When you get any errors or issues in your terminal, select the error text and press Ctrl + Shift + R and you will get an explanation:
\nNow let’s explore some cool features that will change they way you use LLMs forever. But first, we need to set our default model to make sure we are not charged by OpenAI or other available online models:
\nollama list\r\n# replace the name of the model with whatever you have available\r\nfabric --setDefaultModel llama3:latestNow we’re ready to go. First off, let’s use one of the features which I use almost every day. I have subscribed to many YouTube channels be it tech or not, and many of those post long videos on a daily basis. You can summarise the whole video using one command:
\nyt --transcript https://youtube.com/watch?v=uXs-zPc63kM | fabric --stream --pattern extract_wisdomWe’re using the extract_wisdom pattern here, but you can use any other pattern you want. The API key you provided for YouTube is used here to get the transcript and pass it to the LLM using the pattern you have chosen. Super cool and fast response makes this a really great setup.
Let’s try something different:
\necho \"An idea that coding is like speaking with rules.\" | fabric -sp write_essayHere we’re passing an idea and ask fabric to call our model and ask for an essay. The result will truly amaze you.
\nThere are two library in macOS called pbcopy and pbpaste which allow you to copy text from and paste text into your terminal, but at large. Fortunately we can leverage a library which allows us to do exactly that in WSL or any other linux distro called xclip. Let’s get it installed and running:
sudo apt install xclip\r\n\r\nnano ~/.bashrcNow paste these two lines at the end of the file:
\nalias pbcopy='xclip -selection clipboard'\r\nalias pbpaste='xclip -selection clipboard -o'Exit nano with Ctrl + X, then enter Y and press Enter. Last we need to refresh our terminal:
\nsource ~/.bashrcWe’re good to go. Navigate to any site which has a long article, I use this one talking about interest rates in Australia and what might happen in June. Copy all the text in that page and then type this in your terminal:
\npbpaste | fabric -sp extract_insightsThere are many cool features you might be interested in, but I just highlight two more which I think are the most practical. Setting a context, and adding custom patters. Setting a context is done by adding a markdown file called context.md in the ./config/fabric/ directory to add context to your pattern. This could be anything you like, for example you might add your goals or the essence of your existence and why you do what you do day to day.
From the custom patterns perspective you can always add your custom patterns which you do not want to upload to fabric in the ~/.config/custom-fabric-patterns directory. However, whenever you want to use them with fabric you need to move them into the ~/.config/fabric/patterns directory. Just beware that any time you update fabric, the folder get updated and every custom pattern will be deleted, so you need to copy them from the custom folder before using them.
Hope you now have a good cause to go setup fabric and spend a little bit more time with your local LLMs and get better at writing prompts and extracting information or getting what you need faster and more effectively. Stay tuned for more AI content 👋🏽.
","timeToRead":4,"frontmatter":{"title":"🔮 fabric, augmenting humans using AI","unformattedDate":"2024-06-01T00:00:00.000Z","date":"Jun 01, 2024","path":"/fabric/","author":"Yaser Adel Mehraban","tags":["AI","LLM","GenerativeAI","fabric","promptengineering"],"thumbnail":{"childImageSharp":{"gatsbyImageData":{"layout":"constrained","placeholder":{"fallback":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAKCAYAAAC0VX7mAAAACXBIWXMAAA7BAAAOwQG4kWvtAAACwUlEQVR42m2Sa0ySURiA0axV648/bG1t/ehnv9qqtaYTJ6n7DAOcJGlETqfTFQUrChd9xtSlhpKQaJOZE7zNlBpe8AZq6cDLHHnLVPCaGCqJQ0K+700warbO9m7nvDvv856z9yEQ/lmAgj+6F559SUJf4LR8JWirbSt/vsG6bq5YW+7OMSd77wH4/a7w06IQQKfXHzoA0WohYGgIDnvPGvtJs9wiGyowz+gLTUsj4u94I28G+rPXoCd3Fe8Qz3LACqfnG2xnoR+O+TgoivoT9shHUALqD4T9jq+SeoOMktUek9wFE2Wb2ECBBa/jftlVC2cwo9KKLaq23ZOVVmxEsrDTm2PeVmXOGbVlmylSqenUnxca1bZAg3KNOFq3IZisdsxOVe2CvnzD1Ve2jhmq7Nhw7Q7oKmwwoPgBzaJFyEvTuQWsLqjJXcLbqt1QmDuP0yhNNgSp5BJS7jRnqkosc+3yHWiUOaHm9QZUSBYw1bttaFLaQSGzgFQ4Afx7emBnDAOPbQTu/UnIEVlxWf1PnC0YxcKjFM4IRAVIdKWGEEluWrmZoIW09MHdhBSdg8X+5HqQNQ7PXkzDQ74BOE8NICw2QnbRIHCeG4D38ivwpd/gcckyMDgfISyyyhlH1wCNoZZ4v0uKKueGkEpLSddqp5L5Y/Ck2IQ/yvuMC8TjoNDYQd7phNvcVqAyazFqstpNSWvH6Hd1GDmpFQsj17iQ2A6IYbT2oSzWUd9svIokJraci6Y2KmNZ75d4ommsuBMgS2mDYPIbPJiixG/xx4HJG4MbnGGISdICQm/Do+M8sBY9k1l/Zn/KXt08QE/4vCIGhIa/FdLSe+E8qcgdSqsDamqXg0gulV8KyedeIUpFxKtyRdT1agklvik+NfXDcZ+PB4T2OOSTMyNDe+Li5YLuCyFiB8Jo0EcghcH/LfLl4G/+F9J4nFtMefroAAAAAElFTkSuQmCC"},"backgroundColor":"transparent","images":{"fallback":{"src":"/static/64bf948aba70b827b708605fff9f762b/1cdee/fabric-logo.png","srcSet":"/static/64bf948aba70b827b708605fff9f762b/7440e/fabric-logo.png 750w,\n/static/64bf948aba70b827b708605fff9f762b/1cdee/fabric-logo.png 753w","sizes":"(min-width: 753px) 753px, 100vw"},"sources":[{"srcSet":"/static/64bf948aba70b827b708605fff9f762b/6abb8/fabric-logo.webp 750w,\n/static/64bf948aba70b827b708605fff9f762b/e748a/fabric-logo.webp 753w","type":"image/webp","sizes":"(min-width: 753px) 753px, 100vw"}]},"width":753,"height":392}}}}}},{"node":{"id":"4f4f7548-6059-5cdd-9666-b25628bb1cd8","html":"Many learners ask me how they can get access to Azure OpenAI and Generative AI since they don’t have access to an enabled subscription. I knew there are open source tools which allow people to work with these models, but I never had a use case to go and try this out.
\n\nI have a kid in high school and she wanted to give ChatGPT a try for a task she was working on, I was afraid she would use it to get the answer right away instead of figuring out how to solve the problem. This forced me to look into how I can have a better control over how she could use LLMs without “cheating”.
\nThat’s when I stumbled upon Ollama, a great cross-platform, open source project which happens to be the easiest way you can get an engine running with many available models. Although their Windows version is experimental and in development, you can install it on Windows Subsystem for Linux aka WSL.
\nBefore we start our process, you need to know that you will need a system which has a decent GPU since running AI locally demands that. This could even be your laptop which has a graphic card, or even better your gaming PC with that crazy spec you spent that much money on.
\nYou most likely need docker installed as well since I will use it to run the web UI, but this is not mandatory.
\nOf course you need WSL enabled and a distro installed, but don’t worry as soon as you enable Virtual Machine Platform and Windows Subsystem for Linux in your windows features, all it takes is a few commands:
\nwsl -- install -d ubuntu\r\nwsl --update\r\nwsl --set-default-version 2Before we install any packages, it’s always a good idea to update the current ones, this becomes more important if you have had WSL enabled for a while.
\nsudo apt update && sudo apt upgradeNow it’s time to install Ollama:
\ncurl -fsSL https://ollama.com/install.sh | shThis will take a while to finish, so get a coffee and be patient. Once it is installed it will start the Ollama engine and shows you it’s running. To test it you can open a browser and navigate to http://localhost:11434 which should show you it’s running:
Now you can pull down a model and interact with it:
\nollama run llama3Once it’s done, it will wait for you to enter your prompt:
\nAnother issue I was facing now was that I didn’t want to keep my terminal running, so a better way would be to run Ollama as a service. Since WSL does not use the systemd, you can’t run services by default. So we have to first enable it:
nano /etc/wsl.confThen enter these lines anywhere in the file:
\n[boot]\r\nsystemd=trueAnd finally exit the nano with Ctrl + X, select Y to save your changes. Now we have to restart our WSL. Exit our of WSL by typing exit, and then run:
\nwsl --shutdown\r\nwsl -l\r\nwsl run Ubuntu-22.04And finally start the service:
\nsudo systemctl enable ollama\r\nsudo systemctl start ollamaThis is great, but my kiddo can’t use my terminal to interact with these models. So I went on a hunt to find a user interface which can use Ollama, and not long after I found Open WebUI which allows you to leverage Ollama and interact with it via a user friendly UI. Plus it has the benefit of persisting your conversation history.
\nYou can install it directly on the WSL, but I’d much prefer to use the docker version of it, but first you need to enable the WSL integration on the Docker Desktop app:
\nOnce you have that done, simply run the docker command:
\ndocker run -d -p 3005:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:mainNote I changed the default port to 3005 since I have a few other apps running on port 3000 in development. Once the container is up and running all you need to do is to open a browser and navigate to http://localhost:3005:
Click on sign up and add your user, don’t worry the password is only stored locally inside the docker container volume. Once you signed up, you will need to add the Ollama address in the settings:
\nClick Save and you’re ready to select a model and start chatting.
\nThat got me through the initial setup and everything was great, but I still had the problem of how to prevent the model to give direct answers to my kid. Fortunately Open WebUI has the ability to create custom model files which basically allows you to set a system message for an existing model. This is exactly what I needed.
\nNavigate to Workspace and select create a new model file, I named it Debra, and added the following custom prompt:
\nFROM llama3\r\nPARAMETER temperature 0\r\nSYSTEM \"\"\"\r\nYou are an AI assistant designed to help my daughter which is in high school learn and solve problems. You will guide her through the process of finding solutions, but you won’t provide direct answers. This is to ensure that she is actively learning and understanding the concepts. Remember, the goal is not just to get the right answer, but to understand how to arrive at that answer. I want her on this journey of learning together in a safe and supportive environment. \r\n\"\"\"I also checked the assistant and education boxes and saved my model.
\nAnd last we need to make sure her user can only use this model and can’t delete their chat history which can be done in the admin settings:
\nIt’s that easy to create a kernel function which then can be included in a plan by the kernel. Don’t worry about the 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. There are two types of planners you can use at the time of writing this post (this is in preview so anything can happen): Let’s start by creating our planner and see how it will create a plan. We need a few things before we start: First we can ready our directories from the Next let’s add our function to our kernel: Since our planner will have to pass parameters to prompts and plugins, we need to create a Next we will create our planner and ask: 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: If we print our plan, it might look like this: And last we invoke our plan and see the results: We should see our pipelines getting created in the desired directory. DevOps is the name of our plugin, and AzDevOps and GitHubActions are our function names. 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. Here is how mine looks like for GitHub Actions: 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 And here is what the 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. 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. I have created a folder called desc which includes two files one for an application written with Here is the content of the In order to setup the kernel we need a few things: 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: You can find the full code for this post here. Simply clone the code, build and run it passing the required information like so: I am passing the The result will look like this: 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. 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. 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. Semantic Kernel Series: ✔️ Part one: Intro\r\n You can find the code on my GitHub repository here. 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. 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. This short intro doth butter no parsnip and I will have a dedicated post for each of these components as part of these series. 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. Image from Semantic Kernel Documentation 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: The next step is to add the SDK: Copy this code snippet into the Replace the endpoint, API key and model name and run the project with either F5 or 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.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 }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.Planner
\n\n
\nCreating the planner
\n\n
\nappsettings.json file:var planTemplatePath = Configuration!.GetValue<string>(\"PlanPath\")!;\r\nvar pipelineDir = Configuration!.GetValue<string>(\"PipelineDir\")!;kernel.ImportPluginFromType<ExtrcatPipelineFromOutput>();KernelArguments object: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};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}\";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}{{!-- 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}}var result = await plan.InvokeAsync(kernel, initialArguments);\r\nConsole.WriteLine(result);Prompt text
\nINSTRUCTIONS:\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}}$input which will be passed by the user to the kernel later.config.json looks like for this prompt:{\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}Input
\n.Net 8 and one for a node based application.node based input file: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.Setting up the kernel
\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>());Output
\ngit 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.Net application prompt and tell the kernel to create a GitHub Actions workflow.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#-----#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.What next?
\n
\r\n✔️ Part two: Plugins\r\n
\r\n✔️ Part three: Planners and Native Function pluginsSemantic Kernel’s components
\n\n
\nA little taste of what to expect
\nA simple quick start
\ndotnet new console -n semantickerneldemocd semantickerneldemo\r\ndotnet add package Microsoft.SemanticKernelprogram.cs file: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.dotnet run. And you should see the summary of the text.What’s next?
\n