05-Adding_Memory.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "01a8b5c0-87cb-4302-8e3c-dc809d0039fb",
   "metadata": {},
   "source": [
    "# Understanding Memory in LLMs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2f73380-6395-4e9f-9c83-3f47a5d7e292",
   "metadata": {},
   "source": [
    "In the previous Notebooks, we successfully explored how OpenAI models can enhance the results from Azure AI Search queries. \n",
    "\n",
    "However, we have yet to discover how to engage in a conversation with the LLM. With [Microsoft Copilot](http://chat.bing.com/), for example, this is possible, as it can understand and reference the previous responses.\n",
    "\n",
    "There is a common misconception that LLMs (Large Language Models) have memory. This is not true. While they possess knowledge, they do not retain information from previous questions asked to them.\n",
    "\n",
    "In this Notebook, our goal is to illustrate how we can effectively \"endow the LLM with memory\" by employing prompts and context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "733c782e-204c-47d0-8dae-c9df7091ab23",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "from langchain_community.chat_message_histories import ChatMessageHistory, CosmosDBChatMessageHistory\n",
    "from langchain_core.chat_history import BaseChatMessageHistory\n",
    "from langchain_core.runnables import ConfigurableFieldSpec\n",
    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
    "from langchain_openai import AzureChatOpenAI\n",
    "from langchain_openai import AzureOpenAIEmbeddings\n",
    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "from operator import itemgetter\n",
    "from typing import List\n",
    "\n",
    "from IPython.display import Markdown, HTML, display  \n",
    "\n",
    "def printmd(string):\n",
    "    display(Markdown(string))\n",
    "\n",
    "#custom libraries that we will use later in the app\n",
    "from common.utils import CustomAzureSearchRetriever, get_answer\n",
    "from common.prompts import DOCSEARCH_PROMPT_TEXT\n",
    "\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv(\"credentials.env\")\n",
    "\n",
    "import logging\n",
    "\n",
    "# Get the root logger\n",
    "logger = logging.getLogger()\n",
    "# Set the logging level to a higher level to ignore INFO messages\n",
    "logger.setLevel(logging.WARNING)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6bc63c55-a57d-49a7-b6c7-0f18bca8199e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set the ENV variables that Langchain needs to connect to Azure OpenAI\n",
    "os.environ[\"OPENAI_API_VERSION\"] = os.environ[\"AZURE_OPENAI_API_VERSION\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dc72b22-11c2-4df0-91b8-033d01829663",
   "metadata": {},
   "source": [
    "### Let's start with the basics\n",
    "Let's use a very simple example to see if the GPT model of Azure OpenAI have memory. We again will be using langchain to simplify our code "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "3eef5dc9-8b80-4085-980c-865fa41fa1f6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "QUESTION = \"tell me chinese medicines that help fight covid-19\"\n",
    "FOLLOW_UP_QUESTION = \"What was my prior question?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "a00181d5-bd76-4ce4-a256-75ac5b58c60f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "COMPLETION_TOKENS = 1000\n",
    "# Create an OpenAI instance\n",
    "llm = AzureChatOpenAI(deployment_name=os.environ[\"GPT4o_DEPLOYMENT_NAME\"], \n",
    "                      temperature=0.5, max_tokens=COMPLETION_TOKENS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "9502d0f1-fddf-40d1-95d2-a1461dcc498a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# We create a very simple prompt template, just the question as is:\n",
    "output_parser = StrOutputParser()\n",
    "prompt = ChatPromptTemplate.from_messages([\n",
    "    (\"system\", \"You are an assistant that give thorough responses to users.\"),\n",
    "    (\"user\", \"{input}\")\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c5c9903e-15c7-4e05-87a1-58e5a7917ba2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Chinese medicine has a long history and a rich tradition of using herbs and other natural substances to treat various ailments. During the COVID-19 pandemic, some Traditional Chinese Medicine (TCM) practices and formulations have been explored for their potential to support the immune system and alleviate symptoms. It's important to note that while TCM may provide supportive care, it should not replace conventional medical treatments for COVID-19. Always consult with a healthcare professional before starting any new treatment.\n",
       "\n",
       "Here are some TCM herbs and formulations that have been studied or used in the context of COVID-19:\n",
       "\n",
       "### 1. **Lianhua Qingwen Capsule (连花清瘟胶囊)**\n",
       "- **Ingredients:** Forsythia fruit, Honeysuckle flower, Ephedra, Bitter Apricot Seed, Gypsum, Isatis root, Dryopteris root, Rhubarb, Houttuynia, Patchouli, Rhodiola, and Menthol.\n",
       "- **Uses:** This formulation is often used for treating flu-like symptoms, including fever, cough, and fatigue. Some studies suggest it may help alleviate symptoms of COVID-19.\n",
       "\n",
       "### 2. **Shuanghuanglian Oral Liquid (双黄连口服液)**\n",
       "- **Ingredients:** Honeysuckle, Scutellaria, and Forsythia.\n",
       "- **Uses:** Traditionally used to clear heat and detoxify, it has been explored for its potential antiviral properties.\n",
       "\n",
       "### 3. **Jinhua Qinggan Granule (金花清感颗粒)**\n",
       "- **Ingredients:** Honeysuckle, Forsythia, Ephedra, Bitter Apricot Seed, Gypsum, Isatis root, Dryopteris root, Rhubarb, Houttuynia, Patchouli, and Rhodiola.\n",
       "- **Uses:** Used for treating respiratory infections and reducing fever and cough.\n",
       "\n",
       "### 4. **Qingfei Paidu Decoction (清肺排毒汤)**\n",
       "- **Ingredients:** A combination of 21 herbs including Ephedra, Licorice, Gypsum, Cinnamon Twig, and others.\n",
       "- **Uses:** This formulation has been recommended by the Chinese government for treating COVID-19 symptoms, particularly in mild to moderate cases.\n",
       "\n",
       "### 5. **Xuebijing Injection (血必净注射液)**\n",
       "- **Ingredients:** A combination of herbs including Carthamus, Salvia, Angelica, Paeonia, and Ligusticum.\n",
       "- **Uses:** Used in severe cases to reduce inflammation and improve microcirculation.\n",
       "\n",
       "### 6. **Pneumonia No. 1 Formula (肺炎1号方)**\n",
       "- **Ingredients:** A specific formulation used in Wuhan during the early stages of the pandemic, containing various herbs aimed at treating lung infections.\n",
       "- **Uses:** Targeted at treating symptoms like fever, cough, and fatigue.\n",
       "\n",
       "### 7. **Maxingshigan-Yinqiaosan (麻杏石甘-银翘散)**\n",
       "- **Ingredients:** Ephedra, Apricot Seed, Gypsum, Licorice, Honeysuckle, and Forsythia.\n",
       "- **Uses:** Used to clear heat and detoxify, addressing symptoms like fever and cough.\n",
       "\n",
       "### General Herbs Used in TCM for Respiratory Health:\n",
       "- **Astragalus (Huangqi, 黄芪):** Known for its immune-boosting properties.\n",
       "- **Licorice Root (Gancao, 甘草):** Used for its anti-inflammatory and antiviral effects.\n",
       "- **Isatis Root (Banlangen, 板蓝根):** Commonly used for its antiviral properties.\n",
       "- **Honeysuckle (Jinyinhua, 金银花):** Used for its heat-clearing and detoxifying effects.\n",
       "\n",
       "### Important Considerations:\n",
       "1. **Consult Healthcare Providers:** Always consult with a healthcare professional, particularly one knowledgeable in TCM, before starting any new treatment.\n",
       "2. **Combination with Conventional Medicine:** TCM should complement, not replace, conventional medical treatments.\n",
       "3. **Quality and Source of Herbs:** Ensure that the herbs and formulations are sourced from reputable suppliers to avoid contamination or adulteration.\n",
       "\n",
       "### Research and Efficacy:\n",
       "While there is some preliminary research and anecdotal evidence supporting the use of these TCM formulations for COVID-19, more rigorous clinical trials are needed to confirm their efficacy and safety. The integration of TCM with Western medicine has shown promise in some cases, but it should be approached with caution and professional guidance."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's see what the GPT model responds\n",
    "chain = prompt | llm | output_parser\n",
    "response_to_initial_question = chain.invoke({\"input\": QUESTION})\n",
    "display(Markdown(response_to_initial_question))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "99acaf3c-ce68-4b87-b24a-6065b15ff9a8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "I'm sorry, but I don't have access to previous interactions or questions you've asked. Each session is independent and doesn't retain any information from past interactions. How can I assist you today?"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Now let's ask a follow up question\n",
    "printmd(chain.invoke({\"input\": FOLLOW_UP_QUESTION}))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3e1c143-c95f-4566-a8b4-af8c42f08dd2",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "As you can see, it doesn't remember what it just responded, sometimes it responds based only on the system prompt, or just randomly. This proof that the LLM does NOT have memory and that we need to give the memory as a a conversation history as part of the prompt, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "0946ce71-6285-432e-b011-9c2dc1ba7b8a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "hist_prompt = ChatPromptTemplate.from_template(\n",
    "\"\"\"\n",
    "    {history}\n",
    "    Human: {question}\n",
    "    AI:\n",
    "\"\"\"\n",
    ")\n",
    "chain = hist_prompt | llm | output_parser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "6d088e51-e5eb-4143-b87d-b2be429eb864",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "Conversation_history = \"\"\"\n",
    "Human: {question}\n",
    "AI: {response}\n",
    "\"\"\".format(question=QUESTION, response=response_to_initial_question)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "d99e34ad-5539-44dd-b080-3ad05efd2f01",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Your prior question was: \"tell me chinese medicines that help fight covid-19\""
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(chain.invoke({\"history\":Conversation_history, \"question\": FOLLOW_UP_QUESTION}))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045e5af6-55d6-4353-b3f6-3275c95db00a",
   "metadata": {},
   "source": [
    "**Bingo!**, so we now know how to create a chatbot using LLMs, we just need to keep the state/history of the conversation and pass it as context every time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eafd1694-0077-4aa8-bd01-e9f763ce36a3",
   "metadata": {},
   "source": [
    "## Now that we understand the concept of memory via adding history as a context, let's go back to our GPT Smart Search engine"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9787ffb6-2b11-4b03-92fc-9443cd1f2ab9",
   "metadata": {},
   "source": [
    "From Langchain website:\n",
    "    \n",
    "A memory system needs to support two basic actions: reading and writing. Recall that every chain defines some core execution logic that expects certain inputs. Some of these inputs come directly from the user, but some of these inputs can come from memory. A chain will interact with its memory system twice in a given run.\n",
    "\n",
    "    AFTER receiving the initial user inputs but BEFORE executing the core logic, a chain will READ from its memory system and augment the user inputs.\n",
    "    AFTER executing the core logic but BEFORE returning the answer, a chain will WRITE the inputs and outputs of the current run to memory, so that they can be referred to in future runs.\n",
    "    \n",
    "So this process adds delays to the response, but it is a necessary delay :)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f36e8f14-e566-4ae9-a7d4-6dee7f469dad",
   "metadata": {},
   "source": [
    "![image](./images/memory_diagram.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "ef9f459b-e8b8-40b9-a94d-80c079968594",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "index1_name = \"srch-index-files\"\n",
    "index2_name = \"srch-index-csv\"\n",
    "index3_name = \"srch-index-books\"\n",
    "indexes = [index1_name, index2_name, index3_name]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "b01852c2-6192-496c-adff-4270f9380469",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Initialize our custom retriever \n",
    "retriever = CustomAzureSearchRetriever(indexes=indexes, topK=10, reranker_threshold=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d9a3378-1c40-47c5-8ef7-6f68f4c58029",
   "metadata": {},
   "source": [
    "**Prompt Template Definition**\n",
    "\n",
    "If you check closely below, there is an optional variable in the `DOCSEARCH_PROMPT` called `history`. It is basically a placeholder were we will inject the conversation in the prompt so the LLM is aware of it before it answers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "cb3d9576-c052-4b3d-8d95-6604e19ca4cb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "DOCSEARCH_PROMPT = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\"system\", DOCSEARCH_PROMPT_TEXT + \"\\n\\nCONTEXT:\\n{context}\\n\\n\"),\n",
    "        MessagesPlaceholder(variable_name=\"history\", optional=True),\n",
    "        (\"human\", \"{question}\"),\n",
    "    ]\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "035fa6e6-226c-400f-a504-30255385f43b",
   "metadata": {},
   "source": [
    "**Now let's add memory to it:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "3c8c9381-08d0-4808-9ab1-78156ca1be6e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "store = {} # Our first memory will be a dictionary in memory\n",
    "\n",
    "# We have to define a custom function that takes a session_id and looks somewhere\n",
    "# (in this case in a dictionary in memory) for the conversation\n",
    "def get_session_history(session_id: str) -> BaseChatMessageHistory:\n",
    "    if session_id not in store:\n",
    "        store[session_id] = ChatMessageHistory()\n",
    "    return store[session_id]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "48ff51e1-2b1e-4c67-965d-1c2e2f55e005",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# We use our original chain with the retriever but removing the StrOutputParser\n",
    "chain = (\n",
    "    {\n",
    "        \"context\": itemgetter(\"question\") | retriever, \n",
    "        \"question\": itemgetter(\"question\"),\n",
    "        \"history\": itemgetter(\"history\")\n",
    "    }\n",
    "    | DOCSEARCH_PROMPT\n",
    "    | llm\n",
    ")\n",
    "\n",
    "## Then we pass the above chain to another chain that adds memory to it\n",
    "\n",
    "output_parser = StrOutputParser()\n",
    "\n",
    "chain_with_history = RunnableWithMessageHistory(\n",
    "    chain,\n",
    "    get_session_history,\n",
    "    input_messages_key=\"question\",\n",
    "    history_messages_key=\"history\",\n",
    ") | output_parser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "0e582915-243f-42cb-bb1e-c35a20ee0b9f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This is where we configure the session id\n",
    "config={\"configurable\": {\"session_id\": \"abc123\"}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d91a7ff4-6148-459d-917c-37302805dd09",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Traditional Chinese Medicine (TCM) has been used in various ways to help fight COVID-19. Several specific medicines and formulations have been recommended and utilized for their potential benefits. Here are some notable mentions:\n",
       "\n",
       "1. **Qingfei Paidu Decoction**: This formulation has been recommended by the National Health Commission of the People’s Republic of China and the National Administration of Traditional Chinese Medicine for the treatment of COVID-19. It has shown good clinical efficacy and potential in treating the disease [[6]](https://doi.org/10.19540/j.cnki.cjcmm.20200219.501; https://www.ncbi.nlm.nih.gov/pubmed/32281335/).\n",
       "\n",
       "2. **Shuang Huang Lian Kou Fu Ye**: This is one of the traditional Chinese medicines that have been used to attenuate COVID-19. It works by triggering the inflammation pathway, such as the neuraminidase blocker, to fight the SARS-CoV-2 virus [[1]](https://doi.org/10.1101/2020.04.10.20060376).\n",
       "\n",
       "3. **Bu Huan Jin Zheng Qi San and Da Yuan Yin**: This combination is another traditional Chinese medicine used for treating COVID-19, focusing on the inflammation pathway [[1]](https://doi.org/10.1101/2020.04.10.20060376).\n",
       "\n",
       "4. **Xue Bi Jing Injection**: This traditional Chinese medicine has also been used to treat COVID-19 by targeting similar pathways [[1]](https://doi.org/10.1101/2020.04.10.20060376).\n",
       "\n",
       "5. **Qing Fei Pai Du Tang**: Another formulation used to combat COVID-19 by triggering the inflammation pathway [[1]](https://doi.org/10.1101/2020.04.10.20060376).\n",
       "\n",
       "6. **Astragalus membranaceus and Yupingfeng Powder**: These are often used in various prevention programs for reinforcing vital qi and preventing COVID-19 [[2]](https://doi.org/10.7501/j.issn.0253-2670.2020.04.006).\n",
       "\n",
       "These TCM formulations and medicines have been integrated into COVID-19 treatment protocols and have shown potential benefits in managing the disease, although their efficacy and mechanisms are still subject to further research and validation."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(chain_with_history.invoke({\"question\": QUESTION}, config=config))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "25dfc233-450f-4671-8f1c-0b446e46f048",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Your prior question was: \"tell me chinese medicines that help fight covid-19\""
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Remembers\n",
    "printmd(chain_with_history.invoke({\"question\": FOLLOW_UP_QUESTION},config=config))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "c67073c2-9a82-4e44-a9e2-48fe868c1634",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "You're welcome! If you have any more questions in the future, feel free to ask. Goodbye!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Remembers\n",
    "printmd(chain_with_history.invoke({\"question\": \"Thank you! Good bye\"},config=config))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87405173",
   "metadata": {},
   "source": [
    "## Using CosmosDB as persistent memory\n",
    "\n",
    "Previously, we  added local RAM memory to our chatbot. However, it is not persistent, it gets deleted once the app user's session is terminated. It is necessary then to use a Database for persistent storage of each of the bot user conversations, not only for Analytics and Auditing, but also if we wish to provide recommendations in the future. \n",
    "\n",
    "In the next notebook we are going to explain how to use an external Database (CosmosDB) to keep the state of the conversation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6789cada-23a3-451a-a91a-0906ceb0bd14",
   "metadata": {},
   "source": [
    "# Summary\n",
    "##### Adding memory to our application allows the user to have a conversation, however this feature is not something that comes with the LLM, but instead, memory is something that we must provide to the LLM in form of context of the question.\n",
    "\n",
    "We added persitent memory using local RAM.\n",
    "\n",
    "We also can notice that the current chain that we are using is smart, but not that much. Although we have given memory to it, many times it searches for similar docs everytime, regardless of the input. This doesn't seem efficient, but regardless, we are very close to finish our first RAG talk-to-your-data Bot.\n",
    "\n",
    "Note:The use of `RunnableWithMessageHistory` in this notebook is for example purposes. We will see later (on the next notebooks), that we recomend the use of memory state and graphs in order to inject memory into a bot. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c629ebf4-aced-45b7-a6a2-315810d37d48",
   "metadata": {},
   "source": [
    "# NEXT\n",
    "We know now how to do a Smart Search Engine that can power a chatbot!! great!\n",
    "\n",
    "In the next notebook 6, we are going to build our first RAG bot. In order to do this we will introduce the concept of Agents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f53a8f7a-5e28-4d5f-9a33-0a3be0536b0f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10 - SDK v2",
   "language": "python",
   "name": "python310-sdkv2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}