beta_Practical_task_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "#!import config/Settings.cs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Import Semantic Kernel\n",
    "#r \"nuget: Microsoft.SemanticKernel, 1.0.0-beta8\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.1 🚀 Initialization and Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.SemanticKernel;\n",
    "\n",
    "var builder = new KernelBuilder();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "using Kernel = Microsoft.SemanticKernel.Kernel;\n",
    "\n",
    "var (model1, azureEndpoint1, apiKey1, gpt35TurboServiceId) = Settings.LoadFromFile(model: \"gpt-35-turbo\");\n",
    "builder.WithAzureOpenAIChatCompletionService(model1, azureEndpoint1, apiKey1, serviceId: gpt35TurboServiceId);\n",
    "\n",
    "var (model2, azureEndpoint2, apiKey2, gpt4ServiceId) = Settings.LoadFromFile(model: \"gpt-4-32k\");\n",
    "builder.WithAzureOpenAIChatCompletionService(model2, azureEndpoint2, apiKey2, serviceId: gpt4ServiceId);\n",
    "\n",
    "var kernel = builder.Build();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.2. 🚀 Semantic Kernel Pipeline: Calling Chain of Functions\n",
    "\n",
    "In the SK pipeline, you can create a powerful and expressive chain of inline functions. These functions, when executed sequentially, form a cohesive and efficient processing pipeline. Each function plays a specific role in transforming and analyzing data, contributing to the overall semantic understanding of the code.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "using System;\n",
    "using Microsoft.SemanticKernel.Orchestration;\n",
    "\n",
    "SKContext context = kernel.CreateNewContext();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.SemanticKernel.Connectors.AI.OpenAI;\n",
    "\n",
    "var requestSettings = new OpenAIRequestSettings\n",
    "{\n",
    "    Temperature = 0.7,\n",
    "    ServiceId = gpt4ServiceId,\n",
    "};\n",
    "\n",
    "context.Variables[\"NumberOfParticipants\"] = \"3\";\n",
    "context.Variables[\"NumberOfWords\"] = \"25\";\n",
    "\n",
    "var chatStoryPrompt = \"Craft a {{$NumberOfWords}}-word chat transcript involving {{$NumberOfParticipants}} users engaging with an online virtual assistant.\";\n",
    "var chatStoryFunction = kernel.CreateSemanticFunction(\n",
    "    promptTemplate: chatStoryPrompt, \n",
    "    pluginName: nameof(chatStoryPrompt),\n",
    "    requestSettings: requestSettings);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.SemanticKernel.Connectors.AI.OpenAI;\n",
    "\n",
    "var requestSettings = new OpenAIRequestSettings\n",
    "{\n",
    "    Temperature = 2,\n",
    "    ServiceId = gpt4ServiceId,\n",
    "};\n",
    "\n",
    "context.Variables[\"Lang\"] = \"Italian\";\n",
    "\n",
    "var translateStoryPrompt = \"You are the best linguist. Please translate the given TEXT to {{$Lang}}. TEXT: {{$Input}}\";\n",
    "\n",
    "var translateStoryFunction = kernel.CreateSemanticFunction(\n",
    "    promptTemplate: translateStoryPrompt, \n",
    "    pluginName: nameof(translateStoryPrompt),\n",
    "    requestSettings: requestSettings);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "ISKFunction[] pipeline = new ISKFunction[]\n",
    "{\n",
    "    chatStoryFunction,\n",
    "    translateStoryFunction,\n",
    "};\n",
    "\n",
    "var pipelineResult = await kernel.RunAsync(context.Variables, pipeline);\n",
    "\n",
    "Console.WriteLine($\"RESULT: {string.Join(\"\\n\\n===================\\n\\n\", pipelineResult.FunctionResults.Select(_ => _.GetValue<string>()))}\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.3 🚀 Using Built-in SK Plugins: Loading Functions\n",
    "\n",
    "The SK provides a set of built-in native plugins that offer powerful functionality for code analysis and manipulation. Loading functions from these plugins allows you to leverage their capabilities seamlessly within your code. Follow the steps below to harness the features of built-in native SK plugins.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.SemanticKernel.Plugins.Core;\n",
    "\n",
    "var timeFunctions = kernel.ImportFunctions(new TimePlugin(), \"time\");\n",
    "context.Variables[\"input\"] = \"100\";\n",
    "var result = await kernel.RunAsync(context.Variables, timeFunctions[\"daysAgo\"]);\n",
    "\n",
    "Console.WriteLine(result);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.4 🚀 Custom SK Plugin: Creating a new Plugin with SK functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "#!import Plugins/CustomPlugin/CustomPlugin.cs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Import your CustomPlugin to Semantic Kernel\n",
    "var customPluginFunctions = kernel.ImportFunctions(new CustomPlugin(kernel, serviceId: gpt4ServiceId));\n",
    "Console.WriteLine($\"{string.Join(\"\\n\", customPluginFunctions.Select(_ => $\"[{_.Value.Name}] : {_.Value.Description}\"))}\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Translate to 'Italian' using 'Translate' function from CustomPlugin\n",
    "context.Variables[\"input\"] = \"Translate me\";\n",
    "context.Variables[\"lang\"] = \"Italian\";\n",
    "\n",
    "var result = await kernel.RunAsync(customPluginFunctions[\"Translate\"], context.Variables);\n",
    "\n",
    "Console.WriteLine($\"{result.GetValue<string>()}\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Translate to 'Russian' using 'Translate' function from CustomPlugin\n",
    "context.Variables[\"input\"] = \"Translate me\";\n",
    "context.Variables[\"lang\"] = \"Russian\";\n",
    "\n",
    "result = await kernel.RunAsync(customPluginFunctions[\"Translate\"], context.Variables);\n",
    "\n",
    "Console.WriteLine($\"{result.GetValue<string>()}\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Translate to 'Chinese' using 'Translate' function from CustomPlugin\n",
    "context.Variables[\"input\"] = \"Translate me\";\n",
    "context.Variables[\"lang\"] = \"Chinese\";\n",
    "\n",
    "result = await kernel.RunAsync(customPluginFunctions[\"Translate\"], context.Variables);\n",
    "\n",
    "Console.WriteLine($\"{result.GetValue<string>()}\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.5. 🚀 Loading and calling functions from CustomPlugin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Create a pipeline array to store custom plugin functions.\n",
    "var pipeline = new []\n",
    "{\n",
    "    customPluginFunctions[\"Chat\"],\n",
    "    customPluginFunctions[\"Translate\"]\n",
    "};\n",
    "\n",
    "context.Variables[\"lang\"] = \"Russian\";\n",
    "context.Variables[\"message\"] = \"Hello\";\n",
    "context.Variables[\"history\"] = string.Empty;\n",
    "\n",
    "kernel.ImportFunctions(new TimePlugin());\n",
    "\n",
    "// Run the pipeline asynchronously using the kernel and update context variables.\n",
    "var result = await kernel.RunAsync(context.Variables, pipeline);\n",
    "\n",
    "Console.WriteLine($\"[Chat History]: {context.Variables[\"history\"]}\");\n",
    "Console.WriteLine($\"[Pipeline Result]: {result.GetValue<string>()}\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "Func<string, Task> Chat = async (string input) => {\n",
    "    // Save new message in the context variables\n",
    "    context.Variables[\"message\"] = input;\n",
    "    var answer = await kernel.RunAsync(context.Variables, pipeline);\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "await Chat(\"Favorite color?\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "await Chat(\"Best movie genre?\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "await Chat(\"Morning or night?\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.6. 🚀 Invoke a pipelines of semantic functions loaded from various plugins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Using plugins from the repo\n",
    "using Microsoft.SemanticKernel.AI.ChatCompletion;\n",
    "\n",
    "var currentDirectory = System.IO.Directory.GetCurrentDirectory();\n",
    "var pluginsDirectory = Path.Combine(currentDirectory, \"Plugins\");\n",
    "\n",
    "var summarizePluginFunctions = kernel.ImportSemanticFunctionsFromDirectory(pluginsDirectory, \"SummarizePlugin\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Creating pipeline with functions from multiple Plugins\n",
    "var summarizeFunction = summarizePluginFunctions[\"Summarize\"];\n",
    "\n",
    "var requestSettings = new OpenAIRequestSettings { ServiceId = gpt4ServiceId };\n",
    "summarizeFunction.ModelSettings.Append(requestSettings);\n",
    "\n",
    "context.Variables[\"message\"] = \"Semantic Kernel or Langchain?\";\n",
    "context.Variables[\"History\"] = string.Empty;\n",
    "context.Variables[\"lang\"] = \"Italian\";\n",
    "\n",
    "var pipeline = new []\n",
    "{\n",
    "    customPluginFunctions[\"Chat\"],\n",
    "    customPluginFunctions[\"Translate\"],\n",
    "    summarizePluginFunctions[\"Summarize\"],\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Run the pipeline asynchronously using the kernel and update context variables.\n",
    "var result = await kernel.RunAsync(context.Variables, pipeline);\n",
    "Console.WriteLine($\"[Pipeline Result]: {result.GetValue<string>()}\");"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "python",
   "version": "3.12.0"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}