notebook/L6_Planning_and_Stock_Report_Generation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "source": [
    "#### Lesson 6: Planning and Stock Report Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><div></div><div></div><div><strong>Installed Packages</strong><ul><li><span>AutoGen, 0.2.0</span></li></ul></div></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#r \"nuget:AutoGen,0.2.0\"\n",
    "#load \"util.csx\"\n",
    "\n",
    "using AutoGen.Core;\n",
    "using AutoGen.OpenAI;\n",
    "using AutoGen.OpenAI.Extension;\n",
    "using System.Threading;\n",
    "using System.IO;\n",
    "using Microsoft.SemanticKernel;\n",
    "using System.ComponentModel;\n",
    "using AutoGen.SemanticKernel;\n",
    "using OpenAI;\n",
    "using OpenAI.Chat;\n",
    "\n",
    "var chatClient = ChatClientProvider.Create(\"gpt-4o-mini\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note\n",
    "This example is slightly different with the python ones when it comes to engineer agent\n",
    "\n",
    "due to the lacking built-in support of running python code in C# AutoGen.\n",
    "\n",
    "The engineer and executor agent is replaced with market watcher and data analyst agents to gather and plot the stock price data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The task!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var task = \"\"\"\n",
    "Write a blogpost about the stock price performance of Nvidia in the past month.\n",
    "Today's date is 2024-04-23.\n",
    "\"\"\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build a group chat\n",
    "This group chat will include these agents:\n",
    "\n",
    "- User_proxy: to allow the user to comment on the report and ask the writer to refine it.\n",
    "- Planner: to determine relevant information needed to complete the task.\n",
    "- Market_Watcher: to gather the stock price data.\n",
    "- Data_Analyst: to plot the stock price data.\n",
    "- Writer: to write the report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var user = new OpenAIChatAgent(\n",
    "    chatClient: chatClient,\n",
    "    name: \"user\",\n",
    "    systemMessage: \"\"\"\n",
    "    Give the task, and send instructions to writer to refine the blog post.\n",
    "    \"\"\")\n",
    "    .RegisterMessageConnector()\n",
    "    .RegisterPrintMessage();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var planner = new OpenAIChatAgent(\n",
    "    chatClient: chatClient,\n",
    "    name: \"Planner\",\n",
    "    systemMessage: \"\"\"\n",
    "    You are Planner.\n",
    "    Given a task, please determine what step is needed to complete the task.\n",
    "    Please only suggest steps that can be done by others.\n",
    "    After each step is done by others, check the progress and instruct the remaining steps.\n",
    "    If a step fails, try to work around it.\n",
    "    If the task is completed, say 'task completed'.\n",
    "    \"\"\")\n",
    "    .RegisterMessageConnector()\n",
    "    .RegisterPrintMessage();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var workingDirectory = Path.Combine(Directory.GetCurrentDirectory(), \"work\");\n",
    "if (!Directory.Exists(workingDirectory))\n",
    "{\n",
    "    Directory.CreateDirectory(workingDirectory);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create market tools to gather and plot the stock price data. The data analyst will plot the stock price data and the writer will write the report."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "public class MarketTools\n",
    "{\n",
    "    private string workDir;\n",
    "\n",
    "    public MarketTools(string workDir)\n",
    "    {\n",
    "        this.workDir = workDir;\n",
    "    }\n",
    "\n",
    "    /// <summary>\n",
    "    /// Retrieve stock price data for a given symbol and date range.\n",
    "    /// </summary>\n",
    "    /// <param name=\"symbol\">stock symbol.</param>\n",
    "    /// <param name=\"from\">from date, in the format of YYYY-MM-dd</param>\n",
    "    /// <param name=\"to\">to date, in the format of YYYY-MM-dd</param>\n",
    "    /// <returns></returns>\n",
    "    [KernelFunction]\n",
    "    [Description(\"Retrieve stock price data for a given symbol and date range.\")]\n",
    "    public async Task<string> RetrieveStockPrice(\n",
    "        [Description(\"stock symbol\")]string symbol,\n",
    "        [Description(\"from data, in the format of YYYY-MM-dd\")]string from, \n",
    "        [Description(\"to date, in the format of YYYY-MM-dd\")]string to)\n",
    "    {\n",
    "        var sb = new StringBuilder();\n",
    "        sb.AppendLine($\"Retrieving stock price data for {symbol} from {from} to {to}...\");\n",
    "        // Retrieve stock price data from the database\n",
    "        var stockData = \"\"\"\n",
    "            2024-03-25    950.020020\n",
    "            2024-03-26    925.609985\n",
    "            2024-03-27    902.500000\n",
    "            2024-03-28    903.559998\n",
    "            2024-04-01    903.630005\n",
    "            2024-04-02    894.520020\n",
    "            2024-04-03    889.640015\n",
    "            2024-04-04    859.049988\n",
    "            2024-04-05    880.080017\n",
    "            2024-04-08    871.330017\n",
    "            2024-04-09    853.539978\n",
    "            2024-04-10    870.390015\n",
    "            2024-04-11    906.159973\n",
    "            2024-04-12    881.859985\n",
    "            2024-04-15    860.010010\n",
    "            2024-04-16    874.150024\n",
    "            2024-04-17    840.349976\n",
    "            2024-04-18    846.710022\n",
    "            2024-04-19    762.000000\n",
    "            2024-04-22    795.179993\n",
    "            \"\"\";\n",
    "\n",
    "        sb.AppendLine(stockData);\n",
    "\n",
    "        return sb.ToString();\n",
    "    }\n",
    "\n",
    "    /// <summary>\n",
    "    /// Plot candle line chart for stock price data.\n",
    "    /// </summary>\n",
    "    /// <param name=\"symbol\">stock symbol.</param>\n",
    "    /// <param name=\"close\">close price.</param>\n",
    "    /// <param name=\"date\">date, in the format of YYYY-MM-dd</param>\n",
    "    [KernelFunction]\n",
    "    [Description(\"Plot candle line chart for stock price data.\")]\n",
    "    public async Task<string> PlotStockLineChart(\n",
    "        [Description(\"stock symbol\")]string symbol,\n",
    "        [Description(\"close price\")]float[] close,\n",
    "        [Description(\"date, in the format of YYYY-MM-dd\")]string[] date)\n",
    "    {\n",
    "        var title = $\"Stock Price Performance of {symbol} from {date[0]} to {date[^1]}\";\n",
    "\n",
    "        // copy img/nvidia-plot.png to workDir/{title}.png\n",
    "        var targetPath = Path.Combine(workDir, $\"{title}.png\");\n",
    "        var imgPath = Path.Combine(\"img\", \"nvidia-plot.png\");\n",
    "        File.Copy(imgPath, targetPath, true);\n",
    "\n",
    "        var reply = $\"\"\"\n",
    "            Stock price data has been plotted.\n",
    "            You can view the chart at {targetPath}\n",
    "            \"\"\";\n",
    "\n",
    "        return reply;\n",
    "    }\n",
    "}\n",
    "\n",
    "var kernel = new Kernel();\n",
    "var marketTools = new MarketTools(workingDirectory);\n",
    "var marketToolsPlugin = kernel.ImportPluginFromObject(marketTools);\n",
    "var marketToolsPluginMiddleware = new KernelPluginMiddleware(kernel, marketToolsPlugin);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var marketWatcher = new OpenAIChatAgent(\n",
    "    chatClient: chatClient,\n",
    "    name: \"Market_Watcher\",\n",
    "    systemMessage: \"\"\"\n",
    "    You are Market Watcher. You can gather stock price data.\n",
    "    \"\"\")\n",
    "    .RegisterMessageConnector()\n",
    "    .RegisterMiddleware(marketToolsPluginMiddleware)\n",
    "    .RegisterPrintMessage();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var dataAnalyst = new OpenAIChatAgent(\n",
    "    chatClient: chatClient,\n",
    "    name: \"Data_Analyst\",\n",
    "    systemMessage: \"\"\"\n",
    "    You are Data Analyst. You can plot stock price data.\n",
    "    \"\"\")\n",
    "    .RegisterMessageConnector()\n",
    "    .RegisterMiddleware(marketToolsPluginMiddleware)\n",
    "    .RegisterPrintMessage();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var writer = new OpenAIChatAgent(\n",
    "    chatClient: chatClient,\n",
    "    name: \"Writer\",\n",
    "    systemMessage: \"\"\"\n",
    "    Please write blogs in markdown format (with relevant titles) and put the content in pseudo ```md``` code block.\n",
    "    You take feedback from the admin and refine your blog.\n",
    "    \"\"\")\n",
    "    .RegisterMessageConnector()\n",
    "    .RegisterPrintMessage();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define the group chat\n",
    "\n",
    "Create a group chat admin to orchestrate the group chat\n",
    "\n",
    "The admin will be responsible for selecting the next speaker\n",
    "\n",
    "It will not directly participate in the conversation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var groupChatAdminAgent = new OpenAIChatAgent(\n",
    "    chatClient: chatClient,\n",
    "    name: \"Admin\")\n",
    "    .RegisterMessageConnector();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a speaker selection policy using workflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var workflow = new Graph();\n",
    "\n",
    "// user <=> planner\n",
    "workflow.AddTransition(Transition.Create(user, planner));\n",
    "workflow.AddTransition(Transition.Create(planner, user));\n",
    "\n",
    "// planner <=> marketWatcher\n",
    "workflow.AddTransition(Transition.Create(planner, marketWatcher));\n",
    "workflow.AddTransition(Transition.Create(marketWatcher, planner));\n",
    "\n",
    "// planner <=> dataAnalyst\n",
    "workflow.AddTransition(Transition.Create(planner, dataAnalyst));\n",
    "workflow.AddTransition(Transition.Create(dataAnalyst, planner));\n",
    "\n",
    "// planner <=> writer\n",
    "workflow.AddTransition(Transition.Create(planner, writer));\n",
    "workflow.AddTransition(Transition.Create(writer, planner));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a group chat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "var groupChat = new GroupChat(\n",
    "    admin: groupChatAdminAgent,\n",
    "    workflow: workflow,\n",
    "    members: [user, planner, marketWatcher, dataAnalyst, writer]);\n",
    "\n",
    "// Add agent self-description as inital messages.\n",
    "groupChat.AddInitializeMessage(new TextMessage(Role.Assistant, \"I am market watcher. I can gather stock price data.\", from: marketWatcher.Name));\n",
    "groupChat.AddInitializeMessage(new TextMessage(Role.Assistant, \"I am data analyst. I can plot stock price data.\", from: dataAnalyst.Name));\n",
    "groupChat.AddInitializeMessage(new TextMessage(Role.Assistant, \"I am writer. I can write blogs in markdown format.\", from: writer.Name));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "start the group chat!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "from: Planner\n",
      "To complete the task of writing a blog post about the stock price performance of Nvidia in the past month, we will need to follow these steps:\n",
      "\n",
      "1. **Gather Stock Price Data**: The Market Watcher will need to collect the stock price data for Nvidia over the past month (from March 23, 2024, to April 23, 2024).\n",
      "\n",
      "Once the Market Watcher completes this step, I will check the progress and instruct the remaining steps. Let's proceed!\n",
      "\n",
      "AggregateMessage from Market_Watcher\n",
      "--------------------\n",
      "ToolCallMessage:\n",
      "ToolCallMessage from Market_Watcher\n",
      "--------------------\n",
      "- RetrieveStockPrice: {\"symbol\":\"NVDA\",\"from\":\"2024-03-23\",\"to\":\"2024-04-23\"}\n",
      "--------------------\n",
      "\n",
      "ToolCallResultMessage:\n",
      "ToolCallResultMessage from Market_Watcher\n",
      "--------------------\n",
      "- RetrieveStockPrice: Retrieving stock price data for NVDA from 2024-03-23 to 2024-04-23...\n",
      "2024-03-25    950.020020\n",
      "2024-03-26    925.609985\n",
      "2024-03-27    902.500000\n",
      "2024-03-28    903.559998\n",
      "2024-04-01    903.630005\n",
      "2024-04-02    894.520020\n",
      "2024-04-03    889.640015\n",
      "2024-04-04    859.049988\n",
      "2024-04-05    880.080017\n",
      "2024-04-08    871.330017\n",
      "2024-04-09    853.539978\n",
      "2024-04-10    870.390015\n",
      "2024-04-11    906.159973\n",
      "2024-04-12    881.859985\n",
      "2024-04-15    860.010010\n",
      "2024-04-16    874.150024\n",
      "2024-04-17    840.349976\n",
      "2024-04-18    846.710022\n",
      "2024-04-19    762.000000\n",
      "2024-04-22    795.179993\n",
      "\n",
      "--------------------\n",
      "\n",
      "--------------------\n",
      "\n",
      "from: Planner\n",
      "The Market Watcher has successfully gathered the stock price data for Nvidia from March 23, 2024, to April 23, 2024. \n",
      "\n",
      "Next, we will proceed with the following step:\n",
      "\n",
      "2. **Plot Stock Price Data**: The Data Analyst will now need to create a plot of the stock price data collected for Nvidia over the past month.\n",
      "\n",
      "Once the Data Analyst completes this step, I will check the progress and instruct the remaining steps. Let's proceed!\n",
      "\n",
      "AggregateMessage from Data_Analyst\n",
      "--------------------\n",
      "ToolCallMessage:\n",
      "ToolCallMessage from Data_Analyst\n",
      "--------------------\n",
      "- PlotStockLineChart: {\"symbol\":\"NVDA\",\"close\":[950.02002,925.609985,902.5,903.559998,903.630005,894.52002,889.640015,859.049988,880.080017,871.330017,853.539978,870.390015,906.159973,881.859985,860.01001,874.150024,840.349976,846.710022,762.0,795.179993],\"date\":[\"2024-03-25\",\"2024-03-26\",\"2024-03-27\",\"2024-03-28\",\"2024-04-01\",\"2024-04-02\",\"2024-04-03\",\"2024-04-04\",\"2024-04-05\",\"2024-04-08\",\"2024-04-09\",\"2024-04-10\",\"2024-04-11\",\"2024-04-12\",\"2024-04-15\",\"2024-04-16\",\"2024-04-17\",\"2024-04-18\",\"2024-04-19\",\"2024-04-22\"]}\n",
      "--------------------\n",
      "\n",
      "ToolCallResultMessage:\n",
      "ToolCallResultMessage from Data_Analyst\n",
      "--------------------\n",
      "- PlotStockLineChart: Stock price data has been plotted.\n",
      "You can view the chart at c:\\Users\\xiaoyuz\\source\\repos\\AI-Agentic-Design-Patterns-with-AutoGen.Net\\notebook\\work\\Stock Price Performance of NVDA from 2024-03-25 to 2024-04-22.png\n",
      "--------------------\n",
      "\n",
      "--------------------\n",
      "\n",
      "from: Planner\n",
      "The Data Analyst has successfully plotted the stock price data for Nvidia.\n",
      "\n",
      "Next, we will proceed with the final step:\n",
      "\n",
      "3. **Write the Blog Post**: The Writer will now need to create a blog post in markdown format, incorporating the stock price data and the plot created by the Data Analyst.\n",
      "\n",
      "Once the Writer completes this step, I will check the progress and confirm if the task is completed. Let's proceed!\n",
      "\n",
      "from: Writer\n",
      "```md\n",
      "# Nvidia Stock Price Performance: March 23, 2024 - April 23, 2024\n",
      "\n",
      "In the past month, Nvidia's stock (NVDA) has experienced significant fluctuations. Below, we analyze the stock price data collected from March 23, 2024, to April 23, 2024.\n",
      "\n",
      "## Stock Price Data\n",
      "\n",
      "The following table summarizes Nvidia's stock prices over the past month:\n",
      "\n",
      "| Date       | Stock Price (USD) |\n",
      "|------------|--------------------|\n",
      "| 2024-03-25 | 950.02             |\n",
      "| 2024-03-26 | 925.61             |\n",
      "| 2024-03-27 | 902.50             |\n",
      "| 2024-03-28 | 903.56             |\n",
      "| 2024-04-01 | 903.63             |\n",
      "| 2024-04-02 | 894.52             |\n",
      "| 2024-04-03 | 889.64             |\n",
      "| 2024-04-04 | 859.05             |\n",
      "| 2024-04-05 | 880.08             |\n",
      "| 2024-04-08 | 871.33             |\n",
      "| 2024-04-09 | 853.54             |\n",
      "| 2024-04-10 | 870.39             |\n",
      "| 2024-04-11 | 906.16             |\n",
      "| 2024-04-12 | 881.86             |\n",
      "| 2024-04-15 | 860.01             |\n",
      "| 2024-04-16 | 874.15             |\n",
      "| 2024-04-17 | 840.35             |\n",
      "| 2024-04-18 | 846.71             |\n",
      "| 2024-04-19 | 762.00             |\n",
      "| 2024-04-22 | 795.18             |\n",
      "\n",
      "## Price Trends\n",
      "\n",
      "As observed, Nvidia’s stock price started at a high of $950.02 on March 25, 2024, but faced a downward trend, hitting a low of $762.00 on April 19, 2024. The stock price showed a slight recovery towards the end of the month, closing at $795.18 on April 22, 2024.\n",
      "\n",
      "![Stock Price Performance of NVDA](c:\\Users\\xiaoyuz\\source\\repos\\AI-Agentic-Design-Patterns-with-AutoGen.Net\\notebook\\work\\Stock Price Performance of NVDA from 2024-03-25 to 2024-04-22.png)\n",
      "\n",
      "## Conclusion\n",
      "\n",
      "The month saw a volatile trading period for Nvidia, influenced by various market factors including earnings reports and broader market trends. Investors should continue to monitor these developments as they could impact Nvidia’s stock performance moving forward.\n",
      "\n",
      "---\n",
      "\n",
      "*Note: All prices are in USD and reflect closing values on the respective dates.*\n",
      "```\n",
      "\n",
      "Please review this blog post and let me know if there are any changes or additional information you'd like to include!\n",
      "\n",
      "from: Planner\n",
      "The Writer has successfully created the blog post about Nvidia's stock price performance over the past month. The content is well-structured and includes the necessary data and analysis. \n",
      "\n",
      "Since there are no requests for changes or additional information, I will consider the task completed.\n",
      "\n",
      "**Task completed.**\n",
      "\n"
     ]
    }
   ],
   "source": [
    "var chatHistory = new List<IMessage>()\n",
    "{\n",
    "    new TextMessage(Role.User, task, from: user.Name),\n",
    "};\n",
    "\n",
    "\n",
    "await foreach (var reply in groupChat.SendAsync(chatHistory, maxRound: 20))\n",
    "{\n",
    "    chatHistory.Add(reply);\n",
    "\n",
    "    if (reply.GetContent()?.ToLower().Contains(\"task completed\") is true)\n",
    "    {\n",
    "        break;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "retrieve the final blog post from writer and save it to a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The blog post has been written and saved to c:\\Users\\xiaoyuz\\source\\repos\\AI-Agentic-Design-Patterns-with-AutoGen.Net\\notebook\\work\\nvidia-blog.md\r\n"
     ]
    }
   ],
   "source": [
    "var finalBlogPath = Path.Combine(workingDirectory, \"nvidia-blog.md\");\n",
    "var finalBlog = chatHistory.Where(c => c.From == writer.Name).Last().GetContent();\n",
    "// retrieve the content between ```md``` code block\n",
    "var blogContent = finalBlog!.Split(\"```md\")[1].Split(\"```\")[0].Trim();\n",
    "await File.WriteAllTextAsync(finalBlogPath, blogContent);\n",
    "\n",
    "// Print the final blog post path\n",
    "Console.WriteLine($\"The blog post has been written and saved to {finalBlogPath}\");"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "python"
  },
  "polyglot_notebook": {
   "kernelInfo": {
    "defaultKernelName": "csharp",
    "items": [
     {
      "aliases": [],
      "name": "csharp"
     }
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}