sandbox/usecases/rag/dotnet/Getting-started.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started with Miyagi's Retrieval Augmented Generation (RaG) Workflow using Azure Cognitive Search (ACS) and Semantic Kernel\n",
    "\n",
    "To quickly get started, follow these steps:\n",
    "\n",
    "1. Ensure the [Polyglot notebooks extension](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.dotnet-interactive-vscode) is installed.\n",
    "2. [Create a new Azure OpenAI service (or use an existing OpenAI service)](https://learn.microsoft.com/en-us/azure/ai-services/openai/chatgpt-quickstart?tabs=command-line&pivots=programming-language-studio#prerequisites).\n",
    "3. [Deploy the `gpt-35-turbo` and `text-embeddings-ada-002` models](https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models#working-with-models).\n",
    "4. [Create an Azure Cognitive Search instance and enable the Semantic Search capability](https://learn.microsoft.com/en-us/azure/search/semantic-search-overview#enable-semantic-search).\n",
    "5. Copy the `.env.example` file from the `rag` folder to `dotnet/.env` and paste the corresponding values from the resources you provisioned in the earlier steps.\n",
    "6. Click on `Run All`.\n",
    "\n",
    "> You will need an [.Net 7 SDK](https://dotnet.microsoft.com/en-us/download) and [Polyglot](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.dotnet-interactive-vscode) to get started with this notebook using .Net Interactive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "In this notebook, we will show you how to quickly get started with Miyagi's Retrieval Augmented Generation (RaG) workflow using Semantic Kernel, Azure Cognitive Search (ACS) and Cosmos. Through this use case, involving stock recommendations, you will understand the basics of RaG and the capabilities of Semantic Kernel, Azure Cognitive Search and Cosmos to adapt to your specific use case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load settings from .env file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#r \"nuget: dotenv.net\"\n",
    "dotenv.net.DotEnv.Load();\n",
    "var env = dotenv.net.DotEnv.Read();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare the kernel with memory using Azure Cognitive Search"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first add the nuget packages (dependecies) required to instantiate the kernel and ancillary dependencies. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#r \"nuget: Microsoft.SemanticKernel, 1.7.1\"\n",
    "#r \"nuget: Microsoft.SemanticKernel.Connectors.AzureAISearch, 1.7.1-alpha\"\n",
    "#r \"nuget: Microsoft.SemanticKernel.Plugins.OpenApi, 1.7.1-alpha\"\n",
    "#r \"nuget: Microsoft.SemanticKernel.Plugins.Memory, 1.7.1-alpha\"\n",
    "#r \"nuget: Microsoft.SemanticKernel.Plugins.Core, 1.7.1-alpha\"\n",
    "#r \"nuget: Microsoft.SemanticKernel.PromptTemplates.Handlebars, 1.7.1\"\n",
    "#r \"nuget: Microsoft.SemanticKernel.Yaml, 1.7.1\"\n",
    "#r \"nuget: Azure.Identity\"\n",
    "#r \"nuget: System.IdentityModel.Tokens.Jwt, 7.5.1\"\n",
    "#r \"nuget: Microsoft.Extensions.Logging\"\n",
    "#r \"nuget: Microsoft.Extensions.Logging.Console\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importance of Authentication Using DefaultAzureCredential\n",
    "\n",
    "Authentication is a critical aspect of security in cloud applications, ensuring that only authorized users and services can access your Azure resources. `DefaultAzureCredential` simplifies the authentication process in your .NET applications by automatically selecting the best available authentication method based on the environment your application is running in. This includes environments like local development machines, Azure-hosted applications, and CI/CD pipelines.\n",
    "\n",
    "### How DefaultAzureCredential Works\n",
    "`DefaultAzureCredential` attempts to authenticate using several methods in order. This includes:\n",
    "1. Environment credentials (using environment variables)\n",
    "2. Managed Identity (ideal for automated tasks in Azure, such as in Azure Functions or App Services)\n",
    "3. Visual Studio credentials (helpful during development)\n",
    "4. Visual Studio Code credentials\n",
    "5. Azure CLI credentials (convenient for local debugging)\n",
    "6. Interactive browser credential as a fallback\n",
    "\n",
    "![Azure Identity](https://raw.githubusercontent.com/Azure/azure-sdk-for-net/main/sdk/identity/Azure.Identity/images/mermaidjs/DefaultAzureCredentialAuthFlow.svg)\n",
    "\n",
    "### Troubleshooting Authentication Issues\n",
    "If `DefaultAzureCredential` fails to authenticate, use the below code cell to troubelshoot with a detailed log setup that attempts to acquire a token using `DefaultAzureCredential`.\n",
    "\n",
    "#### Optional: Specifying Client ID and Secret\n",
    "In scenarios where `DefaultAzureCredential` does not meet your specific needs, such as when needing explicit control over the identity used for testing, you can configure a Service Principal directly using the following environment variables:\n",
    "- `AZURE_CLIENT_ID`\n",
    "- `AZURE_CLIENT_SECRET`\n",
    "- `AZURE_TENANT_ID`\n",
    "\n",
    "Ensure that the Service Principal has the appropriate roles assigned for accessing the Azure OpenAI Service and Azure Cognitive Search. Typically, this involves configuring role assignments in the Azure portal or using Azure CLI.\n",
    "\n",
    "### Steps to Use Service Principal with Environment Variables\n",
    "1. Create a Service Principal using Azure CLI or through the Azure portal.\n",
    "2. Assign the necessary roles to the Service Principal for the resources it needs to access (for this notebook, that would be Azure OpenAI service and AI Search).\n",
    "3. Set the environment variables on the machine or in the application settings where your code will run.\n",
    "4. Use `DefaultAzureCredential`, which will now pick up the environment variables.\n",
    "\n",
    "Remember, using a Service Principal requires keeping your credentials secure. Avoid hard-coding credentials in your source code and use secrets management tools provided by Azure or other third parties.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using Azure.Identity;\n",
    "using Microsoft.Extensions.Logging;\n",
    "using System.IdentityModel.Tokens.Jwt;\n",
    "using System.Linq;\n",
    "\n",
    "var loggerFactory = LoggerFactory.Create(builder =>\n",
    "{\n",
    "    builder\n",
    "        .AddConsole()\n",
    "        .SetMinimumLevel(LogLevel.Debug);\n",
    "});\n",
    "\n",
    "ILogger logger = loggerFactory.CreateLogger(\"DefaultLogger\");\n",
    "\n",
    "var options = new DefaultAzureCredentialOptions\n",
    "{\n",
    "    Diagnostics =\n",
    "    {\n",
    "        IsLoggingContentEnabled = false,\n",
    "        IsLoggingEnabled = true,\n",
    "        IsDistributedTracingEnabled = true,\n",
    "        IsTelemetryEnabled = true\n",
    "    }\n",
    "};\n",
    "\n",
    "var credential = new DefaultAzureCredential(options);\n",
    "\n",
    "try\n",
    "{\n",
    "    var tokenRequestContext = new Azure.Core.TokenRequestContext(new[] { \"https://management.azure.com/.default\" });\n",
    "    var tokenResult = credential.GetToken(tokenRequestContext);\n",
    "    var handler = new JwtSecurityTokenHandler();\n",
    "    var jwtToken = handler.ReadJwtToken(tokenResult.Token);\n",
    "\n",
    "    var name = jwtToken.Claims.FirstOrDefault(c => c.Type == \"name\")?.Value;\n",
    "    var unique_name = jwtToken.Claims.FirstOrDefault(c => c.Type == \"unique_name\")?.Value;\n",
    "    var scopes = jwtToken.Claims.FirstOrDefault(c => c.Type == \"scp\")?.Value;\n",
    "\n",
    "    logger.LogInformation($\"Token principal: {name}\");\n",
    "    logger.LogInformation($\"Token Unique Name: {unique_name}\");\n",
    "    logger.LogInformation($\"Token scopes: {scopes}\");\n",
    "}\n",
    "catch (Exception ex)\n",
    "{\n",
    "    logger.LogError($\"Error retrieving token: {ex.Message}\");\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With dependencies installed and configured, we create an instance of the kernel using the built-in `Kernel.Builder` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.SemanticKernel;\n",
    "using Azure.Identity;\n",
    "\n",
    "var builder = Kernel.CreateBuilder();\n",
    "        builder.Services.AddAzureOpenAIChatCompletion(\n",
    "            deploymentName: env[\"AZURE_OPENAI_CHAT_MODEL\"],\n",
    "            endpoint: env[\"AZURE_OPENAI_ENDPOINT\"],\n",
    "            // credentials: new DefaultAzureCredential() // Use this for token based authentication (recommended)\n",
    "            apiKey: env[\"AZURE_OPENAI_API_KEY\"] // Use this for API key based authentication (not recommended for production use)\n",
    "        );\n",
    "\n",
    "var kernel = builder.Build();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make the kernel stateful, we will use Memory Plugin with a Azure Cognitive Search and Embedding backend. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.SemanticKernel.Connectors.AzureAISearch;\n",
    "using Microsoft.SemanticKernel.Connectors.OpenAI;\n",
    "using Microsoft.SemanticKernel.Memory;\n",
    "using Microsoft.SemanticKernel.Plugins.Core;\n",
    "  \n",
    "#pragma warning disable SKEXP0003\n",
    "#pragma warning disable SKEXP0011\n",
    "#pragma warning disable SKEXP0021\n",
    "#pragma warning disable SKEXP0001\n",
    "#pragma warning disable SKEXP0010\n",
    "#pragma warning disable SKEXP0020\n",
    "\n",
    "IMemoryStore store = new AzureAISearchMemoryStore(\n",
    "    env[\"AZURE_COGNITIVE_SEARCH_ENDPOINT\"],\n",
    "    // credentials: new DefaultAzureCredential() // Use this for token based authentication (recommended)\n",
    "    apiKey: env[\"AZURE_COGNITIVE_SEARCH_API_KEY\"] // Use this for API key based authentication (not recommended for production use)\n",
    "    );\n",
    "            \n",
    "// Create an embedding generator to use for semantic memory.\n",
    "var embeddingGenerator = new AzureOpenAITextEmbeddingGenerationService(\n",
    "    deploymentName: env[\"AZURE_OPENAI_EMBEDDING_MODEL\"],\n",
    "    endpoint: env[\"AZURE_OPENAI_ENDPOINT\"],\n",
    "    // credential: new DefaultAzureCredential(), // Use this for token based authentication (recommended)\n",
    "    apiKey: env[\"AZURE_OPENAI_API_KEY\"], // Use this for API key based authentication (not recommended for production use)\n",
    "    modelId: env[\"AZURE_OPENAI_EMBEDDING_MODEL\"]\n",
    ");\n",
    "\n",
    "SemanticTextMemory textMemory = new(store, embeddingGenerator);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorize and persist embeddings in Azure Cognitive Search with Semantic Kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Embeddings are a type of data transformation that convert text into high-dimensional vectors that capture semantic relationships between words or text chunks. This vectorized form allows machines to process text in a manner akin to numerical data, enabling operations like similarity comparison which is foundational for vector databases to retrieve meaningful context for LLMs. Embeddings are essential to generate and retrieve relevant content in a RaG workflow because:\n",
    "\n",
    "1. They normalize your data in a common mathematical representation, making it machine-friendly\n",
    "1. They compress data, retaining essential representations while reducing dimensionality\n",
    "1. They preserve relationships within your data\n",
    "1. They are representationally dense, meaning they are more efficient to store and process\n",
    "\n",
    "\n",
    "> See a visual representation of the embeddings in 2D space below (from Cohere):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Semantic Search](https://txt.cohere.com/content/images/2023/01/Vis-7-2.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let’s delve into the process of creating and utilizing embeddings in the context of ACS.\n",
    "\n",
    "In this scenario, we have a snippet of proprietary text data—extracted from a book—which needs to be processed and indexed for semantic search. The steps involve:\n",
    "\n",
    "1. Chunking the Text: Breaking down the text into manageable pieces, referred to as 'chunks'.\n",
    "1. Generating Embeddings: Transforming these chunks into high-dimensional vectors using an Azure Text Embedding Generation Service.\n",
    "1. Persisting Embeddings to ACS: Storing these embeddings in Azure Cognitive Search to facilitate semantic search.\n",
    "\n",
    "The provided code snippet orchestrates these steps. It reads the text data from a local file, chunks it, generates embeddings for each chunk, and then persists these embeddings to ACS. The specific operations are abstracted for simplicity using methods like SaveInformationAsync, which is part of a hypothetical kernel object in this code. The end result is a collection of indexed embeddings in ACS that significantly enhance search quality by moving beyond mere keyword matching to understanding semantic relationships."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved 24 chunks to memory collection miyagi-investment-thesis\r\n"
     ]
    }
   ],
   "source": [
    "using Microsoft.SemanticKernel.Text;\n",
    "using System.IO;\n",
    "\n",
    "#pragma warning disable SKEXP0055\n",
    "#pragma warning disable SKEXP0050\n",
    "var dataset = \"intelligent-investor.txt\";\n",
    "var recommendationServicePath = \"../../../../services/recommendation-service/dotnet\";\n",
    "const int MaxTokensPerParagraph = 300;\n",
    "const int MaxTokensPerLine = 100;\n",
    "\n",
    "// Load text data from a local file\n",
    "var filePath = Path.Combine(recommendationServicePath, \"resources\", \"sample-datasets\", dataset);\n",
    "var streamReader = new StreamReader(filePath);\n",
    "var text = await streamReader.ReadToEndAsync();\n",
    "\n",
    "// Define a memory collection name for indexing\n",
    "var memoryCollectionName = \"miyagi-investment-thesis\";\n",
    "\n",
    "// Chunk the text into lines and paragraphs for manageable processing\n",
    "var lines = TextChunker.SplitPlainTextLines(text, MaxTokensPerLine);\n",
    "var chunks = TextChunker.SplitPlainTextParagraphs(lines, MaxTokensPerParagraph);\n",
    "\n",
    "// Loop through each chunk to generate embeddings and persist to ACS\n",
    "for (var i = 0; i < chunks.Count; i++)\n",
    "{\n",
    "    var chunk = chunks[i];\n",
    "    // Generate an identifier for each chunk\n",
    "    await textMemory.SaveInformationAsync(\n",
    "        memoryCollectionName,\n",
    "        chunk,\n",
    "        $\"{dataset}-{i}\",\n",
    "        $\"Dataset: {dataset} Chunk: {i}\",\n",
    "        i.ToString());\n",
    "}\n",
    "\n",
    "// Output the result to console\n",
    "System.Console.WriteLine($\"Saved {chunks.Count} chunks to memory collection {memoryCollectionName}\");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Search and retrieve documents using Semantic Kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To search and retrieve documents, we will use the `SearchAsync` method of Semantic memory that encapsulates retrieval abstractions of different memory providers. This method takes in a query and returns a list of documents that are relevant to the query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Projection is dangerous because the future is uncertain, and inflation, economic recessions, pandemics and geopolitical upheavals often arrive without warning.\n",
      "Graham argues that it is a fool's errand for an ordinary investor to attempt making money by timing the market.\n",
      "Graham advocates for a protection-based approach that does not try to time the market.\n",
      "Value investors should identify and invest in large, conservatively financed companies whose present value (as estimated by tangible assets) is substantially below their current stock prices.\n",
      "   Relevance: 0.8646199382230626\n",
      "\n",
      "   Similarly, a defensive investor who has made a value-based investment based on sound business fundamentals will ignore the stock market valuation apart from taking advantage of its swings. Graham goes so far as to say that the single biggest reason investors fail is that they pay too much attention to what the stock market is currently doing.\n",
      "Intelligent investors should be comfortable holding their stocks even if they don't see the daily stock market prices for years. Experiments have shown that investors who received frequent news updates about their stocks earned half the returns of investors who received no information at all.\n",
      "resource image\n",
      "[widget]\n",
      "A defensive investor's stock portfolio\n",
      "Asset allocation\n",
      "Graham suggests a mechanical 50-50 split between stocks and bonds for defensive investors to guard against over-purchasing shares in a bull market and rushing into bonds in a bear market. The only action they should take is to rebalance their portfolio every six months if market developments alter this 50-50 ratio by over 5%.\n",
      "   Relevance: 0.8577210461127733\n",
      "\n"
     ]
    }
   ],
   "source": [
    " var query = \"Ben Graham's investment philosophy\";\n",
    " \n",
    " await foreach (var result in textMemory.SearchAsync(\n",
    "            collection: memoryCollectionName,\n",
    "            query: query,\n",
    "            limit: 2,\n",
    "            minRelevanceScore: 0.79,\n",
    "            withEmbeddings: true))\n",
    "        {\n",
    "            Console.WriteLine(\"   \" + result.Metadata.Text);\n",
    "            Console.WriteLine(\"   Relevance: \" + result.Relevance + \"\\n\");\n",
    "        }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grounding with Native Functions and SK's Memory \"recall\"\n",
    "\n",
    "> Note that this prompt template (semantic function) is located under services/reccommendation-service/dotnet/plugins/AdvisorPlugin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using System.IO;\n",
    "using Microsoft.SemanticKernel;\n",
    "using Microsoft.SemanticKernel.PromptTemplates.Handlebars;\n",
    "using Microsoft.SemanticKernel.Plugins.Memory;\n",
    "\n",
    "#pragma warning disable SKEXP0052\n",
    "#pragma warning disable SKEXP0001\n",
    "#pragma warning disable SKEXP0050\n",
    "\n",
    "\n",
    "var pluginFolder = $\"{recommendationServicePath}/Resources/Prompts\";\n",
    "\n",
    "// Construct the full file path\n",
    "var filePath = Path.Combine(pluginFolder, \"InvestmentAdvise.prompt.yaml\");\n",
    "\n",
    "KernelFunction advisorPlugin;\n",
    "\n",
    "// Use StreamReader to read the file\n",
    "using (StreamReader reader = new StreamReader(filePath))\n",
    "{\n",
    "    // Create the function from the YAML file using Handlebars template\n",
    "    advisorPlugin = kernel.CreateFunctionFromPromptYaml(\n",
    "        reader.ReadToEnd(),\n",
    "        promptTemplateFactory: new HandlebarsPromptTemplateFactory()\n",
    "    );\n",
    "}\n",
    "\n",
    "\n",
    "// recall is from the TextMemoryPlugin, which has a recall method that can be invoked from Semantic Function to perform retrieval\n",
    "KernelPlugin memoryPlugin = kernel.ImportPluginFromObject(new TextMemoryPlugin(textMemory));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Kernel Arguments (context variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using System.Text.Json;\n",
    "using Microsoft.SemanticKernel.ChatCompletion;\n",
    "\n",
    "#pragma warning disable SKEXP0052\n",
    "#pragma warning disable SKEXP0001\n",
    "#pragma warning disable SKEXP0050\n",
    "\n",
    "// Create few-shot examples\n",
    "List<ChatHistory> fewShotExamples = [\n",
    "    [\n",
    "        new ChatMessageContent(AuthorRole.User, @\"{\"\"stocks\"\":[{\"\"symbol\"\":\"\"MSFT\"\",\"\"allocation\"\":0.6},{\"\"symbol\"\":\"\"ACN\"\",\"\"allocation\"\":0.4}]}\"),\n",
    "        new ChatMessageContent(AuthorRole.Assistant, @\"{\"\"portfolio\"\":[{\"\"symbol\"\":\"\"MSFT\"\",\"\"gptRecommendation\"\":\"\"Booyah! Hold on, steady growth! Diversify, though!\"\"},{\"\"symbol\"\":\"\"ACN\"\",\"\"gptRecommendation\"\":\"\"Buy! Services will see a boom!\"\"}]}\")\n",
    "    ]\n",
    "];\n",
    "\n",
    "/*\n",
    "    * Resolve issue with Handlebars ProcessPositionalArguments issue with parameter parsing for TextMemoryPlugin-recall\n",
    "    * In prompt template for handlebars, the following is not working:\n",
    "    * {{TextMemoryPlugin-recall semanticQuery, miyagi-embeddings, 0.8, 3}}\n",
    "    *\n",
    "    * Meanwhile, use this alternative approach\n",
    "*/\n",
    "var memories = await kernel.InvokeAsync(memoryPlugin[\"Recall\"], new()\n",
    "{\n",
    "    [TextMemoryPlugin.InputParam] = $\"Investment advise for aggressive risk level\",\n",
    "    [TextMemoryPlugin.CollectionParam] = \"miyagi-investment-thesis\",\n",
    "    [TextMemoryPlugin.LimitParam] = \"2\",\n",
    "    [TextMemoryPlugin.RelevanceParam] = \"0.8\",\n",
    "});\n",
    "\n",
    "Console.WriteLine($\"Memories: {memories.GetValue<string>()}\");\n",
    "Console.WriteLine();\n",
    "\n",
    "// Set harcoded parameters for the AdvisorPlugin\n",
    "var stocks = new[] {\n",
    "    new {symbol = \"MSFT\", allocation = 0.3},\n",
    "    new {symbol = \"ACN\", allocation = 0.1},\n",
    "    new {symbol = \"JPM\", allocation = 0.3},\n",
    "    new {symbol = \"PEP\", allocation = 0.3}\n",
    "};\n",
    "\n",
    "var arguments = new KernelArguments\n",
    "{\n",
    "    [\"userId\"] = \"50\",\n",
    "    [\"stocks\"] = JsonSerializer.Serialize(stocks),\n",
    "    [\"risk\"] = \"aggressive\",\n",
    "    [\"fewShotExamples\"] = fewShotExamples,\n",
    "    [\"voice\"] = \"Jim Cramer\",\n",
    "    [\"memories\"] = memories.GetValue<string>()\n",
    "};\n",
    "arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create native function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "// Copyright (c) Microsoft. All rights reserved.\n",
    "\n",
    "using System.ComponentModel;\n",
    "using Microsoft.SemanticKernel;\n",
    "\n",
    "\n",
    "/// <summary>\n",
    "///     UserProfilePlugin shows a native skill example to look user info given userId.\n",
    "/// </summary>\n",
    "/// <example>\n",
    "///     Usage: kernel.ImportSkill(\"UserProfilePlugin\", new UserProfilePlugin());\n",
    "///     Examples:\n",
    "///     SKContext[\"userId\"] = \"000\"\n",
    "///     {{UserProfilePlugin.GetUserAge $userId }} => {userProfile}\n",
    "/// </example>\n",
    "public class UserProfilePlugin\n",
    "{\n",
    "    /// <summary>\n",
    "    ///     Name of the context variable used for UserId.\n",
    "    /// </summary>\n",
    "    public const string UserId = \"UserId\";\n",
    "\n",
    "    private const string DefaultUserId = \"40\";\n",
    "    private const int DefaultAnnualHouseholdIncome = 150000;\n",
    "    private const int Normalize = 81;\n",
    "\n",
    "    /// <summary>\n",
    "    ///     Lookup User's age for a given UserId.\n",
    "    /// </summary>\n",
    "    /// <example>\n",
    "    ///     SKContext[UserProfilePlugin.UserId] = \"000\"\n",
    "    /// </example>\n",
    "    [KernelFunction, Description(\"Given a userId, get user age\")]\n",
    "    public string GetUserAge(\n",
    "        [Description(\"Unique identifier of a user\")]\n",
    "        string userId)\n",
    "    {\n",
    "        // userId = context.Variables.ContainsKey(UserId) ? context[UserId] : DefaultUserId;\n",
    "        userId = string.IsNullOrEmpty(userId) ? DefaultUserId : userId;\n",
    "        \n",
    "        int age;\n",
    "\n",
    "        if (int.TryParse(userId, out var parsedUserId))\n",
    "            age = parsedUserId > 100 ? parsedUserId % Normalize : parsedUserId;\n",
    "        else\n",
    "            age = int.Parse(DefaultUserId);\n",
    "\n",
    "        // invoke a service to get the age of the user, given the userId\n",
    "        return age.ToString();\n",
    "    }\n",
    "\n",
    "    /// <summary>\n",
    "    ///     Lookup User's annual income given UserId.\n",
    "    /// </summary>\n",
    "    /// <example>\n",
    "    ///     SKContext[UserProfilePlugin.UserId] = \"000\"\n",
    "    /// </example>\n",
    "    [KernelFunction, Description(\"Given a userId, get user annual household income\")]\n",
    "    public string GetAnnualHouseholdIncome(\n",
    "        [Description(\"Unique identifier of a user\")]\n",
    "        string userId)\n",
    "    {\n",
    "        \n",
    "        // userId = context.Variables.ContainsKey(UserId) ? context[UserId] : DefaultUserId;\n",
    "        userId = string.IsNullOrEmpty(userId) ? DefaultUserId : userId;\n",
    "\n",
    "        var random = new Random();\n",
    "        var randomMultiplier = random.Next(1000, 8000);\n",
    "\n",
    "        // invoke a service to get the annual household income of the user, given the userId\n",
    "        var annualHouseholdIncome = int.TryParse(userId, out var parsedUserId)\n",
    "            ? parsedUserId * randomMultiplier\n",
    "            : DefaultAnnualHouseholdIncome;\n",
    "\n",
    "        return annualHouseholdIncome.ToString();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "// import the UserProfilePlugin\n",
    "kernel.Plugins.AddFromType<UserProfilePlugin>();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Invoke the LLM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"portfolio\":[\n",
       "  {\"symbol\":\"MSFT\",\"gptRecommendation\":\"Tech's a battlefield, but Microsoft's a warrior!\"},\n",
       "  {\"symbol\":\"ACN\",\"gptRecommendation\":\"Accenture's hot, but don't forget to spread your bets!\"},\n",
       "  {\"symbol\":\"JPM\",\"gptRecommendation\":\"Bank on JPMorgan, it's a financial fortress!\"},\n",
       "  {\"symbol\":\"PEP\",\"gptRecommendation\":\"Pepsi's fizzing with potential, keep sipping those dividends!\"}\n",
       "]}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "var result = await kernel.InvokeAsync(\n",
    "            advisorPlugin,\n",
    "            arguments\n",
    "        );\n",
    "result.GetValue<string>()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![RaG Workflow](../../../../assets/images/sk-memory-orchestration.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "polyglot-notebook"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}